No. 10of 22StationResearch
Blind ×4 image super-resolution with a web app around it
Auto Image Enhancer
A self-trained ×4 super-resolution model for blurry, noisy or compressed photos, behind a web app with credits, payments and job queues. The first stage is trained and served; the planned diffusion stage was written but never trained.
- When
- Dec 2025 – Jan 2026
- Status
- Built
- Team
- Personal project.
- Role
- Sole builder.
Progress
Progress60%
The backbone model is trained and served, and the web platform is extensive. The diffusion stage was never trained, and the model is below its own quality target.
What comes next
- Measure a bicubic baseline on the same validation set.
- Make before-and-after images on my own photographs.
- Train the diffusion refiner, or remove it from the design.
21.38dB
validation PSNR after 200 epochs of blind ×4 training (SSIM 0.613)
The best reading was 21.44 dB. Blind ×4 on heavily degraded inputs is not comparable to published bicubic benchmarks, and no bicubic baseline was measured, so the gain over plain upscaling is unknown.
Training log (backbone_x4_train.log)Verified. Backed by a file or public page that has been checked.Training log (backbone_x4_train.log) — Read in the project audit of 13 November 2026.Not reached
the project's own quality target of 28 to 32 dB
The log never exceeds 21.44 dB.
Training log and setup notesVerified. Backed by a file or public page that has been checked.Training log and setup notes — Read in the project audit of 13 November 2026.6,371
high-resolution training images from DIV2K and Flickr2K, with 531 more for validation
Counted on disk (model_trained/data)Verified. Backed by a file or public page that has been checked.Counted on disk (model_trained/data) — Read in the project audit of 13 November 2026.Not trained
the diffusion refiner, the second stage of the design
Its code is written. The model API serves the first stage alone.
Audit of the project folderVerified. Backed by a file or public page that has been checked.Audit of the project folder — Read in the project audit of 13 November 2026.Exhibit 01 · Chart
Validation PSNR against the project's own target
Exhibit 02 · Walk-through
From a clean photo to a training pair, and from an upload to a result
Step 01
Start clean
A high-resolution photo from the DIV2K or Flickr2K sets: 6,371 for training, 531 for validation.
Step 02
Damage it on purpose
The degradation pipeline adds Gaussian or motion blur, noise, JPEG compression and color shifts to make the low-quality half of a pair. The model is never told which.
Step 03
Learn to restore
An EDSR-style network of about 1.5 million parameters learns to produce the ×4 image back. 200 epochs on an RTX 3050 with 4 GB of memory.
Step 04
Plan each upload
At serving time a planner measures noise, blur and blockiness to choose the scale, whether to tile the image, and whether to use the diffusion stage.
Step 05
Refine: designed, not trained
A conditional diffusion model was meant to add detail as a second stage. Its code exists, but it was never trained, so an upload gets the backbone's output.
01
What it is
Upload a blurry, noisy or compressed photo and get back a version four times larger and sharper. The design has two stages: a small convolutional network that restores the image, then a diffusion model that refines it, with a planner that measures noise, blur and blockiness to decide how each photo is processed. Around the model sits a full web product. Only the first stage was trained.
02
The hard part
The model works blind: nobody tells it what damaged the photo. So I built a degradation pipeline that takes clean images and damages them with Gaussian and motion blur, noise, JPEG compression and color shifts, to make training pairs. That is a much harder task than the standard benchmark, where images are only shrunk cleanly. And the training ran on one graphics card with 4 GB of memory.
03
What was built
The backbone is an EDSR-style network of about 1.5 million parameters, written from scratch and trained for 200 epochs at ×4 on 6,371 high-resolution images from the DIV2K and Flickr2K sets. A model API analyzes and enhances an image. The diffusion refiner, a conditional U-Net with 1,000 steps, is written but was never trained, so the API serves the backbone alone.
The web platform is a FastAPI backend with accounts, jobs, credits, payments, storage and an admin area, on PostgreSQL with a Redis job queue and 14 property-based test files, and a Next.js front end built around one flow: upload, watermarked preview, pay with credits, clean download.
04
What was measured
On the validation set the model reached 21.38 dB PSNR and 0.613 SSIM at the last epoch; its best was 21.44 dB. It read 20.79 dB at epoch 5, so 195 more epochs bought 0.65 dB. The project's own target was 28 to 32 dB, and it was not reached. These figures cannot be set beside published super-resolution tables, which use clean downscaling. And there is no baseline: plain bicubic upscaling was never measured on the same images, so how much the model improves a photo is unknown.
05
What I'd change
Measure the bicubic baseline first, so the gain is visible. Make before-and-after images on my own photographs; none exist yet that can be shown, which is why this page has no pictures. Then either train the diffusion stage or take it out of the design.
One question
The answer is on this page. Get it right and it goes in your passport on the map.
Challenge· stamped
The model trained for 200 epochs. How much did its validation PSNR improve between epoch 5 and its best reading?
0.65 dB: from 20.79 dB at epoch 5 to a best of 21.44 dB. The project's own target of 28 to 32 dB was not reached. Source: the training log.
Show the answer
0.65 dB. 0.65 dB: from 20.79 dB at epoch 5 to a best of 21.44 dB. The project's own target of 28 to 32 dB was not reached. Source: the training log.
- Stack
- PyTorch
- CUDA (RTX 3050)
- EDSR-style CNN
- DDPM (written, not trained)
- FastAPI
- SQLAlchemy and Alembic
- PostgreSQL
- Redis and RQ
- S3 storage
- Stripe
- Hypothesis
- Next.js
- TypeScript
- Docker