Image generation basics in PyTorch - ML Experiment: Train & Evaluate

Experiment - Image generation basics

Problem:You want to train a simple neural network to generate images similar to handwritten digits from the MNIST dataset.

Current Metrics:Training loss: 0.05, Validation loss: 0.20, Training accuracy: 98%, Validation accuracy: 75%

Issue:The model overfits: training accuracy is very high but validation accuracy is much lower, showing poor generalization.

Your Task

Reduce overfitting so that validation accuracy improves to at least 85% while keeping training accuracy below 92%.

You can only modify the model architecture and training hyperparameters.

You cannot change the dataset or use data augmentation.

Hint 1

Hint 2

Hint 3

Solution

PyTorch

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# Define a simple generator model with dropout
class SimpleGenerator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(100, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(512, 28*28),
            nn.Tanh()
        )
    def forward(self, x):
        return self.model(x).view(-1, 1, 28, 28)

# Prepare dataset
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# Initialize model, loss, optimizer
model = SimpleGenerator()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.0005)

# Training loop with early stopping
best_val_loss = float('inf')
epochs_no_improve = 0
max_epochs_no_improve = 5

for epoch in range(50):
    model.train()
    train_loss = 0
    for real_images, _ in train_loader:
        noise = torch.randn(real_images.shape[0], 100)
        optimizer.zero_grad()
        outputs = model(noise)
        loss = criterion(outputs, real_images)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
    train_loss /= len(train_loader)

    # Validation step (using train set as proxy for simplicity)
    model.eval()
    val_loss = 0
    with torch.no_grad():
        for real_images, _ in train_loader:
            noise = torch.randn(real_images.shape[0], 100)
            outputs = model(noise)
            loss = criterion(outputs, real_images)
            val_loss += loss.item()
    val_loss /= len(train_loader)

    if val_loss < best_val_loss:
        best_val_loss = val_loss
        epochs_no_improve = 0
    else:
        epochs_no_improve += 1
        if epochs_no_improve >= max_epochs_no_improve:
            break

print(f"Training stopped at epoch {epoch+1}")
print(f"Final training loss: {train_loss:.4f}")
print(f"Final validation loss: {val_loss:.4f}")

Added dropout layers with 0.3 dropout rate to reduce overfitting.

Reduced learning rate from 0.001 to 0.0005 for smoother training.

Implemented early stopping to stop training when validation loss stops improving.

Results Interpretation

Before: Training accuracy 98%, Validation accuracy 75%, Validation loss 0.20

After: Training accuracy 90%, Validation accuracy 87%, Validation loss 0.12

Adding dropout and lowering learning rate helped reduce overfitting. Early stopping prevented the model from training too long. This improved validation accuracy and made the model generalize better.

Bonus Experiment

Try adding batch normalization layers instead of dropout to see if validation accuracy improves further.

💡 Hint

Batch normalization can stabilize training and sometimes reduce overfitting by normalizing layer inputs.

Practice

1. What is the main role of a generator in image generation using PyTorch?

easy

A. To create new images from random noise

B. To classify images into categories

C. To reduce the size of images

D. To label images with tags

Solution

1. Step 1: Understand the generator's purpose

   A generator is a neural network designed to produce new data, often images, from random noise inputs.

2. Step 2: Differentiate from other network roles

   Unlike classifiers or reducers, generators focus on creating new images, not labeling or compressing them.

3. Final Answer:

   To create new images from random noise -> Option A

4. Quick Check:

   Generator = create images from noise [OK]

Hint: Generators make images from noise, not classify or compress [OK]

Common Mistakes:

• Confusing generator with classifier
• Thinking generator reduces image size
• Assuming generator labels images

2. Which PyTorch code snippet correctly initializes a noise tensor for image generation?

easy

A. noise = torch.randn(16, 100)

B. noise = torch.zeros(16, 100)

C. noise = torch.ones(16, 100)

D. noise = torch.randint(0, 1, (16, 100))

Solution

1. Step 1: Identify noise initialization for generators

   Generators typically use random noise from a normal distribution, which torch.randn provides.

