# How to Interpret PSNR and SSIM Benchmark Metrics for Frame Interpolation in RIFE

> Understand PSNR and SSIM metrics for RIFE frame interpolation. Learn how these benchmarks measure reconstruction fidelity and highlight quality with typical Vimeo90K scores.

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

---

**PSNR and SSIM quantify reconstruction fidelity in RIFE by measuring pixel-wise error and structural similarity, with typical Vimeo-90K scores around 36 dB PSNR and 0.96 SSIM indicating high-quality interpolation.**

Frame interpolation generates intermediate frames between existing ones, and evaluating quality requires standardized metrics. The `hzwer/eccv2022-rife` repository uses **PSNR** (Peak Signal-to-Noise Ratio) and **SSIM** (Structural Similarity Index) as primary benchmarks across datasets like Vimeo-90K, UCF-101, and ATD-12K. Understanding how to interpret these values helps you compare model checkpoints and diagnose interpolation artifacts.

## What PSNR and SSIM Measure for Frame Interpolation

### Peak Signal-to-Noise Ratio (PSNR)

PSNR measures the ratio between the maximum possible pixel value (typically 255 for 8-bit images) and the mean squared error (MSE) between the ground truth and interpolated frame. In `hzwer/eccv2022-rife`, the calculation follows the standard formula:

```python
psnr = 10 * np.log10(255.0 ** 2 / np.mean((gt - pred) ** 2))

```

For frame interpolation, PSNR values typically range from 20–40 dB. Scores above 30 dB generally indicate good quality, while small improvements of 0.1–0.5 dB can signal perceptible visual gains in challenging motion scenarios.

### Structural Similarity Index (SSIM)

SSIM evaluates perceptual similarity by comparing luminance, contrast, and structure between the ground truth and predicted frames. Unlike PSNR, SSIM correlates more closely with human visual perception, making it crucial for assessing edge preservation and texture fidelity in interpolated sequences.

The repository computes SSIM using:

```python
ssim = compare_ssim(gt, pred, multichannel=True, data_range=255)

```

SSIM values range from 0 to 1, with typical frame interpolation results falling between 0.70–0.95. Scores exceeding 0.90 indicate excellent structural preservation, while gains of 0.01–0.02 often correspond to noticeable reductions in blurring or ghosting artifacts.

## How RIFE Computes PSNR and SSIM Benchmarks

The `hzwer/eccv2022-rife` repository implements standardized evaluation pipelines across multiple datasets. Each benchmark script follows a consistent workflow:

1. **Load ground truth frames** from high-frame-rate sequences
2. **Generate intermediate frames** using [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py) or direct model inference
3. **Calculate metrics** using the PSNR and SSIM formulas shown above
4. **Average results** across all test sequences

You can find the implementation in these key files:

- [`benchmark/Vimeo90K.py`](https://github.com/hzwer/eccv2022-rife/blob/main/benchmark/Vimeo90K.py) – Evaluates on the Vimeo-90K septuplet test set
- [`benchmark/UCF101.py`](https://github.com/hzwer/eccv2022-rife/blob/main/benchmark/UCF101.py) – Tests on the UCF-101 action dataset  
- [`benchmark/ATD12K.py`](https://github.com/hzwer/eccv2022-rife/blob/main/benchmark/ATD12K.py) – Benchmarks on the large-scale ATD-12K dataset
- [`benchmark/HD_multi_4X.py`](https://github.com/hzwer/eccv2022-rife/blob/main/benchmark/HD_multi_4X.py) – Reports PSNR across multiple HD resolutions (544×1280, 720p, 1080p)

The console output follows a standardized format. For Vimeo-90K, UCF-101, and ATD-12K, the scripts print:

```text
Avg PSNR: 36.12 SSIM: 0.962

```

For HD benchmarks, the output shows resolution-specific values:

```text
PSNR: 35.8(544*1280), 34.2(720p), 32.1(1080p)

```

## Interpreting PSNR and SSIM Results in Practice

When evaluating frame interpolation quality in RIFE, consider both metrics together. PSNR indicates overall reconstruction accuracy, while SSIM reveals structural fidelity. A model improvement that increases PSNR but decreases SSIM may indicate over-smoothing or ringing artifacts that pixel-wise averaging misses but human perception catches.

Use this reference table to interpret benchmark changes:

| Scenario | PSNR Change | SSIM Change | Likely Visual Impact |
|----------|-------------|-------------|----------------------|
| Minimal improvement | +0.1 dB | +0.001 | Hardly noticeable; likely statistical noise |
| Moderate gain | +0.5 dB | +0.01 | Clear sharpening of edges and reduced blurriness |
| Significant improvement | +1.5 dB | +0.03 | Noticeable reduction in ghosting/artifacts; smoother motion |
| Divergent signals | Any increase | Decrease | Potential over-sharpening or ringing; visual quality may worsen |

In the RIFE repository, typical high-quality results on Vimeo-90K approach **36 dB PSNR** and **0.96 SSIM**. If your custom training yields significantly lower values (e.g., < 30 dB PSNR or < 0.85 SSIM), investigate data loading, flow estimation accuracy, or alignment issues in the [`model/RIFE.py`](https://github.com/hzwer/eccv2022-rife/blob/main/model/RIFE.py) implementation.

## Running Your Own PSNR and SSIM Evaluations

The repository provides ready-to-use scripts for benchmarking custom models or datasets.

**Benchmarking on Vimeo-90K**

```bash
python benchmark/Vimeo90K.py \
    --model ./model_weights/RIFE_HD_v2.pth \
    --input_dir /path/to/vimeo90k/low_fps \
    --gt_dir /path/to/vimeo90k/high_fps

```

**Programmatic extraction of metrics**

Capture PSNR and SSIM values for automated testing:

```python
import subprocess
import re

def run_benchmark(model_path):
    out = subprocess.check_output([
        "python", "benchmark/UCF101.py",
        "--model", model_path,
        "--input_dir", "data/ucf_low",
        "--gt_dir", "data/ucf_high"
    ], text=True)
    return list(map(float, re.search(
        r"Avg PSNR: ([\d.]+) SSIM: ([\d.]+)", out
    ).groups()))

psnr_a, ssim_a = run_benchmark("model_weights/RIFE_HD.pth")
psnr_b, ssim_b = run_benchmark("model_weights/RIFE_HD_v2.pth")

print(f"RIFE_HD    → PSNR: {psnr_a:.2f}, SSIM: {ssim_a:.4f}")
print(f"RIFE_HD_v2 → PSNR: {psnr_b:.2f}, SSIM: {ssim_b:.4f}")

```

**Computing metrics on single frame pairs**

For debugging specific interpolation artifacts:

```python
import cv2
import numpy as np
from skimage.metrics import structural_similarity as compare_ssim

gt = cv2.imread("ground_truth.png")
pred = cv2.imread("interpolated.png")

mse = np.mean((gt.astype(np.float32) - pred.astype(np.float32)) ** 2)
psnr = 10 * np.log10(255.0 ** 2 / mse)

ssim, _ = compare_ssim(gt, pred, full=True, multichannel=True, data_range=255)

print(f"PSNR: {psnr:.2f} dB, SSIM: {ssim:.4f}")

```

## Summary

- **PSNR** measures pixel-wise reconstruction error in decibels; higher values (30+ dB) indicate less distortion, with 0.1–0.5 dB gains often perceptible.
- **SSIM** evaluates structural fidelity (edges, textures) on a 0–1 scale; values above 0.90 represent excellent quality, and 0.01+ improvements usually correlate with visible sharpness gains.
- The `hzwer/eccv2022-rife` repository computes these metrics in [`benchmark/Vimeo90K.py`](https://github.com/hzwer/eccv2022-rife/blob/main/benchmark/Vimeo90K.py), [`benchmark/UCF101.py`](https://github.com/hzwer/eccv2022-rife/blob/main/benchmark/UCF101.py), and [`benchmark/ATD12K.py`](https://github.com/hzwer/eccv2022-rife/blob/main/benchmark/ATD12K.py), averaging results across all interpolated frames.
- Always evaluate **both metrics together**; divergent signals (PSNR up, SSIM down) may indicate over-smoothing or ringing artifacts that degrade perceptual quality despite lower pixel error.

## Frequently Asked Questions

### What is a good PSNR value for frame interpolation?

For video frame interpolation using RIFE on standard benchmarks like Vimeo-90K, PSNR values around **35–37 dB** indicate high-quality results. Values below 30 dB typically suggest significant motion artifacts or alignment errors, while gains of 0.5 dB or more between model versions usually translate to perceptible visual improvements.

### Why does SSIM matter if PSNR is already high?

PSNR only measures pixel-wise intensity differences and can be misleading when artifacts affect structural elements like edges or textures. **SSIM specifically evaluates luminance, contrast, and structural correlation**, making it more aligned with human perception. A model might achieve high PSNR through aggressive smoothing that actually destroys fine details, which SSIM would reveal as a lower score.

### How do I run PSNR and SSIM benchmarks on my own video dataset?

Use the existing benchmark scripts as templates. Create a Python script that loads your ground-truth and input frames, calls [`inference_video.py`](https://github.com/hzwer/eccv2022-rife/blob/main/inference_video.py) to generate intermediates, then computes metrics using the formulas found in [`benchmark/Vimeo90K.py`](https://github.com/hzwer/eccv2022-rife/blob/main/benchmark/Vimeo90K.py):

```python
psnr = 10 * np.log10(255.0 ** 2 / np.mean((gt - pred) ** 2))
ssim = compare_ssim(gt, pred, multichannel=True, data_range=255)

```

Average these values across your test set to obtain final benchmark scores comparable to the official RIFE results.

### Can PSNR and SSIM improve while visual quality degrades?

Yes, this occurs when models optimize for pixel-wise accuracy at the expense of perceptual quality. For example, over-sharpening might increase PSNR slightly while introducing ringing artifacts that reduce SSIM. Conversely, excessive smoothing can raise PSNR by reducing noise but lower SSIM by blurring textures. Always verify that **both metrics trend upward** before concluding that a model iteration represents genuine quality improvement.