Add MNIST GAN generator model with LFS tracking

README.md

@@ -1,13 +1,131 @@
 ---
-title: Mnist Gan Generator
-emoji: 🏢
-colorFrom: gray
+title: MNIST GAN - Handwritten Digit Generation
+colorFrom: purple
 colorTo: blue
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 4.0.0
 app_file: app.py
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MNIST GAN - Handwritten Digit Generation
+
+A Generative Adversarial Network trained on the MNIST dataset to generate realistic handwritten digit images.
+
+---
+
+## Author
+
+**Rohan Jain**  
+- [LinkedIn](https://www.linkedin.com/in/jaroh23/)  
+- [GitHub](https://github.com/rohanjain2312)
+
+---
+
+## Model Summary
+
+| Property | Details |
+|-----------|----------|
+| Architecture | Fully Connected GAN |
+| Framework | PyTorch 2.0+ |
+| Dataset | MNIST (60,000 training images) |
+| Training Epochs | 200 |
+| Batch Size | 128 |
+| Image Resolution | 28×28 pixels |
+
+---
+
+## Technical Architecture
+
+**Generator:**  
+- Input: 100-dimensional latent vector
+- Layers: Linear(100→128) → LeakyReLU → Linear(128→256) → LeakyReLU → Linear(256→512) → LeakyReLU → Linear(512→784) → Tanh
+- Output: 28×28 grayscale image
+
+**Discriminator:**  
+- Input: 784-dimensional flattened image
+- Layers: Linear(784→512) → LeakyReLU → Linear(512→256) → LeakyReLU → Linear(256→1) → Sigmoid
+- Output: Real/Fake probability
+
+**Training Configuration:**
+- Loss Function: Binary Cross-Entropy
+- Optimizer: Adam (lr=0.0002, betas=(0.5, 0.999))
+- Normalization: [-1, 1] range
+
+---
+
+## Training Results
+
+| Epoch | Image Quality |
+|-------|---------------|
+| 1 | Random noise |
+| 50 | Faint digit structures |
+| 100 | Recognizable digits |
+| 150 | Clear, defined digits |
+| 200 | High-quality handwritten digits |
+
+**Loss Metrics:**
+- Discriminator Loss (Stabilized): 0.31-0.49
+- Generator Loss (Stabilized): 1.33-1.99
+
+---
+
+## Usage
+
+**Local Installation:**
+```bash
+git clone https://huggingface.co/spaces/rohanjain2312/MNIST-GAN
+cd MNIST-GAN
+pip install -r requirements.txt
+python app.py
+```
+
+**Programmatic Generation:**
+```python
+import torch
+from model import Generator
+
+generator = Generator(latent_dim=100, img_shape=(1, 28, 28))
+generator.load_state_dict(torch.load('generator.pth', map_location='cpu'))
+generator.eval()
+
+with torch.no_grad():
+    z = torch.randn(1, 100)
+    img = generator(z)
+```
+
+---
+
+## Project Files
+
+| File | Description |
+|------|-------------|
+| `app.py` | Gradio interface |
+| `model.py` | Generator and Discriminator architectures |
+| `generator.pth` | Trained generator weights |
+| `discriminator.pth` | Trained discriminator weights |
+| `requirements.txt` | Python dependencies |
+
+---
+
+## Skills Demonstrated
+
+- Generative Adversarial Networks (GANs)
+- PyTorch Implementation
+- Adversarial Training Dynamics
+- Model Deployment (Hugging Face Spaces)
+- Gradio Interface Development
+
+---
+
+## Acknowledgments
+
+- Dataset: [MNIST Dataset - Yann LeCun](http://yann.lecun.com/exdb/mnist/)
+- Framework: [Generative Adversarial Nets - Goodfellow et al., 2014](https://arxiv.org/abs/1406.2661)
+
+---
+
+## License
+
+MIT License

app.py

@@ -0,0 +1,228 @@
+import gradio as gr
+import torch
+import numpy as np
+from PIL import Image
+import time
+from model import Generator, Discriminator
+
+# Configuration
+LATENT_DIM = 100
+IMG_SHAPE = (1, 28, 28)
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Load the trained models
+generator = Generator(latent_dim=LATENT_DIM, img_shape=IMG_SHAPE).to(DEVICE)
+generator.load_state_dict(torch.load('generator.pth', map_location=DEVICE))
+generator.eval()
+
+discriminator = Discriminator(img_shape=IMG_SHAPE).to(DEVICE)
+discriminator.load_state_dict(torch.load('discriminator.pth', map_location=DEVICE))
+discriminator.eval()
+
+def generate_digits(num_images, seed, show_confidence):
+    """Generate digits and return with optional confidence scores"""
+    start_time = time.time()
+    
+    with torch.no_grad():
+        # Set seed for reproducibility if provided
+        if seed != 0:
+            torch.manual_seed(seed)
+            np.random.seed(seed)
+        
+        # Generate random noise
+        num_images = int(num_images)
+        z = torch.randn(num_images, LATENT_DIM).to(DEVICE)
+        
+        # Generate images
+        generated_imgs = generator(z)
+        
+        # Get discriminator confidence
+        confidence_scores = discriminator(generated_imgs)
+        avg_confidence = confidence_scores.mean().item() * 100
+        
+        # Convert to numpy and denormalize
+        generated_imgs = generated_imgs.cpu().numpy()
+        generated_imgs = ((generated_imgs + 1) / 2 * 255).astype(np.uint8)
+        
+        # Create grid
+        grid_size = int(np.ceil(np.sqrt(num_images)))
+        grid_img = Image.new('L', (280 * grid_size, 280 * grid_size), color=255)
+        
+        for idx in range(num_images):
+            img_pil = Image.fromarray(generated_imgs[idx][0], mode='L')
+            img_pil = img_pil.resize((280, 280), Image.NEAREST)
+            row = idx // grid_size
+            col = idx % grid_size
+            grid_img.paste(img_pil, (col * 280, row * 280))
+    
+    generation_time = time.time() - start_time
+    
+    # Build info text
+    info_text = f"Generated {num_images} digit(s) in {generation_time:.3f}s"
+    if show_confidence:
+        info_text += f"\nDiscriminator Confidence: {avg_confidence:.1f}% (how 'real' the digits appear)"
+    
+    return grid_img, info_text
+
+def create_comparison_grid():
+    """Create a comparison showing training progress"""
+    # Create sample images at different seeds
+    seeds = [42, 123, 456, 789]
+    images = []
+    
+    with torch.no_grad():
+        for seed in seeds:
+            torch.manual_seed(seed)
+            z = torch.randn(1, LATENT_DIM).to(DEVICE)
+            img = generator(z)
+            img = ((img[0, 0].cpu().numpy() + 1) / 2 * 255).astype(np.uint8)
+            img_pil = Image.fromarray(img, mode='L')
+            img_pil = img_pil.resize((140, 140), Image.NEAREST)
+            images.append(img_pil)
+    
+    # Create grid
+    grid = Image.new('L', (280, 280), color=255)
+    for idx, img in enumerate(images):
+        row = idx // 2
+        col = idx % 2
+        grid.paste(img, (col * 140, row * 140))
+    
+    return grid
+
+# Create interface
+with gr.Blocks(title="MNIST GAN Generator", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # MNIST Handwritten Digit Generator
+        ### Using Generative Adversarial Networks (GAN)
+        
+        **Created by Rohan Jain** | [LinkedIn](https://www.linkedin.com/in/jaroh23/) | [GitHub](https://github.com/rohanjain2312)
+        """
+    )
+    
+    with gr.Tabs():
+        # Tab 1: Generate Digits
+        with gr.TabItem("Generate Digits"):
+            gr.Markdown("Generate new handwritten digits using the trained GAN model.")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    num_images = gr.Slider(
+                        minimum=1, 
+                        maximum=16, 
+                        value=4, 
+                        step=1, 
+                        label="Number of Digits",
+                        info="Generate 1-16 digits at once"
+                    )
+                    seed = gr.Number(
+                        value=0, 
+                        label="Random Seed",
+                        info="Use 0 for random, or set a number for reproducible results"
+                    )
+                    show_confidence = gr.Checkbox(
+                        value=True,
+                        label="Show Discriminator Confidence",
+                        info="Display how 'real' the generator fooled the discriminator"
+                    )
+                    generate_btn = gr.Button("Generate", variant="primary", size="lg")
+                
+                with gr.Column(scale=2):
+                    output_image = gr.Image(label="Generated Digits", type="pil")
+                    output_info = gr.Textbox(label="Generation Info", lines=2)
+            
+            generate_btn.click(
+                fn=generate_digits,
+                inputs=[num_images, seed, show_confidence],
+                outputs=[output_image, output_info]
+            )
+            
+            gr.Markdown("### Quick Examples")
+            gr.Examples(
+                examples=[
+                    [4, 42, True],
+                    [9, 123, True],
+                    [16, 456, False],
+                ],
+                inputs=[num_images, seed, show_confidence],
+                outputs=[output_image, output_info],
+                fn=generate_digits,
+                cache_examples=True,
+            )
+        
+        # Tab 2: Model Information
+        with gr.TabItem("Model Details"):
+            gr.Markdown("### Training Loss Curves")
+            gr.Image(value="loss_curve.png", label="Generator and Discriminator Loss During Training")
+            
+            gr.Markdown(
+                """
+                **Loss Analysis:**
+                - The discriminator loss (orange) stabilizes around 0.3-0.4, indicating it effectively distinguishes real from fake
+                - The generator loss (blue) shows typical adversarial dynamics, settling around 1.5-2.0
+                - The fluctuating losses indicate healthy adversarial balance between the two networks
+                """
+            )
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown(
+                        """
+                        ### Training Details
+                        
+                        **Architecture**: Fully Connected GAN  
+                        **Dataset**: MNIST (60,000 images)  
+                        **Epochs**: 200  
+                        **Batch Size**: 128  
+                        
+                        **Generator**:
+                        - Input: 100-dim random vector
+                        - Layers: 128 → 256 → 512 → 784
+                        - Output: 28×28 grayscale image
+                        
+                        **Discriminator**:
+                        - Input: 28×28 image (784 dims)
+                        - Layers: 512 → 256 → 1
+                        - Output: Real/Fake probability
+                        """
+                    )
+                
+                with gr.Column():
+                    gr.Markdown(
+                        """
+                        ### Training Results
+                        
+                        **Loss Metrics** (Final):
+                        - Discriminator Loss: ~0.32
+                        - Generator Loss: ~1.99
+                        
+                        **Training Evolution**:
+                        - Epoch 1: Random noise
+                        - Epoch 50: Faint structures
+                        - Epoch 100: Recognizable digits
+                        - Epoch 200: High-quality digits
+                        
+                        The adversarial training successfully balanced both networks, 
+                        resulting in realistic digit generation.
+                        """
+                    )
+            
+            gr.Markdown("### Sample Outputs (Different Seeds)")
+            comparison_img = create_comparison_grid()
+            gr.Image(value=comparison_img, label="Generated Samples", type="pil")
+    
+    gr.Markdown(
+        """
+        ---
+        ### About This Project
+        
+        This GAN was trained to generate handwritten digits by learning from the MNIST dataset. 
+        The generator creates images from random noise, while the discriminator learns to distinguish real from fake images.
+        Through adversarial training, the generator improves until it produces realistic digits.
+        
+        **Tech Stack**: PyTorch, Gradio, NumPy | **Training**: Google Colab (GPU) | **Deployment**: Hugging Face Spaces
+        """
+    )
+
+if __name__ == "__main__":
+    demo.launch()

discriminator.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7cd72eed1969132cc1e4ab317d1f7c2217988873bc96350e454ce42ba417d44
+size 2137405

generator.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71a3b34bfd986087d5606fb993800425662f9941d8bcf730f18608780d0cd473
+size 2322841

model.py

@@ -0,0 +1,43 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+class Generator(nn.Module):
+    def __init__(self, latent_dim=100, img_shape=(1, 28, 28)):
+        super().__init__()
+        self.img_shape = img_shape
+        
+        self.model = nn.Sequential(
+            nn.Linear(latent_dim, 128),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Linear(128, 256),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Linear(256, 512),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Linear(512, int(np.prod(img_shape))),
+            nn.Tanh()
+        )
+    
+    def forward(self, z):
+        img = self.model(z)
+        img = img.view(img.size(0), *self.img_shape)
+        return img
+
+
+class Discriminator(nn.Module):
+    def __init__(self, img_shape=(1, 28, 28)):
+        super().__init__()
+        
+        self.model = nn.Sequential(
+            nn.Linear(int(np.prod(img_shape)), 512),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Linear(512, 256),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Linear(256, 1),
+            nn.Sigmoid()
+        )
+    
+    def forward(self, img):
+        img_flat = img.view(img.size(0), -1)
+        validity = self.model(img_flat)
+        return validity

requirements.txt

@@ -0,0 +1,5 @@
+torch>=2.0.0
+torchvision>=0.15.0
+gradio>=4.0.0
+numpy>=1.24.0
+Pillow>=9.5.0