ESRGAN to boost image resolution

How I Used ESRGAN to Boost Image Resolution — From Blurry to Crystal Clear

Have you ever zoomed into an old photo only to be disappointed by a blocky, pixelated mess? That happened to me recently when I tried to restore some low-quality images. Traditional upscaling methods like bicubic interpolation just made the pictures bigger — not better. That’s when I turned to ESRGAN (Enhanced Super-Resolution Generative Adversarial Network), and the results were nothing short of magical.

In this blog, I’ll share how I used ESRGAN to improve image resolution, what worked well, and how it compares with other alternatives.

What is ESRGAN in Simple Terms?

Most image upscaling methods stretch pixels to make an image bigger, which often results in blurred edges. ESRGAN, however, takes a different approach.

It uses deep learning — specifically a Generative Adversarial Network (GAN) — to recreate missing details. Instead of just enlarging pixels, ESRGAN imagines finer textures and sharper edges, making the final image look much more realistic.

In short:

Old method: Bigger, blurrier images.

ESRGAN: Bigger, sharper, and more natural-looking images.

How I Implemented ESRGAN

I kept my workflow simple:

• Set up the environment Installed dependencies in Python using PyTorch and cloned pretrained ESRGAN repo.

 git clone https://github.com/xinntao/ESRGAN
 cd ESRGAN
 pip install -r requirements.txt

• Loaded the model
  I used a pretrained ESRGAN model (RRDB_PSNR) since training from scratch requires a massive dataset and GPU resources.

• Upscaled the images
  

import cv2
import torch
from RRDBNet_arch import RRDBNet

# Load pretrained model
model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64,
                num_block=23, num_grow_ch=32, scale=4)
model.load_state_dict(torch.load('RRDB_ESRGAN_x4.pth'), strict=True)
model.eval()

# Load image
img = cv2.imread('low_res.png')[:, :, ::-1]  # BGR to RGB
img = torch.from_numpy(img).float().permute(2,0,1).unsqueeze(0) / 255.

# Run ESRGAN
with torch.no_grad():
    out = model(img).clamp(0, 1)

# Save result
out_img = (out.squeeze().permute(1,2,0).numpy() * 255).astype('uint8')
cv2.imwrite('upscaled.png', out_img[:, :, ::-1])

• Compared the result The difference was instantly noticeable — textures looked more natural, and the image had much more detail.

Results & Observations

Here’s what I noticed after applying ESRGAN:
✅ Fine details like hair strands, text, and textures were restored.
✅ The upscaled image looked far more realistic than traditional methods.
✅ Performance was fairly fast with GPU acceleration.

However, ESRGAN isn’t perfect:
⚠️ On extremely noisy or compressed images, it sometimes “hallucinates” details that weren’t there originally.
⚠️ Running on CPU is slower, especially for larger images.

Alternatives I Considered

Bicubic Interpolation: Quick, but results were blurry and unimpressive.

SRCNN: Early deep learning model for super-resolution, but oversmoothed results.

SRGAN: Predecessor of ESRGAN; good but not as sharp.

Real-ESRGAN: A practical improvement that handles noisy, real-world images better.

For my case (relatively clean images), ESRGAN worked best since I wanted maximum detail recovery.

Why This Matters

Super-resolution isn’t just for making your selfies sharper. It has real-world applications in:

• Medical imaging (clearer scans for diagnosis).
• Satellite/drone imagery (better detail for mapping).
• Gaming & media (upscaling old textures).
• Historical photo restoration (bringing old memories back to life).

Conclusion

Using ESRGAN, I was able to transform low-resolution, pixelated images into sharp, high-resolution outputs that looked almost lifelike. The process was surprisingly straightforward with pretrained models, and the results were far superior to older methods.

If you’re struggling with blurry images, I highly recommend giving ESRGAN a try. And if you’re dealing with real-world noisy photos, check out Real-ESRGAN for even better results.