Models · Image restoration

SeedVR2

SeedVR2 (Wang et al., ByteDance Seed, 2025): upscales and restores photos and video frames x2 with a large diffusion transformer run for a single step; 3 B and 7 B versions, the 7 B runs on 16 GB with weight streaming (default, ~17 GB free host RAM). Apache-2.0 code and weights.

experimental Fork of ByteDance-Seed/SeedVR@e4de8c2 · backends: portable, kernels

Checkpoint

Paper 2025 Added in 0.2.0 Evaluated with 0.2.0

Portable, RTX 5060 Ti 16 GB 2295 ms 512x512, bf16
vs the faster original 5.7× original bf16: 13150 ms
Peak memory 6,140 MiB original: 7,598 MiB
Accuracy vs original fp32 – original not run on the test set

Use it

pip install fastforks

Lean install with only what this model needs: pip install fastforks-core

from fastforks import restoration

model = restoration.load("seedvr2-3b")  # kernels on a supported GPU, else portable PyTorch
result = model(image)
result.image
result.backend  # what ran: mode, device, dtype, kernels
fastforks bench seedvr2-3b

Times the model on this machine. load(…, mode="portable") or mode="kernels" picks a backend; usage guide.

Speed and memory

Every backend on one GPU (RTX 5060 Ti 16 GB) and the same input, the authors’ code included. Kernels runs bf16. Portable runs bf16 on CUDA.

BackenddtypeTime per call (ms)vs original fp16Peak memory
allocated / reserved
Load (s)First call (s)
Original fp32fp32not measured ––––
Original (own default)load: the authors' fp32 .pth files from the page cache (read once before)bf16 13150–7,598 MiB/14.9 GiB96.213.89
Portable fp32fp32not measured ––––
Portablebf16 22955.7×6,140 MiB/6,772 MiB2.62.45
Kernelsbf16 22965.7×6,140 MiB/6,772 MiB3.32.46
Portable + torch.compile 19416.8×5,237 MiB/8,144 MiB238 (build)–
TensorRTnot measured here ––––

Measured on RTX 5060 Ti 16 GB, torch 2.14.1+cu130, 2026-11-14 to 2026-11-15. First call, 3 warm-up, peak reset, median of 3 rounds x median of 5. Ratios divide two times of this table (same GPU, same input). Original fp16 is the authors’ own precision option, else torch.autocast. torch.compile and TensorRT: build time instead of load time. TensorRT memory (engine, not comparable) is the GPU memory the engine took, read from the driver because TensorRT allocates outside PyTorch, so it can't be compared with the PyTorch peaks of the other rows.

Other devices

DeviceBackenddtypems / callPeak memoryOutput vs referenceInput
Apple M1 Pro 16 GB MPS, torch 2.14.1, 2026-11-15Originalfp32cannot run here–512x512
Portablefp32cannot run here–512x512
Kernelsbf16not implemented–512x512

CUDA memory is torch’s peak allocated / reserved; Apple has no such counter, so the Mac rows show the process footprint (weights, Python and torch included). “Output vs reference” compares the device’s output with the stored golden output under the card’s tolerance; – = not checked on that device. Kernels “not implemented” = no kernels for this model on that backend yet: it runs portable there.

Licence and weights

Commercial use allowed

Code
Apache-2.0 LICENSENOTICE
Weights
Apache-2.0 source
Training data
Paper (arXiv 2506.05301): adversarial post-training of SeedVR on large-scale image and video data with synthetic degradations; the data sources and terms are not stated.
  • The converted weight files (bf16 transformer with the fixed prompt embedding, bf16 VAE) are hosted by fastforks under the originals' Apache-2.0 licence; NOTICE keeps the attribution and lists the changes.

Our reading of the licences, not legal advice.

Weights

seedvr2-3b.safetensors 6.8 GB· hosted on Hugging Face
seedvr2-vae.safetensors 501 MB· hosted on Hugging Face

fastforks downloads and checks these files on first use (fastforks download seedvr2-3b).

Accuracy

The test set through the authors’ code and through ours: same checkpoint, same protocol. The distance between the original’s fp32 and fp16 runs is what half precision alone costs; our runs should stay within it.

DIV2K validation

4 centre crops 512 px, bicubic x2 LR -> HR, PSNR / SSIM (Y) / PSNR to the original

Rundtypepsnr ↑ssim ↑psnr_orig ↑imagesms / image
Original fp32not measured
Original fp16bf1622.020.5865– 4 –
Portable fp32not measured
Portablebf1622.000.586343.13 4 –
Kernelsbf1622.000.586343.13 4 –

The original code was not run on this dataset, so the table cannot show the distance to it.

