All selected work

SRGANMore than meets the pixel.

An implementation study of adversarial image super-resolution: learning to turn a small input into a larger image with more convincing detail. The interesting part is the trade-off between visual sharpness and faithful reconstruction.

Computer vision / Generative modeling
The problem
Simply enlarging a low-resolution image does not recover the textures and edges lost in downsampling.
My contribution
Implemented the generator, discriminator, VGG19 feature network, paired-image preparation, and training loop in TensorFlow/Keras.
The result
Saved model checkpoints and visual comparisons for 4× enlargement, including the before-and-after example below.
The constraint
Limited training resources and a small custom corpus. The published artifacts support a qualitative study, not a benchmark-leading claim.

See what the model changes.

SRGAN high-resolution reconstruction
Original low-resolution input
Drag to compare. Use arrow keys to adjust; Home reveals the output and End reveals the input.
Original project example. Drag the divider, or focus it and use the arrow keys.

The comparison makes edges, texture, and color differences easy to inspect. A sharper-looking result is not necessarily a more accurate record of the original scene: generative reconstruction can introduce plausible detail.

One model reconstructs. Another challenges it.

  1. 64 × 64Low-resolution input
  2. Residual generator16 residual blocks
  3. Upsample twiceTwo 2× stages
  4. 256 × 256Reconstructed image
Dimensions and architecture from the public preprocessing code and training notebook.

The generator combines convolution, batch normalization, PReLU activation, and skip connections. Sixteen residual blocks work on the image representation before two upsampling stages expand it to four times the input width and height.

The notebook names these stages “pixel shuffler” blocks, but the published implementation uses UpSampling2D after a convolution. That is an implementation difference from sub-pixel rearrangement, and part of what makes this a learning study rather than an exact reproduction.

Architecture diagram for the project’s super-resolution generator
Generator architecture from the project materials.Open image

Optimize for more than matching pixels.

The original SRGAN paper combines adversarial loss with a feature-based content objective. Its motivation is that minimizing pixel error alone can favor smooth, perceptually unconvincing output. Read Ledig et al.’s research.

My implementation uses an ImageNet-pretrained VGG19 feature extractor alongside a convolutional discriminator. The discriminator learns to distinguish generated images from high-resolution examples, while the generator is trained against both realism and feature similarity.

The repository contains a 15-epoch training-loop configuration and checkpoints from different runs. I present the saved visual evidence without treating those files as proof of one continuous, fully documented experiment.

The output is evidence. So are its imperfections.

Saved comparison of low-resolution inputs and generated super-resolution images
Saved model comparisons from the project. Inspect full-size images to compare edges and color artifacts.Open image

The project demonstrates a complete adversarial training pipeline and visible differences between input and reconstructed images. It does not publish a reproducible held-out PSNR, SSIM, or perceptual benchmark alongside these examples.

A stronger follow-up would compare bicubic interpolation, a reconstruction-only model, and the adversarial model on identical held-out inputs. I would report quantitative scores together with visual failure cases, especially color shifts and fabricated textures.

The hardest constraint: limited training compute.

The hardest part was training a generative model with limited compute. Super-resolution involves a generator, a discriminator, and a perceptual objective, so every experiment has a cost beyond simply increasing image resolution.

The experience made the compute budget a practical part of the engineering problem. For a follow-up, I would prioritize controlled comparisons and reusable checkpoints so each training run answers a specific question about image quality.

Inspect the implementation.

1 / 0

Arrows: browse · + / −: zoom · Shift + arrows: pan · Esc: close