Practical overview
When it fits
Use Flavr when you need a code-based workflow for interpolating video frames or want to train and evaluate the FLAVR method. Its README documents pretrained-model processing of custom videos and dataset-based model training.
Who it is for
- Developers building video-processing workflows that need frame interpolation.
- Researchers or practitioners training and evaluating interpolation models on video datasets.
- Users comfortable running Python command-line scripts with model checkpoints.
Documented uses
- Generate intermediate frames to create higher-frame-rate or slow-motion video.
- Apply 2×, 4× or 8× interpolation using listed pretrained FLAVR models.
- Train a FLAVR model on Vimeo-90K septuplets or adapt the documented training configuration for GoPro.
- Evaluate predictions on Vimeo-90K or the Middlebury benchmark using the repository’s scripts.
Requirements & limits
The repository is public and lists an Apache-2.0 license.
- Custom-video interpolation requires OpenCV 4.2.0 in addition to the listed Python and deep-learning dependencies.
- The README lists pretrained FLAVR models for 2×, 4× and 8× interpolation.
- Training instructions cover Vimeo-90K septuplets and describe changing the output count for 8× GoPro training.
- The README says motion-magnification trained models are not available in the repository.
Check current requirements in the official documentation. Source-based guidance does not mean OpenViST has run or independently tested this project.
Interpolate a custom video with a pretrained model
Use FLAVR’s documented script to produce a slow-motion video at a higher frame rate.
Before you start
- Ubuntu 18.04, Python 3.7.4, NumPy 1.19.2, PyTorch 1.5.0, torchvision 0.6.0 and CUDA toolkit 10.1 are the listed training and testing dependencies.
- OpenCV 4.2.0 is required for the custom-video workflow.
- A custom input video and a pretrained FLAVR model; the repository lists 2×, 4× and 8× model links.
Steps
Obtain a pretrained model matching the desired interpolation factor.
Run the command below for the documented 8× example.
python interpolate.py --input_video --factor 8 --load_modelFor 2× interpolation, use a 2× model and set
--factor 2.
Expected outcome
The script applies the selected interpolation factor to the input video; the README gives 30 FPS to 240 FPS as the 8× example and 30 FPS to 60 FPS as the 2× example.
Guide limitations
- The guide documents command-line processing, not a graphical editor.
- The stated OpenCV requirement is version 4.2.0.
- The example’s input and model paths must be supplied by the user.
Train a model on Vimeo-90K septuplets
Set up the documented FLAVR training run using the Vimeo-90K septuplet dataset.
Before you start
- Ubuntu 18.04, Python 3.7.4, NumPy 1.19.2, PyTorch 1.5.0, torchvision 0.6.0 and CUDA toolkit 10.1.
- A local path to the Vimeo-90K septuplet dataset.
Steps
Obtain the Vimeo-90K dataset from the dataset link referenced in the repository README.
Set `` to the dataset location.
Run the command below.
python main.py --batch_size 32 --test_batch_size 32 --dataset vimeo90K_septuplet --loss 1*L1 --max_epoch 200 --lr 0.0002 --data_root --n_outputs 1
Expected outcome
The command starts the documented training configuration for Vimeo-90K septuplets.
Guide limitations
- The README says the reported results used 8 GPUs; it does not specify a minimum hardware configuration.
- For GoPro training, the README says to change
n_outputsto 7 for 8× interpolation, but does not provide a complete separate command.
Sources & review
Source record details
- Source availability
- Active
- Sources checked
- 14 October 2026
- Original website title
- tarun005/FLAVR · Official homepage title · retained in its source language