# How the `--exp` and `--fps` Parameters Control Video Interpolation in `inference_video.py` > Learn how --exp and --fps parameters control video interpolation in inference_video.py. Adjust frame generation and output fps for enhanced video quality. - Repository: [hzwer/eccv2022-rife](https://github.com/hzwer/eccv2022-rife) - Tags: how-to-guide - Published: 2026-03-03 --- **The `--exp` parameter defines a power-of-two multiplier for frame generation (default 1 = 2× frames), while `--fps` optionally overrides the output frame rate regardless of the interpolation factor.** The [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py) script in the RIFE (Real-Time Intermediate Flow Estimation) repository serves as the primary command-line interface for video frame interpolation. These two arguments directly govern the temporal resolution of your output, controlling both how many intermediate frames the neural network synthesizes and the playback speed encoded in the final video file. ## Understanding the `--exp` Interpolation Exponent The `--exp` parameter acts as an exponent to determine the upsampling factor. In [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py), the argument parser defines it with a default value of 1: ```python parser.add_argument('--exp', dest='exp', type=int, default=1) ``` The script calculates the total interpolation factor as `2 ** args.exp`. This value drives three critical operations in the source code: - **Frame rate multiplication**: At lines 118-121, the script computes `args.fps = fps * (2 ** args.exp)` to determine the target playback rate when `--fps` is not manually specified. - **Filename annotation**: Lines 150-152 build the output filename using `'{}_{}X_{}fps.'.format(..., 2**args.exp, ...)` to indicate the upsampling level. - **Frame generation count**: The `make_inference` call at lines 258-260 receives `2**args.exp-1`, dictating exactly how many intermediate frames to generate between each pair of source frames. For example: - `exp=1` generates 1 intermediate frame between each source pair (2× total frames) - `exp=2` generates 3 intermediate frames (4× total frames) - `exp=3` generates 7 intermediate frames (8× total frames) ### Performance Implications Higher exponent values produce smoother motion but increase computational load exponentially. Because the script calls the inference model `2^exp - 1` times per source interval, setting `--exp 3` requires generating seven times more frames than the original video, significantly increasing GPU memory usage and processing time. ## Understanding the `--fps` Output Override While `--exp` determines interpolation density, `--fps` controls the temporal metadata written to the output video container. The argument is defined at lines 66-68: ```python parser.add_argument('--fps', dest='fps', type=int, default=None) ``` When omitted, the script defaults to `None` and automatically calculates the output FPS based on the source FPS multiplied by `2 ** args.exp` (lines 118-121). When you provide a specific integer, the script bypasses this calculation and passes your value directly to `cv2.VideoWriter` at line 152. This decoupling allows specific use cases: you can generate 4× intermediate frames (`--exp 2`) but encode the video at 60 FPS to create slow-motion footage, or force 24 FPS to match film standards regardless of the source material. ## Practical Usage Examples Here are concrete command-line scenarios demonstrating parameter interaction: Double the frame rate using default settings: ```bash python inference_video.py --video input.mp4 --output out.mp4 ``` Quadruple the frame rate with explicit exponent (auto-calculates output FPS to 4× source): ```bash python inference_video.py --video input.mp4 --exp 2 --output out_quad.mp4 ``` Generate 4× frames but force 60 FPS output (creating slow-motion if source was 30 FPS): ```bash python inference_video.py --video input.mp4 --exp 2 --fps 60 --output out_60fps.mp4 ``` Process an image sequence with 8× upsampling: ```bash python inference_video.py --img ./frames/ --exp 3 --output seq_out.mp4 ``` ## Summary - **`--exp`** sets the interpolation exponent; the script generates `2^exp - 1` frames between each source pair and multiplies the source frame rate by `2^exp` when `--fps` is not specified. - **`--fps`** overrides the output frame rate metadata in [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py), allowing custom playback speeds independent of the interpolation factor. - **Default behavior**: With `--exp 1` and no `--fps`, the script doubles the source frame rate automatically using the logic at lines 118-121. - **Key implementation**: The upsampling logic resides in [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py) lines 118-121 and 258-260, with the final video encoding performed at line 152 using the calculated or overridden FPS value. ## Frequently Asked Questions ### What is the default value of `--exp` in [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py)? The default value is `1`, which produces a 2× upsampling factor (one interpolated frame between each source frame). This is defined in the argument parser near the beginning of the script and results in the output frame rate being double the input rate unless `--fps` is specified. ### How does the `--exp` value affect GPU memory usage? Processing requirements scale with `2 ** exp` because the script calls the `make_inference` function `2^exp - 1` times per source frame interval. Setting `--exp 3` requires the model to generate seven intermediate frames for every source frame, significantly increasing VRAM consumption and compute time compared to the default `--exp 1`. ### Should I use `--fps` or let the script calculate the frame rate automatically? Use automatic calculation (omit `--fps`) when you want the output to play at normal speed with higher temporal resolution. Specify `--fps` when you need to match specific broadcast standards (e.g., 24p, 60p) or create slow-motion effects where the interpolation factor exceeds the desired playback rate. ### Can I use `--fps` without `--exp`? Yes. If you specify `--fps` without changing `--exp` from its default of 1, the script will still generate 2× frames (one interpolation per source pair) but encode them at your specified rate. This effectively speeds up or slows down the video playback relative to real-time, depending on whether your specified FPS is higher or lower than the source FPS multiplied by 2.