SeedVR2 is a generative one-step restorer, so PSNR is only a fidelity check. Each of the centre 512 px crops of DIV2K validation HR images (a tiny subset: generation is slow) is downscaled with bicubic x2 (PIL) and restored x2 by the model, one pass; PSNR and SSIM (Gaussian 11 x 11, sigma 1.5) on the Y channel of the uint8 output with a 2 px border cropped, averaged over the crops; PSNR to the original = RGB uint8 PSNR of our output against the authors' output of the same input and settings. The original is the authors' inference code, bf16. No perceptual metric (LPIPS) is given: the lpips package and its network weights are not part of the test environment. Original = the authors’ code, same checkpoint and protocol. Measured on original fp16: RTX 5060 Ti, torch 2.14.1+cu130, 2026-11-16; portable, kernels: RTX 5060 Ti, torch 2.14.1+cu130, fastforks 33b2432c, 2026-11-16.

DIV2K validation

25 bicubic x2 center crops of 64 x 64 LR pixels, RGB PSNR

Rundtypepsnr ↑imagesms / image
Original fp32not measured
Original fp16not measured
Portable fp32not measured
Portablebf1620.2542 25 81.6
Kernelsnot measured

The original code was not run on this dataset, so the table cannot show the distance to it.

Every fourth DIV2K validation image. A 64 x 64 center crop of the official bicubic x2 input is restored at 128 x 128 and compared with the corresponding original pixels. PSNR uses RGB in [0, 1] and is averaged over the 25 crops. Both modes use resident BF16 weights and seed 666. Measured on RTX 5060 Ti, torch 2.14.1+cu130, fastforks 29b3bbad, 2026-11-18.

4 video clips (first frame)

PSNR to the original's output

Rundtypepsnr_orig ↑clipsms / clip
Original fp32not measured
Original fp16not measured
Portable fp32not measured
Portablebf1644.56 4 –
Kernelsbf1644.56 4 –

The original code was not run on this dataset, so the table cannot show the distance to it.

First frame of each clip (clips of 2 to 10 frames, x2); PSNR of our output (RGB, uint8) against the authors' output of the same clip; there is no ground truth for these clips. Measured on RTX 5060 Ti, torch 2.14.1+cu130, fastforks 33b2432c, 2026-11-16.

Closeness to the original

Beyond the test-set scores: the raw output of ours against the original’s fp32 output on the same input, pixel by pixel. CPU, float32: max |diff| <= 0.02 vs the original. GPU, bfloat16 (the default), portable and kernels: mean |diff| <= 0.01 and p99 <= 0.05 (absolute error of the output image).

CheckToleranceMeasured
CPU fp32, max |diff|≤ 0.02 not recorded
GPU default dtypes, mean |diff|≤ 0.01 0
GPU default dtypes, p99 |diff|≤ 0.05 0

Recorded for seedvr2-3b on RTX 5060 Ti, torch 2.14.1+cu130, 2026-11-14, with these kernels: nf4

Details

SeedVR2 (Wang et al., ByteDance Seed 2025): one-step video restoration and super-resolution by a diffusion transformer (NaDiT, adversarially post-trained) on the latents of a causal 3-D VAE. `seedvr2-3b` and `seedvr2-7b` are the 3 B and 7 B transformers (same VAE); frames are restored one at a time.

Input / output
Input: one RGB image. Output: the restored (upscaled) image, model.scale x the input size, RGB in [0, 1].
What the numbers mean, and which models need the camera focal length

tile= runs large images in overlapping tiles (as ComfyUI).

Input size
any H x W >= 8, padded to a multiple of 8; tested up to 512x512 (11.7 GiB allocated)
Options
  • seed=666· changes the output
  • stream=true· changes the output
  • quant="none"one of 'none', 'nf4'· changes the output
Outputs
image
CUDA kernels
  • nf4

