Novel View Synthesis Eval

---
name: novel-view-synthesis-eval
description: Evaluates a model's ability to synthesize novel views of 3D scenes from a small set of input images using Gaussian splatting representations. It measures rendering quality, representation efficiency, and cross-dataset generalization. Use when the user wants to benchmark on RealEstate10K, ACID, or asks about evaluating this task. Reports PSNR.
metadata:
  skill_kind: dataset_eval
  source_arxiv: 2503.16338
  bibtex_key: zhang2025gaussiangraphnetwork
  confidence: high
---

# novel-view-synthesis-eval

> Gaussian Graph Network: Learning Efficient and Generalizable Gaussian Representations from Multi-view Images — Zhang et al. (arXiv:2503.16338, 2025)

## What this evaluates

Evaluates a model's ability to synthesize novel views of 3D scenes from a small set of input images using Gaussian splatting representations. It measures rendering quality, representation efficiency, and cross-dataset generalization.

## Datasets

- **RealEstate10K** — total 74766; splits: train (67477), test (7289)
- **ACID** — total 13047; splits: train (11075), test (1972)

## Metrics

- `PSNR` **(primary)** — range: dB
  - Peak Signal-to-Noise Ratio, calculated as 10 * log10(MAX^2 / MSE) in decibels (dB). Higher is better.
- `SSIM` — range: [0, 1]
  - Structural Similarity Index, measures perceived change in structural information between reference and distorted images. Range [0, 1]. Higher is better.
- `LPIPS` — range: [0, 1]
  - Learned Perceptual Image Patch Similarity, computes L2 distance between deep features of reference and distorted images. Range [0, 1]. Lower is better.

## Input / output format

**Input**: Multi-view reference images (2, 4, 8, or 16 views) at 256×256 resolution.

**Output**: Rendered novel view images (3 target views per scene).

## Scoring recipe

```python
def compute_metrics(pred, gt):
    mse = torch.mean((pred - gt) ** 2)
    psnr = 10 * torch.log10(1.0 / mse)
    ssim = compute_ssim(pred, gt)  # standard structural similarity
    lpips = compute_lpips(pred, gt)  # perceptual similarity
    return psnr.item(), ssim.item(), lpips.item()
```

## Common pitfalls

- Comparing FPS directly without accounting for the number of Gaussians or input views, as rendering speed scales with scene complexity.
- Overlooking the † evaluation setting where baselines are constrained to render from only two input views despite receiving more, which artificially boosts their metrics.
- Treating LPIPS as a similarity score where higher is better, whereas lower LPIPS indicates better perceptual quality.

## Evidence (verbatim from paper)

> For 4 view inputs, our method outperforms MVSplat by about 4dB on PSNR with more than 2× fewer Gaussians.

## Citation

```bibtex
@misc{zhang2025gaussiangraphnetwork,
  title={Gaussian Graph Network: Learning Efficient and Generalizable Gaussian Representations from Multi-view Images},
  author={Zhang et al.},
  year={2025},
  note={arXiv:2503.16338}
}
```

- arXiv: 2503.16338