---
license: mit
library_name: pytorch
pipeline_tag: image-to-image
tags:
  - super-resolution
  - image-super-resolution
  - image-to-image
  - pytorch
  - onnx
datasets:
  - eugenesiow/Div2k
model-index:
  - name: SRNet-x4-Upscaler
    results:
      - task:
          type: image-to-image
          name: Image super-resolution (x4)
        dataset:
          name: DIV2K validation (100 images, bicubic degradation)
          type: eugenesiow/Div2k
        metrics:
          - type: psnr
            name: PSNR (Y channel, shave 4)
            value: 30.28
---

# SRNet-x4-Upscaler — small, fast single-image super-resolution

A compact residual CNN (~1.25 M parameters) that upscales images 4x. It predicts a residual on top of a bicubic upscale, so it starts from — and improves on — plain bicubic interpolation. Trained in 30 minutes on 2x T4 GPUs.

**Live demo (runs in your browser, nothing is uploaded):** [Infinitode Experiments](https://infinitode.netlify.app/experiments)

## Results

Evaluated on the 100 DIV2K validation images, full images, bicubic-x4 degradation, Y-channel PSNR with a 4 px border shave, 8-bit outputs:

| Method | PSNR (dB) |
|---|---|
| Bicubic | 28.23 |
| **SRNet-x4-Upscaler** | **30.28** (+2.05) |

Metrics come from the training notebook (antialiased bicubic downscale, not the official MATLAB `imresize`), so they are comparable between methods here but only approximately comparable to published tables. Published tables usually report RGB PSNR, which reads about 1.5 dB lower than Y-channel PSNR for the same images.

## Usage

```python
import numpy as np, torch
from PIL import Image
from huggingface_hub import hf_hub_download
import importlib.util

REPO = "InfinitodeLTD/srnet-x4-upscaler"
spec = importlib.util.spec_from_file_location("srnet", hf_hub_download(REPO, "srnet.py"))
srnet = importlib.util.module_from_spec(spec); spec.loader.exec_module(srnet)
model = srnet.SRNet.from_pretrained(REPO).eval()

img = np.asarray(Image.open("photo.png").convert("RGB"), np.float32) / 255
x = torch.from_numpy(img).permute(2, 0, 1)[None]
with torch.inference_mode():
    y = model(x).clamp(0, 1)[0].permute(1, 2, 0).numpy()
Image.fromarray((y * 255).round().astype("uint8")).save("photo_x4.png")
```

### Large images (tiled inference)

Process tiles with a margin of at least `2*nb + 6 = 38` input pixels; the result is then identical to whole-image inference.

```python
@torch.inference_mode()
def upscale_tiled(model, x, tile=128):
    s, m = model.scale, 2 * model.nb + 6
    _, _, H, W = x.shape
    out = torch.empty(1, 3, H * s, W * s)
    for y in range(0, H, tile):
        for xx in range(0, W, tile):
            y1, x1 = min(H, y + tile), min(W, xx + tile)
            ya, xa, yb, xb = max(0, y - m), max(0, xx - m), min(H, y1 + m), min(W, x1 + m)
            sr = model(x[:, :, ya:yb, xa:xb]).clamp(0, 1)
            out[:, :, y * s:y1 * s, xx * s:x1 * s] = sr[:, :, (y - ya) * s:(y1 - ya) * s, (xx - xa) * s:(x1 - xa) * s]
    return out
```

### ONNX

`srnet_x4.onnx` takes `input` (float32 NCHW RGB in [0, 1], dynamic batch/height/width) and returns `output` (clip to [0, 1]). It runs with onnxruntime and onnxruntime-web (the browser demo uses it).

## Model details

- Architecture: 3x3 conv head -> 16 residual blocks (conv-ReLU-conv, 64 channels) -> 3x3 conv with long skip -> conv to 48 channels + PixelShuffle(4) -> added to a bicubic upscale of the input. The final conv is zero-initialised, so training starts at exact bicubic.
- Compute: all convolutions run at input resolution; about 2.5 MFLOPs per input pixel.

## Training

- Data: DF2K (DIV2K + Flickr2K) HR training images; DIV2K validation images held out.
- Degradation: antialiased bicubic x4 downscale, quantised to 8 bit. No noise, blur or compression.
- 16,157 steps, batch 32, 64x64 LR patches (256x256 HR), random flips/rotations.
- AdamW, peak LR 4e-4 with cosine decay, L1 loss, then MSE for the final 8% of the schedule; EMA (0.999) weights evaluated alongside raw weights and the better one kept; fp16 mixed precision.

## Limitations

- Trained only on clean bicubic-downscaled images. On real-world inputs with noise, blur or JPEG artefacts it will not denoise or deblock and may amplify artefacts.
- Optimised for PSNR with L1/MSE losses, so fine texture (fur, feathers, foliage) comes out smoother than the original. It does not hallucinate detail the way GAN-based upscalers do.
- x4 only.

## License

The code and weights in this repository are released under the [MIT License](LICENSE).

The MIT license does not change the terms of the training data: DIV2K is distributed for academic research use, and Flickr2K images carry their original Flickr licenses. If you plan commercial use, confirm those terms are acceptable to you.

## Acknowledgements

- DIV2K: Agustsson & Timofte, *NTIRE 2017 Challenge on Single Image Super-Resolution: Dataset and Study*, CVPRW 2017.
- Flickr2K: collected for Lim et al., *Enhanced Deep Residual Networks for Single Image Super-Resolution* (EDSR), CVPRW 2017. The residual-block design follows the EDSR family.