Limitations

  • Generative restoration: the output depends on `seed` (one CPU generator draws the VAE posterior noise and the diffusion noise, upstream's default 666); other seeds give other plausible details.
  • One frame per call: the clip mode of the original (temporal attention over 4n + 1 frames) is not used by this image API.
  • The input is padded on the bottom and right (replicate) so that `scale x` its size is a multiple of 16, and the output cropped back; the original centre-crops the resized frame to a multiple of 16 instead.
  • No colour fix: the authors' scripts optionally match the output colours to the input with StableSR's wavelet reconstruction (non-commercial code), which is not included.
  • The 3 B model needs ~7 GB for its weights plus the VAE's activations (~14 GB peak at 960 x 1696 output); `stream=False` keeps them resident; by default (`stream=True`, CUDA) they stay in ~6.6 GB of page-locked host RAM (~9 GB peak at that size).
  • The 3 B TensorRT measurement uses `stream=False` and fixed 64 x 64 input. Export with `export_onnx`, then build the engine in a fresh process. On 25 DIV2K crops the largest per-crop PSNR change was 0.109 dB. The largest single-pixel RGB channel difference was 0.627 on the [0, 1] scale.
  • The 7 B model's weights are 16.5 GB in bf16: it runs with the default `stream=True` (blocks in ~16.5 GB of page-locked host RAM; load fails with an error when less is free) or `quant="nf4"` (~4.6 GB resident); with `stream=false` and no quant it runs out of GPU memory.
  • `quant="nf4"` changes the generated detail: 23-27 dB PSNR against the bf16 output (3 B, 4 clips; 7 B: 26-31 dB, 2 clips), about as far as another `seed` (18-24 dB), with ~3.5x smaller transformer blocks.
Full reference, generated from the repository

SeedVR2 (Wang et al., ByteDance Seed, 2025): upscales and restores photos and video frames x2 with a large diffusion transformer run for a single step; 3 B and 7 B versions, the 7 B runs on 16 GB with weight streaming (default, ~17 GB free host RAM). Apache-2.0 code and weights.

Commercial use: yes.

variantinputbackendtime (ms)peak memory (MiB, allocated / reserved)
seedvr2-3bsynthetic (512x512)original
portable
kernels
portable + torch.compile
13150
2295
2296
1941
7598 / 15268
6140 / 6772
6140 / 6772
5237 / 8144
seedvr2-3b64x64original
portable
kernels
TensorRT bf16
–
–
–
46.8
–
–
–
7662 / 7664
seedvr2-7bsynthetic (512x512)original
portable
kernels
portable + torch.compile
TensorRT fp16
OOM
2712
2713
fails: load: OutOfMemoryError: CUDA out of memory. Tried to allocat
fails: RuntimeError: Inplace update to inference tensor outside Inf
–
6402 / 7034
6402 / 7034
–
–

Weight streaming

Warm inference time and peak reserved GPU memory for the same input with both settings. Streamed weights use pinned host memory.

ModelModeInputGPUPyTorchResident (stream=False)Streamed (stream=True)
seedvr2-3bportable512x512RTX 5060 Ti2.14.1+cu1302,281 ms / 15,348 MiB2,294 ms / 8,876 MiB
seedvr2-7bportable512x512RTX 5060 Ti2.14.1+cu130Out of memory2,715 ms / 8,880 MiB
Details
  • Original code: https://github.com/ByteDance-Seed/SeedVR at e4de8c24441a
  • Code licence: Apache-2.0 (permissive); files: LICENSE, NOTICE
  • Weights licence: Apache-2.0
  • Licence evidence: https://github.com/ByteDance-Seed/SeedVR/blob/e4de8c24441a67e1b7df56abea10645059bb1185/LICENSE ; https://huggingface.co/ByteDance-Seed/SeedVR2-3B (license: apache-2.0)
  • Training data: Paper (arXiv 2506.05301): adversarial post-training of SeedVR on large-scale image and video data with synthetic degradations; the data sources and terms are not stated.
  • Licence note: The converted weight files (bf16 transformer with the fixed prompt embedding, bf16 VAE) are hosted by fastforks under the originals' Apache-2.0 licence; NOTICE keeps the attribution and lists the changes.
  • Options: seed = 666, stream = True, quant = none (one of 'none', 'nf4')
  • Kernel libraries: nf4
  • Variants: seedvr2-3b, seedvr2-7b
  • Outputs: image
  • Input size: any H x W >= 8, padded to a multiple of 8
  • Tested up to (portable, fp16, RTX 5060 Ti 16 GB): seedvr2-3b 512x512 (11.7 GiB peak allocated, 15.0 reserved); seedvr2-7b 512x512 (6.3 GiB peak allocated, 8.7 reserved)
  • seedvr2-3b 512x512, first call: portable + torch.compile 238 s (cold Inductor cache).
  • seedvr2-3b 64x64, first call: TensorRT bf16 324 s (ONNX + engine).
  • seedvr2-3b original 512x512: load: the authors' fp32 .pth files from the page cache (read once before)
  • seedvr2-3b load / first call: original 96.2 s / 13.89 s, portable 2.65 s / 2.454 s, kernels 3.27 s / 2.462 s
  • seedvr2-7b load / first call: portable 222.77 s / 3.174 s, kernels 118.43 s / 3.176 s
  • Protocol, first call, 3 warm-up, peak reset, median of 3 rounds x median of 5

Measured

SeedVR2 is a generative one-step restorer, so PSNR is only a fidelity check. Each of the centre 512 px crops of DIV2K validation HR images (a tiny subset: generation is slow) is downscaled with bicubic x2 (PIL) and restored x2 by the model, one pass; PSNR and SSIM (Gaussian 11 x 11, sigma 1.5) on the Y channel of the uint8 output with a 2 px border cropped, averaged over the crops; PSNR to the original = RGB uint8 PSNR of our output against the authors' output of the same input and settings. The original is the authors' inference code, bf16. No perceptual metric (LPIPS) is given: the lpips package and its network weights are not part of the test environment. Every fourth DIV2K validation image. A 64 x 64 center crop of the official bicubic x2 input is restored at 128 x 128 and compared with the corresponding original pixels. PSNR uses RGB in [0, 1] and is averaged over the 25 crops. Both modes use resident BF16 weights and seed 666. First frame of each clip (clips of 2 to 10 frames, x2); PSNR of our output (RGB, uint8) against the authors' output of the same clip; there is no ground truth for these clips. Original = the original code named under Details, same checkpoint and protocol.

variantdatasetoriginal fp16portablekernelsTensorRTnote
seedvr2-3bDIV2K validation, 4 centre crops 512 px, bicubic x2 LR -> HR, PSNR / SSIM (Y) / PSNR to the original22.02 / 0.5865 / –22.00 / 0.5863 / 43.1322.00 / 0.5863 / 43.13
seedvr2-3bDIV2K validation, 25 bicubic x2 center crops of 64 x 64 LR pixels, RGB PSNR20.254220.2671
seedvr2-3b4 video clips (first frame), PSNR to the original's output44.5644.56
seedvr2-7bDIV2K validation, 2 centre crops 512 px, bicubic x2 LR -> HR, PSNR / SSIM (Y) / PSNR to the original23.16 / 0.6228 / –23.13 / 0.6227 / 44.8523.13 / 0.6227 / 44.85
seedvr2-7b2 video clips (first frame), PSNR to the original's output46.1446.14

Measured on portable: NVIDIA GeForce RTX 5060 Ti, torch 2.14.1+cu130, fastforks 29b3bbad / 33b2432c, 2026-11-16 to 2026-11-18; kernels: NVIDIA GeForce RTX 5060 Ti, torch 2.14.1+cu130, fastforks 33b2432c, 2026-11-16; tensorrt: NVIDIA GeForce RTX 5060 Ti, torch 2.14.1+cu130, fastforks 29b3bbad, 2026-11-18.

Parity

CPU, float32: max |diff| <= 0.02 vs the original. GPU, bfloat16 (the default), portable and kernels: mean |diff| <= 0.01 and p99 <= 0.05 (absolute error of the output image).

variantkernels error vs original, mean / p99GPU, torchkernels used
seedvr2-3b0.0 / 0.0RTX 5060 Ti, torch 2.14.1+cu130nf4@e236d80ba78b:sm_120
seedvr2-7b0.0 / 0.0RTX 5060 Ti, torch 2.14.1+cu130nf4@e236d80ba78b:sm_120

Limitations

  • Generative restoration: the output depends on seed (one CPU generator draws the VAE posterior noise and the diffusion noise, upstream's default 666); other seeds give other plausible details.
  • One frame per call: the clip mode of the original (temporal attention over 4n + 1 frames) is not used by this image API.
  • The input is padded on the bottom and right (replicate) so that scale x its size is a multiple of 16, and the output cropped back; the original centre-crops the resized frame to a multiple of 16 instead.
  • No colour fix: the authors' scripts optionally match the output colours to the input with StableSR's wavelet reconstruction (non-commercial code), which is not included.
  • The 3 B model needs ~7 GB for its weights plus the VAE's activations (~14 GB peak at 960 x 1696 output); stream=False keeps them resident; by default (stream=True, CUDA) they stay in ~6.6 GB of page-locked host RAM (~9 GB peak at that size).
  • The 3 B TensorRT measurement uses stream=False and fixed 64 x 64 input. Export with export_onnx, then build the engine in a fresh process. On 25 DIV2K crops the largest per-crop PSNR change was 0.109 dB. The largest single-pixel RGB channel difference was 0.627 on the [0, 1] scale.
  • The 7 B model's weights are 16.5 GB in bf16: it runs with the default stream=True (blocks in ~16.5 GB of page-locked host RAM; load fails with an error when less is free) or quant="nf4" (~4.6 GB resident); with stream=false and no quant it runs out of GPU memory.
  • quant="nf4" changes the generated detail: 23-27 dB PSNR against the bf16 output (3 B, 4 clips; 7 B: 26-31 dB, 2 clips), about as far as another seed (18-24 dB), with ~3.5x smaller transformer blocks.

Example output

No example rendered for this checkpoint yet.