# EGVSR: video super-resolution that optimises for inference speed

> EGVSR is a PyTorch implementation of a video super-resolution method built around subpixel convolution, with the explicit goal of making the inference faster than the models it is compared against. The repository is also a unified framework: the same codebase contains implementations of several competing methods, and the benchmarks put them side by side on three test sets.

**Thmen/EGVSR** — Efficient & Generic Video Super-Resolution

- Repository: https://github.com/Thmen/EGVSR
- Stars: 956 · Forks: 109
- Language: Python
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/thmen-egvsr

## What the name expands to

The introduction explains the project in one sentence and points at the two works it is built on.

This is a PyTorch implementation of EGVSR, which stands for efficient and generic video super-resolution, using subpixel convolution to optimise the inference speed of the TecoGAN video super-resolution model. The readme points you to the official implementations of the earlier work for more background.

That is the whole thesis, and it is worth understanding what it implies. Video super-resolution is the task of taking a low resolution video and producing a high resolution one, usually by a factor of four, and the quality of the result is usually measured against a ground truth video. The models here are built around a per-frame network with some mechanism for using information across frames, and the mechanisms differ: some propagate optical flow, some use recurrent networks, some do explicit motion compensation.

The efficiency claim is about the inference side, and the mechanism for it is named, subpixel convolution. That is a specific and well understood technique for upsampling inside a network rather than after it, and it reduces the work by having the network produce the pixels directly at the final resolution instead of producing a low resolution feature map and then interpolating it. The upshot is that a network with the same accuracy profile can run faster, and for a video pipeline that processes every frame, that is the difference between real time and not.

The repository also carries a mirror on a second code hosting platform, and the header image compares the model's four times upscaling with a plain bicubic interpolation of the same clip.

## A unified framework, not a single model

The first feature listed is the one that makes this repository more useful than a model release.

The repository provides a unified framework for various state of the art deep learning based video super-resolution methods, naming VESPCN, SOFVSR, FRVSR, TecoGAN and the project's own EGVSR. The second feature is multiple test datasets, and the third is better performance, described as a model with faster inference speed and better overall performance than prior methods, with the detail deferred to the benchmarks section.

The unified framework point is the important one for an evaluator. The listed methods are the main entries in the video super-resolution literature, and having them in one codebase with one training script, one test script and one set of datasets means the comparison in the benchmark section is a comparison within a single harness rather than a comparison across five papers with five different data loaders.

That matters more than it sounds, because video super-resolution evaluation is sensitive to preprocessing. How the frames are extracted, how the ground truth is aligned, whether the metric is computed on all frames or on a subset, and whether the model sees a context of neighbouring frames all change the numbers. A unified harness removes a class of argument.

The second feature is a new test set, which is the other thing that makes the comparison credible. If a method only looks good on the two standard sets, that is worth knowing, so a third set with different content is a genuine contribution rather than a marketing asset.

## Three test sets, and how the data is laid out

The dataset section is precise about what you have to fetch and where to put it.

The training data is the official training set distributed with the earlier TensorFlow implementation of TecoGAN, which you rename and place in the data directory of the project.

The testing data comes in three flavours. The first is a standard set of four video sequences named after a city, a calendar, foliage and a walk. The second is a set of three sequences used by TecoGAN and by this project, named after a bridge, a face and a room. The third is the new contribution, a set of seventy-two video sequences selected from a video sharing site and including more scenes.

The composition of that new set is described, and it is a good sign of how the authors thought about the problem. It includes natural scenery, cultural scenery, streetscape scenes, life record footage and sports photography. The point of listing the categories is that the two original sets are narrow, and a method that only reconstructs foliage well is not a method that reconstructs video well.

The directory layout is the same for all three, with a ground truth directory and a low resolution directory holding frames in Gaussian degradation with four times down-sampling, and the frames are numbered images.

```bash
codes/
data/
scripts/
results/
```

One practical note. The datasets are hosted on a file sharing service with an extraction code, and the readme says you can get them there and put them into the datasets directory. That is a normal arrangement for this field, and it is also a reminder that the repository is not self-contained and that a result is not reproducible without the data.

## The environment, and what the benchmarks were measured on

The dependencies are ordinary for this kind of work, and the benchmark environment is specified in enough detail to be useful.

You need Ubuntu 16.04 or newer, an NVIDIA GPU with CUDA and CUDNN, Python 3, PyTorch 1.0 or newer, and a list of Python packages covering numerical work, image handling, configuration and the database used for the training set. An optional dependency on Matlab from 2016 or newer is listed, which is a strong hint that some of the comparison metrics are computed with tooling from that ecosystem.

```bash
lmdb
numpy
matplotlib
pyyaml
scipy
scikit-image
tqdm
```

