Add Gradio demo app for NanoVSR

.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+checkpoints/
+.venv/
+*.mp4_nanovsr_x*.mp4
+gradio_cached_examples/
+flagged/
+.DS_Store

README.md

@@ -1,6 +1,6 @@
 ---
-title: Nanovsr Demo
-emoji: 🏃
+title: 'NanoVSR: Towards Real-Time Video Super-Resolution on Edge Devices'
+emoji: 🔍
 colorFrom: yellow
 colorTo: green
 sdk: gradio
@@ -12,4 +12,50 @@ license: mit
 short_description: Real-time 4x video super-resolution on edge devices
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<div align="center">
+
+# NanoVSR — Real-Time 4× Video Super-Resolution on Edge Devices
+
+[![arXiv](https://img.shields.io/badge/arXiv-2607.10495-b31b1b)](https://arxiv.org/abs/2607.10495) [![GitHub](https://img.shields.io/badge/GitHub-nanovsr-181717?logo=github)](https://github.com/filippawlicki/nanovsr) [![License](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/filippawlicki/nanovsr/blob/main/LICENSE)
+
+</div>
+
+Interactive demo for **NanoVSR** (ECCV 2026), a fully convolutional, bidirectional-recurrent video
+super-resolution model built for edge devices. It reaches **28.64 dB on REDS4** at **27 FPS on a
+Jetson Orin NX (25 W)**, with no custom CUDA ops — just plain 3×3 convolutions after
+reparameterization.
+
+Upload a low-resolution clip (or try the built-in REDS4 example) and pick one of four model sizes
+to see NanoVSR upscale it 4× in real time, with a side-by-side comparison and a before/after slider.
+Inference runs on Hugging Face **ZeroGPU**.
+
+## Model zoo
+
+| Model | Params | REDS4 PSNR/SSIM | Orin NX (FPS) |
+| :--- | ---: | :---: | ---: |
+| NanoVSR-226k | 226k | 28.23 / 0.8057 | 43.86 |
+| NanoVSR-644k (baseline) | 644k | 28.64 / 0.8215 | 27.20 |
+| NanoVSR-1.7M | 1.7M | 29.15 / 0.8364 | 19.58 |
+| NanoVSR-5.4M | 5.4M | 29.73 / 0.8526 | 8.66 |
+
+Checkpoints are downloaded on demand from the [GitHub releases](https://github.com/filippawlicki/nanovsr/releases)
+of the main repo and cached for the lifetime of the Space.
+
+## Links
+
+- Paper: [arXiv:2607.10495](https://arxiv.org/abs/2607.10495)
+- Code, training and TensorRT deployment: [github.com/filippawlicki/nanovsr](https://github.com/filippawlicki/nanovsr)
+
+## Citation
+
+```bibtex
+@misc{pawlicki2026nanovsr,
+      title={NanoVSR: Towards Real-Time Video Super-Resolution on Edge Devices},
+      author={Filip Pawlicki and Marcel Kańduła and Marcin Pucek and Kamil Dobies},
+      year={2026},
+      eprint={2607.10495},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2607.10495},
+}
+```

app.py

@@ -0,0 +1,255 @@
+"""NanoVSR — real-time video super-resolution, interactive Gradio demo.
+
+Paper: "NanoVSR: Towards Real-Time Video Super-Resolution on Edge Devices" (ECCV 2026)
+Code:  https://github.com/filippawlicki/nanovsr
+"""
+import os
+import tempfile
+import time
+
+import cv2
+import gradio as gr
+import imageio.v2 as imageio
+import numpy as np
+import torch
+
+try:
+    import spaces
+except ImportError:
+    class _NoOpGPU:
+        def __call__(self, fn=None, **kwargs):
+            if fn is not None:
+                return fn
+            return lambda f: f
+
+    class spaces:
+        GPU = _NoOpGPU()
+
+from inference import (
+    DEFAULT_MODEL,
+    MODEL_INFO,
+    SCALE,
+    get_model,
+    run_chunked_inference,
+)
+
+ASSETS_DIR = os.path.join(os.path.dirname(__file__), "assets")
+EXAMPLE_VIDEO = os.path.join(ASSETS_DIR, "examples", "reds4_000_lr.mp4")
+TEASER_VIDEO = os.path.join(ASSETS_DIR, "teaser.mp4")
+
+gr.set_static_paths([ASSETS_DIR])
+
+MAX_SIDE_CHOICES = [180, 240, 320, 480]
+DIVIDER_PX = 8
+
+
+def _even(n):
+    return n - (n % 2)
+
+
+def _read_video(path, max_frames):
+    reader = imageio.get_reader(path)
+    meta = reader.get_meta_data()
+    fps = meta.get("fps", 25.0) or 25.0
+
+    frames = []
+    for i, frame in enumerate(reader):
+        if max_frames is not None and i >= max_frames:
+            break
+        if frame.shape[-1] == 4:
+            frame = frame[..., :3]
+        frames.append(frame)
+    reader.close()
+
+    if not frames:
+        raise gr.Error("Could not read any frames from the input video.")
+    return frames, float(fps)
+
+
+def _resize_to_cap(frames, max_side):
+    h, w = frames[0].shape[:2]
+    longest = max(h, w)
+    if longest <= max_side:
+        new_h, new_w = _even(h), _even(w)
+    else:
+        scale = max_side / longest
+        new_h, new_w = _even(int(round(h * scale))), _even(int(round(w * scale)))
+    new_h, new_w = max(new_h, 8), max(new_w, 8)
+
+    if (new_h, new_w) == (h, w):
+        return frames, (h, w)
+    resized = [cv2.resize(f, (new_w, new_h), interpolation=cv2.INTER_AREA) for f in frames]
+    return resized, (h, w)
+
+
+def _label(img, text):
+    img = np.ascontiguousarray(img)
+    scale = max(0.5, img.shape[0] / 720.0)
+    thickness = max(1, int(round(2 * scale)))
+    origin = (int(16 * scale), int(34 * scale))
+    cv2.putText(img, text, origin, cv2.FONT_HERSHEY_SIMPLEX, scale, (0, 0, 0), thickness * 3, cv2.LINE_AA)
+    cv2.putText(img, text, origin, cv2.FONT_HERSHEY_SIMPLEX, scale, (255, 255, 255), thickness, cv2.LINE_AA)
+    return img
+
+
+def _make_comparison_frame(lq_rgb, sr_rgb):
+    h, w = sr_rgb.shape[:2]
+    base = cv2.resize(lq_rgb, (w, h), interpolation=cv2.INTER_NEAREST)
+    base = _label(base, "Input (LR, nearest-upscaled)")
+    sr = _label(np.ascontiguousarray(sr_rgb), "NanoVSR")
+    divider = np.full((h, DIVIDER_PX, 3), 255, dtype=np.uint8)
+    return np.hstack([base, divider, sr])
+
+
+def _estimate_duration(model_name, frames, chunk_size, use_fp16, progress=None):
+    del use_fp16, progress
+    n = len(frames)
+    factor = {"NanoVSR-226k (fastest)": 0.15, "NanoVSR-644k (baseline)": 0.25,
+              "NanoVSR-1.7M": 0.4, "NanoVSR-5.4M (best quality)": 0.8}.get(model_name, 0.3)
+    return int(min(180, max(25, 20 + n * factor)))
+
+
+@spaces.GPU(duration=_estimate_duration)
+def _gpu_infer(model_name, frames, chunk_size, use_fp16, progress=gr.Progress()):
+    model = get_model(model_name)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    def cb(done, total):
+        progress(done / total, desc=f"Upscaling frames ({done}/{total}) on {device.upper()}")
+
+    progress(0, desc="Starting inference...")
+    return run_chunked_inference(model, frames, chunk_size, device, use_fp16, progress_cb=cb)
+
+
+def upscale(video_path, model_name, chunk_size, max_frames, max_side, use_fp16,
+            progress=gr.Progress()):
+    if not video_path:
+        raise gr.Error("Please upload or select a low-resolution video first.")
+
+    progress(0, desc="Reading video...")
+    frames, fps = _read_video(video_path, max_frames)
+    frames, orig_size = _resize_to_cap(frames, max_side)
+    in_h, in_w = frames[0].shape[:2]
+
+    t0 = time.time()
+    sr_frames = _gpu_infer(model_name, frames, int(chunk_size), bool(use_fp16), progress)
+    elapsed = time.time() - t0
+
+    progress(0.95, desc="Encoding output video...")
+    sr_h, sr_w = sr_frames.shape[1:3]
+
+    out_frames = [_make_comparison_frame(frames[i], sr_frames[i]) for i in range(len(frames))]
+    preview_before = cv2.resize(frames[0], (sr_w, sr_h), interpolation=cv2.INTER_NEAREST)
+
+    out_fd, out_path = tempfile.mkstemp(suffix=f"_nanovsr_x{SCALE}.mp4")
+    os.close(out_fd)
+    out_fps = max(1.0, min(fps, 60.0))
+    writer = imageio.get_writer(out_path, fps=out_fps, codec="libx264",
+                                 ffmpeg_params=["-crf", "18"], macro_block_size=1)
+    for f in out_frames:
+        writer.append_data(f)
+    writer.close()
+
+    resize_note = (f" (downscaled from {orig_size[1]}x{orig_size[0]} to fit the "
+                    f"{max_side}px cap)" if (orig_size[1], orig_size[0]) != (in_w, in_h) else "")
+    status = (
+        f"**Model:** {model_name} · **{MODEL_INFO[model_name]['psnr']}**\n\n"
+        f"**Resolution:** {in_w}x{in_h}{resize_note} → {sr_w}x{sr_h} (x{SCALE})\n\n"
+        f"**Frames processed:** {len(frames)} · **Inference time:** {elapsed:.2f}s "
+        f"({len(frames) / max(elapsed, 1e-6):.1f} FPS)"
+    )
+    preview = (preview_before, np.ascontiguousarray(sr_frames[0]))
+    return out_path, preview, status
+
+
+THEME = gr.themes.Soft(primary_hue="blue", secondary_hue="cyan")
+
+CSS = """
+.status-box { font-size: 0.95em; }
+.badge-row { display: flex !important; gap: 8px; justify-content: center; flex-wrap: wrap; margin: 0; }
+.badge-row a, .badge-row img { display: inline-block !important; margin: 0 !important; }
+"""
+
+with gr.Blocks(title="NanoVSR: Towards Real-Time Video Super-Resolution on Edge Devices") as demo:
+    gr.Markdown(
+        """
+        <div align="center">
+
+        # NanoVSR — Real-Time 4× Video Super-Resolution on Edge Devices
+
+        <p class="badge-row" style="display:flex; gap:8px; justify-content:center; flex-wrap:wrap; margin:0;">
+        <a href="https://arxiv.org/abs/2607.10495"><img src="https://img.shields.io/badge/arXiv-2607.10495-b31b1b" alt="arXiv"></a>
+        <a href="https://github.com/filippawlicki/nanovsr"><img src="https://img.shields.io/badge/GitHub-nanovsr-181717?logo=github" alt="GitHub"></a>
+        <a href="https://github.com/filippawlicki/nanovsr/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-green.svg" alt="License"></a>
+        </p>
+
+        </div>
+
+        A fully convolutional, bidirectional-recurrent video super-resolution model that reaches
+        **27–44 FPS on a Jetson Orin NX** while upscaling 4×. Upload a low-resolution clip below and
+        watch NanoVSR sharpen it in real time — or press one of the examples to try it instantly.
+        """
+    )
+    gr.HTML(
+        f'<video id="header-video" autoplay muted loop playsinline '
+        f'style="width:100%; border-radius:12px; display:block;">'
+        f'<source src="/gradio_api/file={TEASER_VIDEO}" type="video/mp4"></video>'
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            video_in = gr.Video(label="Low-resolution input video", sources=["upload"])
+            gr.Examples(
+                examples=[[EXAMPLE_VIDEO]],
+                inputs=[video_in],
+                label="Example (REDS4 clip '000', the paper's own benchmark set)",
+            )
+            model_dd = gr.Dropdown(
+                choices=list(MODEL_INFO.keys()), value=DEFAULT_MODEL, label="Model",
+                info="Bigger models = higher quality, more compute.",
+            )
+            with gr.Accordion("Advanced options", open=False):
+                chunk_size = gr.Slider(4, 30, value=15, step=1, label="Temporal chunk size (T)",
+                                        info="Frames processed per forward pass. The paper's edge setting is 15.")
+                max_frames = gr.Slider(8, 150, value=60, step=1, label="Max frames to process",
+                                        info="Caps runtime; trim long videos to the first N frames.")
+                max_side = gr.Dropdown(MAX_SIDE_CHOICES, value=320, label="Max input side (px)",
+                                        info="Input is downscaled (never upscaled) to this cap before "
+                                             "running NanoVSR, which expects genuinely low-res input.")
+                fp16 = gr.Checkbox(value=True, label="FP16 inference (GPU only, faster)")
+            run_btn = gr.Button("Upscale ▶", variant="primary")
+
+        with gr.Column(scale=1):
+            video_out = gr.Video(label="NanoVSR result", buttons=["download"])
+            slider_out = gr.ImageSlider(label="Before / after (first frame)", buttons=[])
+            status_out = gr.Markdown(elem_classes=["status-box"])
+
+    run_btn.click(
+        fn=upscale,
+        inputs=[video_in, model_dd, chunk_size, max_frames, max_side, fp16],
+        outputs=[video_out, slider_out, status_out],
+    )
+
+    with gr.Accordion("Model zoo & citation", open=False):
+        model_list_md = "\n".join(f"- **{name}** — {info['psnr']}" for name, info in MODEL_INFO.items())
+        citation_md = model_list_md + "\n\n" + (
+"""All models perform 4× upscaling; larger models trade speed for quality. Full details,
+training code and TensorRT deployment scripts are in the
+[GitHub repo](https://github.com/filippawlicki/nanovsr).
+
+```bibtex
+@misc{pawlicki2026nanovsr,
+      title={NanoVSR: Towards Real-Time Video Super-Resolution on Edge Devices},
+      author={Filip Pawlicki and Marcel Kańduła and Marcin Pucek and Kamil Dobies},
+      year={2026},
+      eprint={2607.10495},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2607.10495},
+}
+```"""
+        )
+        gr.Markdown(citation_md)
+
+if __name__ == "__main__":
+    demo.queue().launch(theme=THEME, css=CSS)

assets/examples/reds4_000_lr.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa60410340d9c8d9f93c8ec74d89b29bb7315644ad4468131df4a736fbd891b0
+size 568786

assets/teaser.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4ba8cdb816963a41689599f8299ce31eb1bdc956965acacb907b37836fde8bd
+size 748387

inference.py

@@ -0,0 +1,111 @@
+"""Checkpoint management and inference helpers for the NanoVSR Gradio demo.
+
+Vendored/adapted from the main nanovsr repo's utils.py + demo.py so this Space
+has no dependency on the training repo at runtime.
+"""
+import os
+
+import numpy as np
+import requests
+import torch
+
+from models.nanovsr import NanoVSR
+
+SCALE = 4
+CKPT_DIR = os.path.join(os.path.dirname(__file__), "checkpoints")
+RELEASE_BASE = "https://github.com/filippawlicki/nanovsr/releases/download/v1.0"
+
+MODEL_INFO = {
+    "NanoVSR-226k (fastest)": dict(file="nanovsr_226k.pth", num_feat=32, num_blocks=8,
+                                     psnr="28.23 dB REDS4"),
+    "NanoVSR-644k (baseline)": dict(file="nanovsr_644k.pth", num_feat=48, num_blocks=12,
+                                      psnr="28.64 dB REDS4"),
+    "NanoVSR-1.7M": dict(file="nanovsr_1.7m.pth", num_feat=64, num_blocks=20,
+                          psnr="29.15 dB REDS4"),
+    "NanoVSR-5.4M (best quality)": dict(file="nanovsr_5.4m.pth", num_feat=96, num_blocks=30,
+                                          psnr="29.73 dB REDS4"),
+}
+DEFAULT_MODEL = "NanoVSR-644k (baseline)"
+
+_model_cache = {}
+
+
+def ensure_checkpoint(model_name):
+    info = MODEL_INFO[model_name]
+    os.makedirs(CKPT_DIR, exist_ok=True)
+    path = os.path.join(CKPT_DIR, info["file"])
+    if not os.path.exists(path):
+        url = f"{RELEASE_BASE}/{info['file']}"
+        tmp_path = path + ".part"
+        with requests.get(url, stream=True, timeout=60) as resp:
+            resp.raise_for_status()
+            with open(tmp_path, "wb") as f:
+                for chunk in resp.iter_content(chunk_size=1 << 20):
+                    f.write(chunk)
+        os.replace(tmp_path, path)
+    return path
+
+
+def get_model(model_name):
+    """Load (and cache on CPU) the requested NanoVSR variant."""
+    if model_name in _model_cache:
+        return _model_cache[model_name]
+
+    info = MODEL_INFO[model_name]
+    checkpoint_path = ensure_checkpoint(model_name)
+    state_dict = torch.load(checkpoint_path, map_location="cpu")
+    if isinstance(state_dict, dict):
+        for key in ["params_ema", "params", "model_state_dict"]:
+            if key in state_dict:
+                state_dict = state_dict[key]
+                break
+
+    model = NanoVSR(num_feat=info["num_feat"], num_blocks=info["num_blocks"])
+    model.load_state_dict(state_dict, strict=False)
+    model.switch_to_deploy()
+    model.eval()
+
+    _model_cache[model_name] = model
+    return model
+
+
+def frames_to_tensor(frames_rgb):
+    """List/array of [H, W, 3] uint8 RGB frames -> [T, 3, H, W] float tensor in [0, 1]."""
+    batch = np.stack(frames_rgb, axis=0).transpose(0, 3, 1, 2)
+    batch = np.ascontiguousarray(batch)
+    return torch.from_numpy(batch).float() / 255.0
+
+
+def tensor_to_frames(tensor):
+    """[T, 3, H, W] float tensor in [0, 1] -> [T, H, W, 3] uint8 RGB numpy array."""
+    arr = (tensor.clamp(0, 1).mul(255.0).round().to(torch.uint8)
+           .permute(0, 2, 3, 1).contiguous().cpu().numpy())
+    return arr
+
+
+@torch.inference_mode()
+def run_chunked_inference(model, frames_rgb, chunk_size, device, use_fp16, progress_cb=None):
+    """Run NanoVSR over a list of LR RGB frames in temporal chunks.
+
+    Returns a [T, H*4, W*4, 3] uint8 RGB numpy array.
+    """
+    model = model.to(device)
+    autocast_ctx = (torch.autocast(device_type="cuda", dtype=torch.float16)
+                     if use_fp16 and device == "cuda" else torch.autocast(device_type="cpu", enabled=False))
+
+    outputs = []
+    n = len(frames_rgb)
+    for start in range(0, n, chunk_size):
+        chunk = frames_rgb[start:start + chunk_size]
+        lq = frames_to_tensor(chunk).unsqueeze(0).to(device)
+        with autocast_ctx:
+            sr = model(lq)
+        outputs.append(tensor_to_frames(sr.float().squeeze(0)))
+        if progress_cb is not None:
+            progress_cb(min(start + chunk_size, n), n)
+
+    model.cpu()
+    if device == "cuda":
+        torch.cuda.empty_cache()
+
+    return np.concatenate(outputs, axis=0)

models/nanovsr.py

@@ -0,0 +1,187 @@
+import os
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+class RepVGGBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, stride=1, deploy=False):
+        super(RepVGGBlock, self).__init__()
+        self.deploy = deploy
+        self.stride = stride
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.activation = nn.LeakyReLU(0.1, inplace=True)
+
+        if deploy:
+            self.rbr_reparam = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=True)
+        else:
+            self.rbr_identity = nn.BatchNorm2d(in_channels) if out_channels == in_channels and stride == 1 else None
+            self.rbr_dense = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False),
+                nn.BatchNorm2d(out_channels)
+            )
+            self.rbr_1x1 = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels, kernel_size=1, padding=0, bias=False),
+                nn.BatchNorm2d(out_channels)
+            )
+
+    def forward(self, x):
+        if self.deploy:
+            return self.activation(self.rbr_reparam(x))
+
+        if self.rbr_identity is None:
+            id_out = 0
+        else:
+            id_out = self.rbr_identity(x)
+
+        return self.activation(self.rbr_dense(x) + self.rbr_1x1(x) + id_out)
+
+    def get_equivalent_kernel_bias(self):
+        kernel3x3, bias3x3 = self._fuse_bn_tensor(self.rbr_dense)
+
+        kernel1x1, bias1x1 = self._fuse_bn_tensor(self.rbr_1x1)
+
+        kernelid, biasid = self._fuse_bn_tensor(self.rbr_identity)
+
+        return (
+            kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1) + kernelid,
+            bias3x3 + bias1x1 + biasid
+        )
+
+    def _pad_1x1_to_3x3_tensor(self, kernel1x1):
+        if kernel1x1 is None:
+            return 0
+        else:
+            return F.pad(kernel1x1, [1, 1, 1, 1])
+
+    def _fuse_bn_tensor(self, branch):
+        if branch is None:
+            return 0, 0
+        if isinstance(branch, nn.Sequential):
+            kernel = branch[0].weight
+            running_mean = branch[1].running_mean
+            running_var = branch[1].running_var
+            gamma = branch[1].weight
+            beta = branch[1].bias
+            eps = branch[1].eps
+        else:
+            assert isinstance(branch, nn.BatchNorm2d)
+            if not hasattr(self, 'id_tensor'):
+                input_dim = self.in_channels
+                kernel_value = np.zeros((self.in_channels, input_dim, 3, 3), dtype=np.float32)
+                for i in range(self.in_channels):
+                    kernel_value[i, i % input_dim, 1, 1] = 1
+                self.id_tensor = torch.from_numpy(kernel_value).to(branch.weight.device)
+            kernel = self.id_tensor
+            running_mean = branch.running_mean
+            running_var = branch.running_var
+            gamma = branch.weight
+            beta = branch.bias
+            eps = branch.eps
+
+        std = (running_var + eps).sqrt()
+        t = (gamma / std).reshape(-1, 1, 1, 1)
+        return kernel * t, beta - running_mean * gamma / std
+
+    def switch_to_deploy(self):
+        if self.deploy:
+            return
+        kernel, bias = self.get_equivalent_kernel_bias()
+        self.rbr_reparam = nn.Conv2d(
+            in_channels=self.rbr_dense[0].in_channels,
+            out_channels=self.rbr_dense[0].out_channels,
+            kernel_size=self.rbr_dense[0].kernel_size,
+            stride=self.rbr_dense[0].stride,
+            padding=self.rbr_dense[0].padding,
+            bias=True)
+        self.rbr_reparam.weight.data = kernel
+        self.rbr_reparam.bias.data = bias
+
+        self.__delattr__('rbr_dense')
+        self.__delattr__('rbr_1x1')
+        if hasattr(self, 'rbr_identity'):
+            self.__delattr__('rbr_identity')
+        self.deploy = True
+
+
+class PixelShuffleBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, upscale_factor=2):
+        super(PixelShuffleBlock, self).__init__()
+        self.conv = nn.Conv2d(in_channels, out_channels * (upscale_factor ** 2), 3, 1, 1)
+        self.pixel_shuffle = nn.PixelShuffle(upscale_factor)
+        self.prelu = nn.PReLU()
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.pixel_shuffle(x)
+        return self.prelu(x)
+
+
+class NanoVSR(nn.Module):
+    def __init__(self, num_feat=32, num_blocks=7, deploy=False):
+        super(NanoVSR, self).__init__()
+        self.num_feat = num_feat
+        self.deploy = deploy
+
+        self.feat_extract = RepVGGBlock(3, num_feat, deploy=deploy)
+
+        self.forward_net = nn.Sequential(*[RepVGGBlock(num_feat, num_feat, deploy=deploy) for _ in range(num_blocks)])
+        self.backward_net = nn.Sequential(*[RepVGGBlock(num_feat, num_feat, deploy=deploy) for _ in range(num_blocks)])
+
+        self.fusion = nn.Conv2d(num_feat * 2, num_feat, 1, 1, 0, bias=True)
+
+        self.upsample1 = PixelShuffleBlock(num_feat, num_feat, upscale_factor=2)
+        self.upsample2 = PixelShuffleBlock(num_feat, 32, upscale_factor=2)
+
+        self.conv_last = nn.Conv2d(32, 3, 3, 1, 1, bias=True)
+
+    def forward(self, x):
+        b, t, c, h, w = x.size()
+
+        x_flat = x.view(-1, c, h, w)
+        feats = self.feat_extract(x_flat)
+        feats = feats.view(b, t, -1, h, w)
+
+        forward_feats = []
+        feat_prop = torch.zeros_like(feats[:, 0, ...])
+        for i in range(t):
+            feat_prop = self.forward_net(feats[:, i, ...] + feat_prop)
+            forward_feats.append(feat_prop)
+
+        backward_feats = []
+        feat_prop = torch.zeros_like(feats[:, 0, ...])
+        for i in range(t - 1, -1, -1):
+            feat_prop = self.backward_net(feats[:, i, ...] + feat_prop)
+            backward_feats.insert(0, feat_prop)
+
+        outputs = []
+
+        for i in range(t):
+            f_fused = torch.cat([forward_feats[i], backward_feats[i]], dim=1)
+            f_fused = self.fusion(f_fused)
+
+            out = self.upsample1(f_fused)
+            out = self.upsample2(out)
+            out = self.conv_last(out)
+
+            base = F.interpolate(x[:, i, ...], scale_factor=4, mode='bilinear', align_corners=False)
+            out += base
+            outputs.append(out)
+
+        final_video = torch.stack(outputs, dim=1)
+
+        return final_video
+
+    def switch_to_deploy(self):
+        if self.deploy:
+            return
+
+        for module in self.modules():
+            if module is self:
+                continue
+            if hasattr(module, 'switch_to_deploy'):
+                module.switch_to_deploy()
+
+        self.deploy = True

requirements.txt

@@ -0,0 +1,8 @@
+gradio==6.20.0
+spaces
+torch>=2.1
+numpy>=1.24
+requests>=2.31
+opencv-python-headless>=4.8
+imageio>=2.34
+imageio-ffmpeg>=0.5