# How to Use Docker with GPU Acceleration for RIFE Inference

> Accelerate RIFE inference with Docker and GPU. Build the image, mount models, and use --gpus all for faster frame interpolation.

- Repository: [hzwer/eccv2022-rife](https://github.com/hzwer/eccv2022-rife)
- Tags: how-to-guide
- Published: 2026-03-03

---

**Run RIFE frame interpolation inside a Docker container by building the image from `docker/Dockerfile`, mounting your pre-trained models to `train_log/`, and launching with `--gpus all` to expose host NVIDIA drivers for GPU-accelerated inference.**

The [hzwer/eccv2022-rife](https://github.com/hzwer/ECCV2022-RIFE) repository provides a complete Docker setup for running RIFE (Real-Time Intermediate Flow Estimation) inference with GPU support. This guide explains how to build the container image, configure NVIDIA driver capabilities, and execute both image and video interpolation while leveraging your host GPU hardware.

## Prerequisites for GPU-Accelerated RIFE Docker Setup

Before building the RIFE Docker image, ensure your system meets the following requirements:

- **Docker Engine 19.03 or newer** with the NVIDIA Container Toolkit installed
- **NVIDIA GPU drivers** compatible with your CUDA version on the host system
- **NVIDIA Docker runtime** configured as the default or available runtime

The RIFE Dockerfile uses `python:3.8-slim` as its base image, which is CPU-only, but relies on the host's NVIDIA driver stack exposed through Docker's GPU runtime to access CUDA capabilities inside the container.

## Building the RIFE Docker Image

Clone the repository and build the image using the provided Dockerfile located at `docker/Dockerfile`:

```bash
git clone https://github.com/hzwer/ECCV2022-RIFE.git
cd ECCV2022-RIFE
docker build -t rife -f docker/Dockerfile .

```

The build process performs the following actions defined in `docker/Dockerfile`:

1. Installs system dependencies including `ffmpeg` and `libgl1-mesa-glx`
2. Copies the entire repository into `/rife` inside the container
3. Installs Python requirements from [`requirements.txt`](https://github.com/hzwer/eccv2022-rife/blob/main/requirements.txt) (including PyTorch)
4. Sets the environment variable `ENV NVIDIA_DRIVER_CAPABILITIES all` to ensure the NVIDIA runtime exposes all driver capabilities to the container
5. Configures `/bin/bash` as the entrypoint for interactive use

## Running RIFE Inference with GPU Acceleration in Docker

To execute inference with GPU support, you must run the container with the `--gpus all` flag and mount your input files and pre-trained models. The repository provides wrapper scripts at `docker/inference_img` and `docker/inference_video` that forward arguments to the Python inference scripts.

### Image Interpolation

Place your pre-trained model files (`.pkl`) in the `train_log/` directory at the repository root, then run:

```bash
docker run --rm -it \
    --gpus all -v /dev/dri:/dev/dri \
    -v "$(pwd)":/host \
    rife:latest inference_img \
      --img img0.png img1.png \
      --exp 4 \
      --model train_log

```

**Key parameters explained:**

- `--gpus all` exposes all host GPUs to the container using the NVIDIA Container Toolkit
- `-v /dev/dri:/dev/dri` bind-mounts the Direct Rendering Infrastructure device for GPU access
- `-v "$(pwd)":/host` mounts your current working directory (containing input images and the `train_log/` model directory) to `/host` inside the container
- `--exp 4` specifies \(2^4 = 16\)× frame interpolation
- The `inference_img` wrapper invokes [`inference_img.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_img.py), which automatically selects GPU execution when `torch.cuda.is_available()` returns true

### Video Interpolation

For video files, use the `inference_video` wrapper:

```bash
docker run --rm -it \
    --gpus all -v /dev/dri:/dev/dri \
    -v "$(pwd)":/host \
    rife:latest inference_video \
      --video input.mp4 \
      --exp 2 \
      --model train_log \
      --output output_4X.mp4

```

The [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py) script handles frame extraction, GPU-accelerated interpolation, and audio transfer (via the `transferAudio` function) to ensure the output video retains the original audio track.

### Enabling Half-Precision for Faster Inference

To reduce memory bandwidth and increase throughput on GPUs with Tensor Cores (such as NVIDIA RTX series), add the `--fp16` flag to either inference command:

```bash
docker run --rm -it \
    --gpus all -v /dev/dri:/dev/dri \
    -v "$(pwd)":/host \
    rife:latest inference_video \
      --video input.mp4 \
      --exp 2 \
      --fp16 \
      --model train_log

```

The `--fp16` flag enables half-precision floating point operations, which the underlying PyTorch implementation in [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py) and [`inference_img.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_img.py) automatically applies when the flag is present.

## How GPU Acceleration Works Inside the Container

The RIFE Docker setup leverages the host's NVIDIA driver stack through several coordinated mechanisms:

1. **Driver Capability Exposure**: The `ENV NVIDIA_DRIVER_CAPABILITIES all` setting in `docker/Dockerfile` instructs the NVIDIA Container Toolkit to expose compute, utility, and graphics capabilities to the container.

2. **Runtime GPU Selection**: Both [`inference_img.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_img.py) and [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py) check `torch.cuda.is_available()` to automatically select CUDA execution when GPUs are present. No manual device specification is required.

3. **Entrypoint Wrappers**: The shell scripts at `docker/inference_img` and `docker/inference_video` serve as thin wrappers that forward all command-line arguments to their respective Python scripts, ensuring the Docker command interface matches the native Python interface.

## Summary

- **Build** the RIFE Docker image using `docker build -t rife -f docker/Dockerfile .` after cloning the hzwer/eccv2022-rife repository.
- **Mount** your pre-trained model files (`.pkl`) to the `train_log/` directory via volume mapping `-v "$(pwd)":/host`.
- **Enable GPU acceleration** by running containers with `--gpus all` and `-v /dev/dri:/dev/dri` to expose host NVIDIA drivers to the PyTorch backend.
- **Execute inference** using the wrapper scripts `inference_img` or `inference_video`, which automatically detect CUDA availability and support half-precision (`--fp16`) for faster RTX GPU performance.

## Frequently Asked Questions

### Do I need an NVIDIA GPU to use Docker with RIFE?

While the RIFE Docker container can run on CPU-only systems, GPU acceleration requires an NVIDIA GPU with compatible drivers on the host machine. The container uses `torch.cuda.is_available()` to automatically detect GPU presence, falling back to CPU execution if CUDA is unavailable. For production inference, an NVIDIA GPU is strongly recommended to achieve real-time frame interpolation performance.

### How do I mount my pre-trained models in the RIFE Docker container?

Place your downloaded `.pkl` model files in a `train_log/` directory at the repository root, then mount the current working directory to `/host` inside the container using `-v "$(pwd)":/host`. The inference scripts expect the `--model` argument to point to this mounted directory (e.g., `--model train_log`). This bind-mount approach ensures the container can access both your input media files and the trained model weights without copying them into the image.

### Can I run RIFE Docker inference on CPU-only systems?

Yes, the RIFE Docker container will function on CPU-only hosts, but you must omit the `--gpus all` flag when running the container. The inference scripts in [`inference_img.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_img.py) and [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py) automatically check for CUDA availability and execute on CPU if no GPU is detected. However, expect significantly slower processing times compared to GPU acceleration, especially for high-resolution video interpolation.

### What Docker flags are required for GPU acceleration with RIFE?

To enable GPU acceleration, you must include three specific configurations in your `docker run` command: `--gpus all` to expose all host GPUs to the container, `-v /dev/dri:/dev/dri` to bind-mount the Direct Rendering Infrastructure device node, and ensure the image was built with `ENV NVIDIA_DRIVER_CAPABILITIES all` (already configured in the repository's `docker/Dockerfile`). These settings allow PyTorch inside the container to detect and utilize the host's NVIDIA drivers for CUDA acceleration.