The benchmark environment is a specific machine: an x86_64 system on Ubuntu 18.04.5 LTS, an Intel i9-9900 at 3.10 GHz, an Nvidia RTX 2080 Ti with 11 GB of GDDR6 memory, and 64 GB of RAM in total from two 32 GB DDR4 2666 modules.

And the measurement conditions are stated too, which is rarer. The floating point operation counts and the speed are computed on RGB input at a resolution of 960 by 540, upscaled to 3840 by 2160, on an Nvidia GeForce GTX 2080 Ti.

That last detail is important, because the two GPUs named are not the same card, and a reader comparing the speed figures with a published number needs to know which one it was measured on.

## Reading the benchmark tables without being misled

The benchmarks section has one explicit reading guide, and it is worth applying carefully.

For the objective metrics used to evaluate visual quality, a smaller value is better, and for the score metric a larger value is better. The guide also says that red stands for the top ranked result and blue for the second, so the two colour-coded charts summarise a ranking rather than a raw metric.

The score formula is given as a weighted sum of three normalised terms with the weights set to a third each, and the footnote explains what it considers: both the spatial and the temporal domain. That is the right instinct for video, because a method can produce a sharp frame that does not match its neighbours, and a viewer notices the flicker long before they notice the blur.

The method comparisons are laid out as image sequences with a legend beneath each. The first is the low resolution input, then the competing methods in a fixed order, then the ground truth last, so you can see the difference rather than being told about it.

There is also a section on optical flow based motion compensation, with three example sequences, which suggests the authors wanted to show where a flow based method behaves and where it does not.

The honest reading of all this is that the numbers are a claim with a stated method, a stated machine and a stated resolution, and the way to use them is to re-run the harness rather than to compare a table here with a table in a paper.

## The licence is MIT, with a caveat in the readme

The licence section is worth reading closely, because the headline and the caveat are both there.

The project is released under the MIT licence, and the readme asks people to cite it in publications, giving a BibTeX entry with the authors, the title and the year.

But the sentence between them is the one to note. The provided implementation is strictly for academic purposes only.

So the code is MIT, which means the permissions are broad, and the project simultaneously asks you not to use it commercially. That is a common pattern in research code, and it is worth a moment's thought if you are evaluating it for a product. The MIT licence grants you the right to use, modify and redistribute the code, including in a commercial product, and the readme's request is a request rather than a restriction.

The acknowledgements name the four projects the code is built on, and they are the lineage of the field: the original sub-pixel convolution work, the general super-resolution framework, a video super-resolution collection, and a PyTorch port of the model this project is built on.

The repository layout backs up the framework claim. There are two experiment directories with suffixes that suggest two different configurations, a pretrained models directory, a codes directory for the model implementations, scripts, results with the images the readme embeds, and resources. There are three shell scripts at the root, one for training, one for testing and one for profiling, which is the minimum a reproducible research result needs.

## Conclusion

EGVSR suits a researcher reproducing video super-resolution results, or a developer who wants the reference implementations of several VSR methods in one place with a shared training and testing harness. It is a poor fit for production deployment, since the training data is not distributed with it and the licence text says the implementation is for academic purposes only, and a poor fit if you have no NVIDIA GPU. Before you start, read the benchmark section rather than the headline claim, because the measured quality and the measured speed are reported separately and the speed figures are tied to a specific GPU and resolution pair.

## FAQ

### What is EGVSR and what does it do?

It is a PyTorch implementation of efficient and generic video super-resolution, using subpixel convolution to optimise the inference speed of the earlier TecoGAN model. The aim is a model that reconstructs a high resolution video from a low resolution one faster than the methods it is compared against.

### Which video super-resolution methods are in the EGVSR repository?

The repository provides a unified framework for several state of the art deep learning video super-resolution methods, naming VESPCN, SOFVSR, FRVSR, TecoGAN and the project's own EGVSR, all sharing one training script, one test script and one set of datasets.

### What test datasets does EGVSR use?

Two standard sets, one of four sequences named after a city, a calendar, foliage and a walk, and one of three sequences named after a bridge, a face and a room, plus a new set of seventy-two sequences selected to include natural scenery, cultural scenery, streetscapes, life record footage and sports photography.

### What are the hardware requirements for EGVSR?

An NVIDIA GPU with CUDA and CUDNN, Ubuntu 16.04 or newer, Python 3 and PyTorch 1.0 or newer. The published benchmarks were run on Ubuntu 18.04 with an Intel i9-9900 and an Nvidia RTX 2080 Ti, with the operation counts and speed computed on RGB input at 960 by 540 upscaled to 3840 by 2160.

## Sources

- [Issues](https://github.com/Thmen/EGVSR/issues)
- [License: MIT](https://github.com/Thmen/EGVSR/blob/master/LICENSE)
- [README](https://github.com/Thmen/EGVSR/blob/master/README.md)
- [Thmen/EGVSR on GitHub](https://github.com/Thmen/EGVSR)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/thmen-egvsr