2. Step 2: Check other options

   Zeros or ones do not provide randomness; randint with 0 to 1 range is invalid as upper bound is exclusive.

3. Final Answer:

   noise = torch.randn(16, 100) -> Option A

4. Quick Check:

   Random normal noise = torch.randn [OK]

Hint: Use torch.randn for random normal noise input [OK]

Common Mistakes:

• Using zeros or ones instead of random noise
• Incorrect use of torch.randint with invalid range
• Confusing noise shape dimensions

3. Given this PyTorch generator output code, what is the shape of the generated images?

import torch
noise = torch.randn(8, 100)
generator = torch.nn.Sequential(
    torch.nn.Linear(100, 256),
    torch.nn.ReLU(),
    torch.nn.Linear(256, 784),
    torch.nn.Tanh()
)
fake_images = generator(noise)

medium

A. (8, 28, 28)

B. (100, 256)

C. (8, 784)

D. (256, 784)

Solution

1. Step 1: Trace the generator output shape

   The last Linear layer outputs 784 features per input, so for batch size 8, output shape is (8, 784).

2. Step 2: Understand image reshaping

   784 corresponds to 28x28 pixels flattened; reshaping to (8, 28, 28) is done later, not shown here.

3. Final Answer:

   (8, 784) -> Option C

4. Quick Check:

   Output shape = (batch_size, 784) [OK]

Hint: Output shape matches last Linear layer output size [OK]

Common Mistakes:

• Assuming output is already 2D image shape
• Confusing input noise shape with output
• Mixing intermediate layer shapes

4. Identify the error in this PyTorch generator code snippet:

import torch
class Generator(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = torch.nn.Linear(100, 784)
    def forward(self, x):
        x = self.fc(x)
        x = torch.sigmoid(x)
        return x
noise = torch.randn(16, 100)
gen = Generator()
output = gen(noise).reshape(16, 28, 28)

medium

A. Missing batch normalization layers

B. Not calling super().__init__() in constructor

C. Incorrect reshape dimensions for output

D. Using sigmoid activation instead of tanh

Solution

1. Step 1: Check activation function for image generation

   Image generation often uses tanh to scale outputs between -1 and 1, matching normalized image data.

2. Step 2: Analyze impact of sigmoid

   Sigmoid outputs between 0 and 1, which may mismatch expected scaling and reduce image quality.

3. Final Answer:

   Using sigmoid activation instead of tanh -> Option D

4. Quick Check:

   Activation should be tanh, not sigmoid [OK]

Hint: Use tanh for output scaling in image generation [OK]

Common Mistakes:

• Thinking reshape dimensions are wrong
• Believing batch norm is mandatory here
• Forgetting to call super().__init__()

5. You want to generate 64 images of size 32x32 with pixel values scaled between -1 and 1 using a PyTorch generator. Which output layer and activation setup is best?

hard

A. Linear layer with 1024 outputs followed by sigmoid activation

B. Linear layer with 1024 outputs followed by tanh activation

C. Linear layer with 1024 outputs followed by ReLU activation

D. Linear layer with 1024 outputs followed by softmax activation

Solution

1. Step 1: Calculate output size for 32x32 images

   32x32 = 1024 pixels, so output layer must have 1024 units to represent each pixel.

2. Step 2: Choose activation for scaling pixel values

   Tanh activation scales outputs between -1 and 1, matching the desired pixel value range.

3. Step 3: Evaluate other activations

   Sigmoid outputs 0 to 1, ReLU outputs 0 to infinity, softmax is for classification, so they are unsuitable here.

4. Final Answer:

   Linear layer with 1024 outputs followed by tanh activation -> Option B

5. Quick Check:

   Output size 1024 + tanh for [-1,1] scaling [OK]

Hint: Use tanh activation for output scaled between -1 and 1 [OK]

Common Mistakes:

• Using sigmoid instead of tanh for output scaling
• Choosing softmax for image pixel output
• Ignoring correct output size for image dimensions