Uploaded 3 files

app, requirements and readme added

README.md

@@ -1,14 +1,42 @@
----
-title: Dcgan Mnist Demo
-emoji: 🐢
-colorFrom: blue
-colorTo: blue
-sdk: gradio
-sdk_version: 5.26.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: Space for deploying the dcgan-mnist app
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# DCGAN MNIST Generator
+
+This repository contains a Deep Convolutional GAN (DCGAN) trained on the MNIST dataset. The model generates handwritten-like digit images from random noise.
+
+## Model Architecture
+
+The model implementation is based on the paper [Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks](http://arxiv.org/abs/1511.06434).
+
+- Generator architecture: 5 transposed convolutional layers with batch normalization
+- Latent space dimension: 100
+- Output: 64x64 grayscale images
+
+## Demo App
+
+The included Gradio app allows you to generate new MNIST-like images using the pre-trained model.
+
+### Running Locally
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Run the app:
+```bash
+python app.py
+```
+
+### Features
+
+- Generate multiple images at once
+- Set a random seed for reproducible outputs
+- Visualize the generated images in a grid
+
+## Training Details
+
+This model was trained for 25 epochs on the MNIST dataset using PyTorch. For optimal results, the model checkpoint from epoch 21 is used for inference, as it produced the most realistic images without mode collapse.
+
+## Acknowledgments
+
+- Original DCGAN implementation based on [PyTorch examples](https://github.com/pytorch/examples/tree/master/dcgan)
+- Training was tracked using Weights & Biases

app.py

@@ -0,0 +1,107 @@
+import torch
+import torch.nn as nn
+import torchvision.utils as vutils
+import gradio as gr
+import numpy as np
+
+
+# Define Generator architecture - must match the architecture used during training
+class Generator(nn.Module):
+    def __init__(self, ngpu=1, nz=100, ngf=64, nc=1):
+        super(Generator, self).__init__()
+        self.ngpu = ngpu
+        self.main = nn.Sequential(
+            # input is Z, going into a convolution
+            nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False),
+            nn.BatchNorm2d(ngf * 8),
+            nn.ReLU(True),
+            # state size. (ngf*8) x 4 x 4
+            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf * 4),
+            nn.ReLU(True),
+            # state size. (ngf*4) x 8 x 8
+            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf * 2),
+            nn.ReLU(True),
+            # state size. (ngf*2) x 16 x 16
+            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf),
+            nn.ReLU(True),
+            # state size. (ngf) x 32 x 32
+            nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False),
+            nn.Tanh()
+            # state size. (nc) x 64 x 64
+        )
+
+    def forward(self, input):
+        return self.main(input)
+
+
+# Load the generator
+def load_model(model_path):
+    # Create the generator and load the saved weights
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    netG = Generator().to(device)
+    netG.load_state_dict(torch.load(model_path, map_location=device))
+    netG.eval()  # Set to evaluation mode
+    return netG, device
+
+
+# Generate images using the model
+def generate_images(num_images=16, seed=None, model_path="models/netG_epoch_21.pth"):
+    # Load the model
+    netG, device = load_model(model_path)
+
+    # Set random seed for reproducibility if provided
+    if seed is not None:
+        torch.manual_seed(seed)
+        np.random.seed(seed)
+
+    # Generate latent vectors
+    nz = 100  # Size of the latent vector (must match the model)
+    noise = torch.randn(num_images, nz, 1, 1, device=device)
+
+    # Generate fake images
+    with torch.no_grad():
+        fake_images = netG(noise).detach().cpu()
+
+    # Convert to grid for display
+    grid = vutils.make_grid(fake_images, padding=2, normalize=True, nrow=int(np.sqrt(num_images)))
+
+    # Convert from tensor to numpy array for Gradio
+    grid_np = grid.numpy().transpose((1, 2, 0))
+
+    # Convert from [-1, 1] to [0, 1] range for display
+    grid_np = (grid_np + 1) / 2.0
+
+    return grid_np
+
+
+# Create Gradio interface
+def create_gradio_app():
+    with gr.Blocks(title="DCGAN MNIST Generator") as app:
+        gr.Markdown("# DCGAN MNIST Generator")
+        gr.Markdown("Generate MNIST-like digits using a Deep Convolutional GAN")
+
+        with gr.Row():
+            with gr.Column():
+                num_images = gr.Slider(minimum=1, maximum=64, value=16, step=1, label="Number of Images")
+                seed = gr.Number(label="Random Seed (leave blank for random)", precision=0)
+                generate_button = gr.Button("Generate Images")
+
+            with gr.Column():
+                output_image = gr.Image(label="Generated Images")
+
+        generate_button.click(fn=generate_images, inputs=[num_images, seed], outputs=output_image)
+
+        gr.Markdown("## About")
+        gr.Markdown("This model was trained using PyTorch DCGAN implementation on the MNIST dataset. "
+                    "It generates new handwritten digit-like images from random noise.")
+
+    return app
+
+
+# Launch the app if the script is run directly
+if __name__ == "__main__":
+    app = create_gradio_app()
+    app.launch()

requirements.txt

@@ -0,0 +1,5 @@
+torch>=2.0.0
+torchvision>=0.15.0
+gradio>=3.50.0
+numpy>=1.22.0
+Pillow>=9.0.0