Radiance Field Acceleration Eval

radiance-field-acceleration-eval

Fast Learning Radiance Fields by Shooting Much Fewer Rays — Zhang et al. (2022) (arXiv:2208.06821, 2022)

What this evaluates

Evaluates the training efficiency and novel-view synthesis or reconstruction quality of neural radiance field methods by reducing the number of rays sampled during volume rendering. It measures how well adaptive ray allocation preserves rendering accuracy while accelerating convergence across diverse 3D scene benchmarks.

Datasets

• Realistic Synthetic 360° — total 8; splits: test (-1)
• Light Field (LF) — total 4; splits: test (-1)
• LLFF — total 8; splits: test (-1)
• Tanks and Temples (T&T) — total 9; splits: test (-1)
• Real-World 360° — total 9; splits: test (-1)
• DTU — total 15; splits: test (-1)

Metrics

• PSNR (primary) — range: [0, ∞) dB
  • Peak Signal-to-Noise Ratio computed as 10 * log10(MAX^2 / MSE) between rendered and ground truth images.
• SSIM — range: [0, 1]
  • Structural Similarity Index measuring perceived change in structural information between images.
• LPIPS — range: [0, 1]
  • Learned Perceptual Image Patch Similarity using deep features to measure perceptual difference.
• Chamfer Distance (CD) — range: [0, ∞) mm
  • Average nearest-neighbor distance between predicted and ground truth mesh point clouds.
• Training Time — range: seconds/hours
  • Wall-clock time required to complete the full training pipeline on a single GPU.

Input / output format

Input: Multi-view images (or single view for novel view synthesis) defining a 3D scene, along with camera poses and intrinsics for ray generation.

Output: Rendered novel-view images or reconstructed 3D meshes.

Scoring recipe

def evaluate(rendered_imgs, gt_imgs, meshes=None, gt_meshes=None, train_times=None):
    psnr_scores, ssim_scores, lpips_scores, cd_scores = [], [], [], []
    for r, g in zip(rendered_imgs, gt_imgs):
        psnr_scores.append(10 * np.log10(255**2 / np.mean((r - g)**2)))
        ssim_scores.append(ssim(r, g))
        lpips_scores.append(lpips_fn(r, g))
    if meshes and gt_meshes:
        for m, gm in zip(meshes, gt_meshes):
            cd_scores.append(chamfer_distance(m, gm))
    avg_time = np.mean(train_times) if train_times else None
    return {'PSNR': np.mean(psnr_scores), 'SSIM': np.mean(ssim_scores),
            'LPIPS': np.mean(lpips_scores), 'CD': np.mean(cd_scores) if cd_scores else None,
            'Training Time': avg_time}

Common pitfalls

• Training times are hardware-dependent and only reported on a single NVIDIA 3090Ti GPU, making cross-hardware comparisons invalid.
• Light Field (LF) dataset splits vary across literature, so results cannot be directly compared to other papers.
• Marginal PSNR/SSIM improvements may not reflect perceptual quality differences, which are better captured by LPIPS or visual inspection.

Evidence (verbatim from paper)

The rendering accuracy is evaluated by PSNR, SSIM and LPIPS, which have been widely adopted by most radiance fields based methods (e.g.[[13]]). Additionally, for DTU dataset, We use Chamfer Distance (CD)[[63]] to evaluate the quality of reconstructed meshes. All of the training time of experiments is counted on a single NVIDIA 3090Ti GPU.

Citation

@misc{zhang2022fastlearning,
  title={Fast Learning Radiance Fields by Shooting Much Fewer Rays},
  author={Zhang et al. (2022)},
  year={2022},
  note={arXiv:2208.06821}
}

• arXiv: 2208.06821