Nerf Compression Eval

---
name: nerf-compression-eval
description: This evaluation protocol measures the storage efficiency, rendering quality, and inference speed of compressed neural radiance field models. It probes how well a learned codebook preserves high-frequency visual details and accelerates real-time rendering compared to uncompressed baselines. Use when the user wants to benchmark on Synthetic-NeRF, LLFF, or asks about evaluating this task. Reports PSNR.
metadata:
  skill_kind: dataset_eval
  source_arxiv: 2305.18163
  bibtex_key: li2023compact
  confidence: high
---

# nerf-compression-eval

> Compact Real-time Radiance Fields with Neural Codebook — Lingzhi Li et al. (arXiv:2305.18163, 2023)

## What this evaluates

This evaluation protocol measures the storage efficiency, rendering quality, and inference speed of compressed neural radiance field models. It probes how well a learned codebook preserves high-frequency visual details and accelerates real-time rendering compared to uncompressed baselines.

## Datasets

- **Synthetic-NeRF** — total ?; splits: train (100), test (200)
- **LLFF** — total ?; splits: train (-1), test (-1)

## Metrics

- `PSNR` **(primary)** — range: other (dB)
  - 10 * log10(MAX_I^2 / MSE), where MSE is the mean squared error between rendered and ground truth images.
- `SSIM` — range: [0, 1]
  - Structural Similarity Index measuring luminance, contrast, and structure correlation between images.
- `LPIPS` — range: [0, 1]
  - Learned Perceptual Image Patch Similarity using deep feature distances to predict perceptual difference.

## Input / output format

**Input**: Training images with known camera poses (Synthetic-NeRF) or COLMAP-estimated poses (LLFF), plus scene geometry parameters for grid-based compression.

**Output**: Rendered images at held-out test viewpoints, compressed model files, and per-scene timing statistics for deployment and inference.

## Scoring recipe

```python
def evaluate(rendered, gt):
    mse = np.mean((rendered - gt) ** 2)
    psnr = 10 * np.log10(255**2 / mse)
    ssim = structural_similarity(rendered, gt, multichannel=True)
    lpips = compute_lpips(rendered, gt)
    return {'PSNR': psnr, 'SSIM': ssim, 'LPIPS': lpips}
```

## Common pitfalls

- Confusing one-time deployment/decompression overhead with per-frame inference time.
- Comparing storage sizes without normalizing for voxel grid resolution or feature channel dimensions.
- Evaluating on non-standard camera poses or resolutions that deviate from the 800x800 or forward-facing setup.

## Evidence (verbatim from paper)

> We compare NCB with other real-time inference methods on multiple metrics including rendering quality (PSNR), deployment time (in minutes), test time (inference cost given views in ms) and storage size, and list the performance of original NeRF for reference.

## Citation

```bibtex
@misc{li2023compact,
  title={Compact Real-time Radiance Fields with Neural Codebook},
  author={Lingzhi Li et al.},
  year={2023},
  note={arXiv:2305.18163}
}
```

- arXiv: 2305.18163