SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1905.02716 · 2019

EDVR: Video Restoration with Enhanced Deformable Convolutional Networks

arXiv · PDF · Open in the Atlas

Code that ran

15 of 19 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 0 violated it and 9 have no contract verdict; 5 failures of our instrument; 4 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1905.02716.json · badge: /api/ran/1905.02716.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
zhusiling/EDVR community (classifier label)
classifier basis not recorded on the link
8 ran · 2 no recorded run
open-mmlab/mmsr community (classifier label)
classifier basis not recorded on the link
7 ran · 2 no recorded run
FunctionStatusWhere it lives
adapt_official Ran
ran on a synthesized input
zhusiling/EDVR/codes/models/modules/DUF_arch.py
code served (permissive licence) · get_code("a3c1e35e4ff68673")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, dtype family float, shape (2, 48, 4, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# The function expects:
# - Rx: a 4D tensor with shape (batch, channels, height, width)
# - scale: an integer (default 4)
# 
# The function uses slicing operations on dimension 1 (channels):
# - x[:, ::3, :, :] gets every 3rd channel starting at 0
# - x[:, 1::3, :, :] gets every 3rd channel starting at 1
# - x[:, 2::3, :, :] gets every 3rd channel starting at 2
# Then it reassigns to Rx with ranges based on scale**2
#
# For scale=4, we need at least 3 * scale**2 = 48 channels
# to avoid index errors when writing to Rx[:, 2*scale**2:, :, :]

# Create a tensor with shape (batch=2, channels=48, height=4, width=5)
# This gives us enough channels for the operations with scale=4
Rx = torch.randn(2, 48, 4, 5)

ARGS = {
    "Rx": Rx,
    "scale": 4
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 48, 4, 5) — shape (2, 48, 4, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
calculate_psnr Ran
ran, honoured the contract we drafted
zhusiling/EDVR/codes/utils/util.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from redrock303/ADF-LLIE, is pointer only (licence: NONE) · get_code("9394ff2c25b8a988")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from redrock303/ADF-LLIE, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

collate_metrics Ran
ran on a synthesized input
open-mmlab/mmsr/.dev_scripts/utils/modelindex.py
code served (permissive licence) · get_code("54b6d9dc8ce868bb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

keys = [
    'Model',
    'Accuracy',
    'F1 Score',
    'Dataset',
    'Precision',
    'Training Resources',
    'Recall',
    'Download'
]

ARGS = {
    'keys': keys
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_data_config Ran
ran on a synthesized input
open-mmlab/mmsr/.dev_scripts/create_ceph_configs.py
code served (permissive licence) · get_code("2c460a151351c467")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os.path as osp
from copy import deepcopy

ARGS = {
    'data_cfg': {
        'dataset': {
            'type': 'ImageNet',
            'data_root': 'data/imagenet',
            'pipeline': [
                {
                    'type': 'mmcls.LoadImageFromFile'
                },
                {
                    'type': 'LoadMask',
                    'mask_config': {
                        'mask_list_file': 'data/masks/mask_list.txt'
                    }
                },
                {
                    'type': 'RandomLoadResizeBg',
                    'bg_dir': 'data/backgrounds'
                },
                {
                    'type': 'CompositeFg',
                    'fg_dirs': ['data/foregrounds/fg1', 'data/foregrounds/fg2'],
                    'alpha_dirs': ['data/alphas/alpha1', 'data/alphas/alpha2']
                }
            ]
        }
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
dict2str Ran
ran; our contract draft was wrong, not the code
zhusiling/EDVR/codes/options/options.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from liyuantsao/BFSR, is pointer only (licence: NONE) · get_code("40c52ad98161c17b")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from liyuantsao/BFSR, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

dict_to_nonedict Ran
ran; our contract draft was wrong, not the code
zhusiling/EDVR/codes/options/options.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from liyuantsao/BFSR, is pointer only (licence: NONE) · get_code("ada7273eee7081c7")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from liyuantsao/BFSR, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

filter_metric Ran
ran on a synthesized input
open-mmlab/mmsr/.dev_scripts/metric_mapping.py
code served (permissive licence) · get_code("0ce4b91d8aca61e4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# metric_mapping: dict where keys are metric names (strings) and values are metric_info (can be any object)
metric_mapping = {
    "accuracy": {"type": "classification", "higher_is_better": True},
    "loss": {"type": "regression", "higher_is_better": False},
    "f1_score": {"type": "classification", "higher_is_better": True}
}

# summary_data: dict where values are dicts that may contain metric names as keys
summary_data = {
    "epoch_1": {
        "accuracy": 0.95,
        "loss": 0.05,
        "other_info": "some data"
    },
    "epoch_2": {
        "accuracy": 0.97,
        "loss": 0.03
    },
    "epoch_3": {
        "f1_score": 0.92,
        "other_metric": 0.88
    }
}

ARGS = {
    "metric_mapping": metric_mapping,
    "summary_data": summary_data
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
flow_warp Ran
ran; our contract draft was wrong, not the code
zhusiling/EDVR/codes/models/modules/module_util.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from taowangzj/lldiffusion, is pointer only (licence: NONE) · get_code("7018e324f2150c43")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from taowangzj/lldiffusion, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

found_table Ran
ran on a synthesized input
open-mmlab/mmsr/.dev_scripts/utils/modelindex.py
code served (permissive licence) · get_code("8e5814637d5291d6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

# Analyzing the function `found_table(lines, i)`:
# - `lines` is a list of strings (table lines in markdown format)
# - `i` is an integer index
# The function checks if a markdown table is found at a given position

ARGS = {
    "lines": [
        "some header line",
        "SKIP THIS TABLE marker in line before table",
        "| column1 | column2 |",
        "| :--- | ---: |",
        "| value1 | value2 |",
        "some footer",
    ],
    "i": 2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
make_layer Ran
ran; our contract draft was wrong, not the code
zhusiling/EDVR/codes/models/modules/module_util.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from haoyuc/A2N, is pointer only (licence: NONE) · get_code("c04a23de0531da4a")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from haoyuc/A2N, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

reading_image_worker Ran
ran on a synthesized input
zhusiling/EDVR/codes/data_scripts/create_lmdb_mp.py
code served (permissive licence) · get_code("e47a76b039b007e1")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import cv2
import numpy as np
import tempfile
import os

# Create a temporary image file for testing
temp_dir = tempfile.mkdtemp()
temp_image_path = os.path.join(temp_dir, "test_image.png")

# Create a small test image using numpy and save it with cv2
test_image = np.random.randint(0, 256, (4, 3, 3), dtype=np.uint8)
cv2.imwrite(temp_image_path, test_image)

ARGS = {
    "path": temp_image_path,
    "key": "image_key_001"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
start_from_proc Ran
ran on a synthesized input
open-mmlab/mmsr/.dev_scripts/job_watcher.py
code served (permissive licence) · get_code("4214819cf4b6bd8d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

class MockProc:
    def read(self):
        # Simulating proc output with 3 lines per task (config, blank, job_id)
        return """
/path/to/config1.yaml
some_output
Job ID: 12345
/path/to/config2.yaml
some_output
Job ID: 67890
""".strip()

root = "root_directory"
proc = MockProc()

ARGS = {
    "root": root,
    "proc": proc,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
tensor2img Ran
ran; our contract draft was wrong, not the code
zhusiling/EDVR/codes/utils/util.py
code served (permissive licence) · get_code("1b40b4f3f0ea0b6e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family int, shape (14, 9, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
import math
from torchvision.utils import make_grid

torch.manual_seed(0)

# Test with a 4D tensor (B, C, H, W)
tensor_4d = torch.rand(2, 3, 4, 5)

# Test with a 3D tensor (C, H, W)
tensor_3d = torch.rand(3, 6, 7)

# Test with a 2D tensor (H, W)
tensor_2d = torch.rand(8, 9)

ARGS = {
    "tensor": tensor_4d,
    "out_type": np.uint8,
    "min_max": (0, 1)
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family int, shape (14, 9, 3) — shape (14, 9, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
update_intervals Ran
ran on a synthesized input
open-mmlab/mmsr/.dev_scripts/create_ceph_configs.py
code served (permissive licence) · get_code("4bbabfed79ffbff3")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import argparse

class Args:
    def __init__(self, iters=None):
        self.iters = iters

config = {
    'train_cfg': {
        'type': 'IterBasedTrainLoop',
        'max_iters': 100,
        'val_interval': 20
    },
    'default_hooks': {
        'logger': {
            'type': 'LoggerHook',
            'interval': 10
        },
        'checkpoint': {
            'type': 'CheckpointHook',
            'interval': 6
        }
    }
}

args = Args(iters=150)

ARGS = {
    'config': config,
    'args': args
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
update_md Ran
ran on a synthesized input
open-mmlab/mmsr/.dev_scripts/update_config_readme.py
code served (permissive licence) · get_code("185156d990381282")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import tempfile
import shutil

# Create a temporary directory structure with test files
temp_dir = tempfile.mkdtemp()
config_subdir = os.path.join(temp_dir, 'configs')
os.makedirs(config_subdir, exist_ok=True)

# Create some dummy config files
config_files = ['model_a.py', 'model-b.py', 'train.py']
for config_file in config_files:
    with open(os.path.join(config_subdir, config_file), 'w') as f:
        f.write('# dummy config')

# Create README.md with references to config files
readme_content = """# Test README

See [model_a](configs/model_a.py) for details.
See [model-b](configs/model-b.py) for more.
See [train](configs/train.py) for training.
"""

readme_path = os.path.join(config_subdir, 'README.md')
with open(readme_path, 'w', encoding='utf-8') as f:
    f.write(readme_content)

# Create README_zh-CN.md with references to config files
readme_zh_content = """# 测试 README

参见 [model_a](configs/model_a.py) 了解详情。
参见 [model-b](configs/model-b.py) 获取更多信息。
参见 [train](configs/train.py) 进行训练。
"""

readme_zh_path = os.path.join(config_subdir, 'README_zh-CN.md')
with open(readme_zh_path, 'w', encoding='utf-8') as f:
    f.write(readme_zh_content)

# The md_file argument should point to one of the README files
md_file_to_test = readme_path

ARGS = {
    'md_file': md_file_to_test
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
DUF_downsample Not yet run
unverified (harvested, no recorded run)
zhusiling/EDVR/codes/utils/util.py
code served (permissive licence) · get_code("30896d7c1646f28e")
How it ran

no invocation recorded.

check_exclude Not yet run
unverified (harvested, no recorded run)
open-mmlab/mmsr/.dev_scripts/update_ut.py
code served (permissive licence) · get_code("eda5ede48a264b22")
How it ran

no invocation recorded.

create_train_job_batch Not yet run
unverified (harvested, no recorded run)
open-mmlab/mmsr/.dev_scripts/train_benchmark.py
code served (permissive licence) · get_code("cee4c863ad3de58e")
How it ran

no invocation recorded.

parse Not yet run
unverified (harvested, no recorded run)
zhusiling/EDVR/codes/options/options.py
code served (permissive licence) · get_code("ce4ad67a16f94299")
How it ran

no invocation recorded.

Also present in other papers' code

Of 19 samples lifted from this paper's linked repositories, 19 carry a function identity and 0 do not. Of the 19 distinct functions with an identity, 15 are also present in other papers whose code we hold (4 with at least one paper dated earlier, 1 the same month, 15 later) and 4 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
make_layer 31 other papers
1 dated earlier, 1 the same month, 29 later · 6 only as an assembly brick
1809.00219 (2018-09)
ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks
1905.10485 (2019-05)
Generative Latent Flow
1909.10692 (2019-09)
Deformable Non-local Network for Video Super-Resolution
and 28 more not named here
dict2str 23 other papers
23 later
1907.03222 (2019-07)
IRNet: A General Purpose Deep Residual Regression Framework for Materials Discovery
2005.05650 (2020-05)
Invertible Image Rescaling
2006.14200 (2020-06)
SRFlow: Learning the Super-Resolution Space with Normalizing Flow
and 20 more not named here
dict_to_nonedict 19 other papers
1 dated earlier, 18 later
1609.04802 (2016-09)
Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network
2006.14200 (2020-06)
SRFlow: Learning the Super-Resolution Space with Normalizing Flow
ijcai2022_0196 (2022 (year only))
KUNet: Imaging Knowledge-Inspired Single HDR Image Reconstruction
and 16 more not named here
calculate_psnr 16 other papers
2 dated earlier, 14 later
1809.00219 (2018-09)
ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks
1904.03377 (2019-04)
Blind Super-Resolution With Iterative Kernel Correction
1907.03222 (2019-07)
IRNet: A General Purpose Deep Residual Regression Framework for Materials Discovery
and 13 more not named here
flow_warp 5 other papers
1 dated earlier, 4 later
1809.00219 (2018-09)
ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks
1911.10375 (2019-11)
Region Normalization for Image Inpainting
2005.01996 (2020-05)
NTIRE 2020 Challenge on Real-World Image Super-Resolution: Methods and Results
and 2 more not named here
tensor2img 2 other papers
2 later
2006.04924 (2020-06)
A Self-supervised Approach for Adversarial Robustness
2502.05749 (2025-02)
UniDB: A Unified Diffusion Bridge Framework via Stochastic Optimal Control
check_exclude 1 other paper
1 later
2207.14812 (2022-07)
GLEAN: Generative Latent Bank for Image Super-Resolution and Beyond
collate_metrics 1 other paper
1 later
2207.14812 (2022-07)
GLEAN: Generative Latent Bank for Image Super-Resolution and Beyond
convert_data_config 1 other paper
1 later
2207.14812 (2022-07)
GLEAN: Generative Latent Bank for Image Super-Resolution and Beyond
create_train_job_batch 1 other paper
1 later
2207.14812 (2022-07)
GLEAN: Generative Latent Bank for Image Super-Resolution and Beyond
filter_metric 1 other paper
1 later
2207.14812 (2022-07)
GLEAN: Generative Latent Bank for Image Super-Resolution and Beyond
found_table 1 other paper
1 later
2207.14812 (2022-07)
GLEAN: Generative Latent Bank for Image Super-Resolution and Beyond
start_from_proc 1 other paper
1 later
2207.14812 (2022-07)
GLEAN: Generative Latent Bank for Image Super-Resolution and Beyond
update_intervals 1 other paper
1 later
2207.14812 (2022-07)
GLEAN: Generative Latent Bank for Image Super-Resolution and Beyond
update_md 1 other paper
1 later
2207.14812 (2022-07)
GLEAN: Generative Latent Bank for Image Super-Resolution and Beyond

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Video restoration tasks, including super-resolution, deblurring, etc, are drawing increasing attention in the computer vision community. A challenging benchmark named REDS is released in the NTIRE19 Challenge. This new benchmark challenges existing methods from two aspects: (1) how to align multiple frames given large motions, and (2) how to effectively fuse different frames with diverse motion and blur. In this work, we propose a novel Video Restoration framework with Enhanced Deformable networks, termed EDVR, to address these challenges. First, to handle large motions, we devise a Pyramid, Cascading and Deformable (PCD) alignment module, in which frame alignment is done at the feature level using deformable convolutions in a coarse-to-fine manner. Second, we propose a Temporal and Spatial Attention (TSA) fusion module, in which attention is applied both temporally and spatially, so as to emphasize important features for subsequent restoration. Thanks to these modules, our EDVR wins the champions and outperforms the second place by a large margin in all four tracks in the NTIRE19 video restoration and enhancement challenges. EDVR also demonstrates superior performance to state-of-the-art published methods on video super-resolution and deblurring. The code is available at https://github.com/xinntao/EDVR.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("1905.02716")
get_code_for_paper("1905.02716")
have("1905.02716")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/1905.02716.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/1905.02716.svg)](https://syntology.ai/paper/1905.02716)

Connect an agent — have() is free.