VideoProc Converter AI — Model Zoo (VideoProc 8.x)
Model weights extracted from the local model stack of VideoProc Converter AI (Digiarty, 8.x series). This repository is a preservation / interoperability archive of the neural networks the application downloads and runs locally: image/video super-resolution, frame interpolation, and a small set of bundled offline NCNN / DeepFilterNet models.
The TensorRT engines are GPU-locked; the ONNX weights are the hardware-agnostic target.
Contents
| Path | What | Files | Size |
|---|---|---|---|
models_unpacked/ | Native weights: 31 portable ONNX + 1 508 TensorRT engines | 1 539 | ~53 GiB |
app/models/ | Bundled offline models shipped in the installer (NCNN bin+param, DeepFilterNet) | 12 weight files | ~63 MiB |
MODEL_ZOO_MANIFEST.json / .csv | Full per-file catalogue (category, backend, size, model key) | — | ~1 MiB |
MODELS.md | Technical detail: backends, layout, feature→model mapping | — | — |
tools/ | ONNX inference example (test_sr_onnx.py) | — | — |
Layout
models_unpacked/
├── image/super_resolution/onnx/ 6 × ONNX image-SR (×1/×2/×4, MoDetail V2)
├── image/super_resolution/tensorrt861-rt6xx/ TRT engines (RTX 3060 class, TRT 8.6.1)
├── video/super_resolution/onnx/ 6 × ONNX video-SR (×1/×2/×4, Video4K V9/V10)
├── v3/image/super_resolution/onnx/ 11 × AIGC / MoDetail V3 image-SR
├── v3/image/super_resolution/tensorrt*/ per-GPU/per-resolution engines
├── v3/video/super_resolution/onnx/ 7 × video-SR (superVIDEO / MoDetail / smooth)
├── v3/video/super_resolution/tensorrt*/ per-GPU/per-resolution engines
└── v3/video/frame_interpolation/onnx/ 2 × flownet (fp16 / fp32)
app/models/
├── df/dfn30.m, dfn31.m DeepFilterNet3 audio denoise (gzipped ONNX tar)
├── film/flownet.m, flownet.p NCNN frame interpolation
├── sr/x4.m, x4.p NCNN ×4 image SR
└── sr_ani/{pro,se}/*.m, *.p NCNN anime image SR
Inventory
| Category | Portable ONNX | TensorRT engines |
|---|---|---|
| Image super-resolution (v1) | 6 | 50 |
| Image super-resolution (v3, AIGC) | 11 | 119 |
| Video super-resolution (v1 + v3) | 13 | ~1 410 |
| Frame interpolation | 2 | 226 |
| Bundled NCNN / DeepFilterNet | — | 12 files |
| Total | 31 ONNX | 1 508 engines |
TensorRT engines are serialized per GPU and precision — they load only on matching hardware + matching TRT/CUDA build:
| Tag | Target | Notes |
|---|---|---|
tensorrt861-rt601/705/806/809 | NVIDIA RTX 30/40 series | TensorRT 8.6.1 class |
tensorrt1090-rt1200{,-compatible} | NVIDIA RTX 50 series | TensorRT 10.9, fp32/fp16 |
For generic hardware, use the ONNX set through onnxruntime.
Usage
ONNX (portable, any CPU/GPU)
import onnxruntime as ort, numpy as np
sess = ort.InferenceSession(
"models_unpacked/v3/video/super_resolution/onnx/"
"Aiarty_superVIDEO_MoDetail_x2_V11_dim40_327000_768.onnx",
providers=["CPUExecutionProvider"], # or CUDAExecutionProvider
)
inp, out = sess.get_inputs()[0], sess.get_outputs()[0]
x = np.random.rand(1, 3, 128, 128).astype(np.float32)
y = sess.run([out.name], {inp.name: x})[0] # dynamic shapes resolved at load time
Input/output are NCHW float32 in [0,1]. Scale factors are fixed by the model
(×1 / ×2 / ×4), and dynamic input dimensions are resolved at load time —
verified: 128×128 → 256×256 (×2), 256×256 → 1024×1024 (×4).
TensorRT engines
Require the same NVIDIA GPU the engine was serialized for, plus a compatible
TensorRT/CUDA runtime (8.6.1 or 10.9 families). Deserialize with
nvinfer1::IRuntime::deserializeCudaEngine (C++) or tensorrt.Runtime (Python).
Bundled NCNN / DeepFilterNet
app/models/**/*.p+*.m— NCNN param + bin (param magic7767517), run with Tencentncnn(Vulkan) or CPU fallback.app/models/df/dfn30.m,dfn31.m— gzipped ONNX tar for DeepFilterNet3 audio denoise, consumed by Rusttractor ONNX Runtime.app/models/film/flownet.*— frame interpolation (NCNN).
Notes
- The 11
v3/contrib/*entries (CodeFormer, GFPGAN, DDColor,htdemucs, YOLO, ResNet-34, AdaAttn) are 808-byte stubs in the source distribution — they carry no payload, so there is nothing to mirror. - Windows runtime glue (GUI, worker, model-manager DLL, D3D11 capture): not required to run the weights.
- Classic OpenCV video stabilization: not a neural network.