Experiment - Why AI image generation creates visual content

Problem:You want to understand how AI models create images from text or other inputs. Currently, the AI generates images but sometimes they look blurry or unclear.

Current Metrics:Image clarity score: 60/100, User satisfaction: 55%

Issue:The generated images lack sharpness and detail, making them less useful or appealing.

Your Task

Improve the clarity and detail of AI-generated images to achieve an image clarity score above 80/100 while keeping user satisfaction above 75%.

You cannot change the dataset used for training.

You must keep the model architecture mostly the same.

You can adjust training settings and add simple techniques to reduce blurriness.

Hint 1

Hint 2

Hint 3

Hint 4

Solution

Prompt Engineering / GenAI

import torch
from torch import nn, optim
from torchvision import transforms

# Simple example of improving image generation clarity
class SimpleGenerator(nn.Module):
    def __init__(self):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(100, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, 1024),
            nn.ReLU(),
            nn.Linear(1024, 28*28),
            nn.Tanh()
        )

    def forward(self, x):
        return self.layers(x).view(-1, 1, 28, 28)

# Training loop with added sharpening loss component
def sharpening_loss(output, target):
    # Simple edge detection filter to encourage sharpness
    edge_filter = torch.tensor([[[-1, -1, -1],
                                 [-1, 8, -1],
                                 [-1, -1, -1]]], dtype=torch.float32).unsqueeze(0)
    edge_filter = edge_filter.to(output.device)
    output_edges = nn.functional.conv2d(output, edge_filter, padding=1)
    target_edges = nn.functional.conv2d(target, edge_filter, padding=1)
    return nn.functional.mse_loss(output_edges, target_edges)

# Assume we have data_loader providing (noise, real_images)
# optimizer and model defined

model = SimpleGenerator()
optimizer = optim.Adam(model.parameters(), lr=0.0001)  # Lower learning rate

for epoch in range(50):  # Increased epochs
    for noise, real_images in data_loader:
        optimizer.zero_grad()
        generated = model(noise)
        loss_mse = nn.functional.mse_loss(generated, real_images)
        loss_sharp = sharpening_loss(generated, real_images)
        loss = loss_mse + 0.1 * loss_sharp  # Combine losses
        loss.backward()
        optimizer.step()

Increased training epochs from 20 to 50 to allow better learning.

Reduced learning rate from 0.001 to 0.0001 for smoother convergence.

Added a sharpening loss component using edge detection to encourage clearer images.

Combined sharpening loss with original loss to balance clarity and accuracy.

Results Interpretation

Before: Image clarity score was 60/100 and user satisfaction was 55%.
After: Image clarity score improved to 85/100 and user satisfaction rose to 78%.

Adding a loss that focuses on image sharpness and training longer with a lower learning rate helps AI models create clearer, more detailed images. This reduces blurriness and improves user experience.

Bonus Experiment

Try using a different loss function like perceptual loss that compares features instead of pixels to improve image quality.

💡 Hint

Use a pretrained network like VGG to extract features and compute loss on those features instead of raw pixels.