nerfacc

https://www.nerfacc.com/

[News] 2023/04/04. Se você estava usando nerfacc <= 0.3.5 e gostaria de migrar para a nossa versão mais recente ( nerfacc >= 0.5.0 ), verifique o Changelog sobre como migrar.

O NERFACC é uma caixa de ferramentas de aceleração do Pytorch Nerf para treinamento e inferência. Ele se concentra na amostragem eficiente no pipeline de renderização volumétrica dos campos de radiação, que é universal e plug-and-play para a maioria dos nerfs. Com modificações mínimas nas bases de código existentes, o Nerfacc fornece acelerações significativas no treinamento de vários trabalhos NERF recentes. E é uma interface python pura com APIs flexíveis!

Instalação

Dependência : Instale o Pytorch primeiro.

A maneira easista é instalar a partir do Pypi. Dessa forma, ele criará o código CUDA na primeira execução (JIT).

 pip install nerfacc

Ou instale da fonte. Dessa forma, ele criará o código CUDA durante a instalação.

 pip install git+https://github.com/nerfstudio-project/nerfacc.git

Também fornecemos rodas pré-construídas, cobrindo as principais combinações de Pytorch + Cuda apoiadas pela Pytorch oficial.

 # e.g., torch 1.13.0 + cu117
pip install nerfacc -f https://nerfacc-bucket.s3.us-west-2.amazonaws.com/whl/torch-1.13.0_cu117.html

Windows & Linux	cu113	cu115	cu116	cu117	cu118
Tocha 1.11.0	✅	✅
tocha 1.12.0	✅		✅
Tocha 1.13.0			✅	✅
Torch 2.0.0				✅	✅

Para uma versão anterior do Nerfacc, verifique aqui as rodas pré-construídas suportadas.

Uso

A idéia do Nerfacc é executar amostragem volumétrica eficiente com um estimador computacionalmente barato para descobrir superfícies. Portanto, o NERFACC pode funcionar com qualquer campo de radiação definido pelo usuário. Para conectar o pipeline de renderização do Nerfacc ao seu código e aproveitar a aceleração, você só precisa definir duas funções com seu campo de radiência.

• sigma_fn : Calcule a densidade em cada amostra. Será usado pelo estimador (por exemplo, nerfacc.OccGridEstimator , nerfacc.PropNetEstimator ) para descobrir superfícies.
• rgb_sigma_fn : Calcule a cor e a densidade em cada amostra. Será usado pelo nerfacc.rendering para render a renderização volumétrica diferenciável. Esta função receberá gradientes para atualizar seu campo de brilho.

Um exemplo simples é assim:

 import torch
from torch import Tensor
import nerfacc 

radiance_field = ...  # network: a NeRF model
rays_o : Tensor = ...  # ray origins. (n_rays, 3)
rays_d : Tensor = ...  # ray normalized directions. (n_rays, 3)
optimizer = ...       # optimizer

estimator = nerfacc . OccGridEstimator (...)

def sigma_fn (
    t_starts : Tensor , t_ends : Tensor , ray_indices : Tensor
) -> Tensor :
    """ Define how to query density for the estimator."""
    t_origins = rays_o [ ray_indices ]  # (n_samples, 3)
    t_dirs = rays_d [ ray_indices ]  # (n_samples, 3)
    positions = t_origins + t_dirs * ( t_starts + t_ends )[:, None ] / 2.0
    sigmas = radiance_field . query_density ( positions ) 
    return sigmas  # (n_samples,)

def rgb_sigma_fn (
    t_starts : Tensor , t_ends : Tensor , ray_indices : Tensor
) -> Tuple [ Tensor , Tensor ]:
    """ Query rgb and density values from a user-defined radiance field. """
    t_origins = rays_o [ ray_indices ]  # (n_samples, 3)
    t_dirs = rays_d [ ray_indices ]  # (n_samples, 3)
    positions = t_origins + t_dirs * ( t_starts + t_ends )[:, None ] / 2.0
    rgbs , sigmas = radiance_field ( positions , condition = t_dirs )  
    return rgbs , sigmas  # (n_samples, 3), (n_samples,)

# Efficient Raymarching:
# ray_indices: (n_samples,). t_starts: (n_samples,). t_ends: (n_samples,).
ray_indices , t_starts , t_ends = estimator . sampling (
    rays_o , rays_d , sigma_fn = sigma_fn , near_plane = 0.2 , far_plane = 1.0 , early_stop_eps = 1e-4 , alpha_thre = 1e-2 , 
)

# Differentiable Volumetric Rendering.
# colors: (n_rays, 3). opacity: (n_rays, 1). depth: (n_rays, 1).
color , opacity , depth , extras = nerfacc . rendering (
    t_starts , t_ends , ray_indices , n_rays = rays_o . shape [ 0 ], rgb_sigma_fn = rgb_sigma_fn
)

# Optimize: Both the network and rays will receive gradients
optimizer . zero_grad ()
loss = F . mse_loss ( color , color_gt )
loss . backward ()
optimizer . step ()

Exemplos:

Antes de executar esses scripts de exemplo, verifique o script sobre qual conjunto de dados é necessário e faça o download do conjunto de dados primeiro. Você pode usar --data_root para especificar o caminho.

 # clone the repo with submodules.
git clone --recursive git://github.com/nerfstudio-project/nerfacc/

Nerfs estáticos

Veja o benchmarking completo aqui: https://www.nerfacc.com/en/stable/examples/static.html

Instant-NGP no conjunto de dados NERF-Syntetic com melhor desempenho em 4,5 minutos.

 # Occupancy Grid Estimator
python examples/train_ngp_nerf_occ.py --scene lego --data_root data/nerf_synthetic
# Proposal Net Estimator
python examples/train_ngp_nerf_prop.py --scene lego --data_root data/nerf_synthetic

Instant-NGP no conjunto de dados MIP-ERF 360 com melhor desempenho em 5 minutos.

 # Occupancy Grid Estimator
python examples/train_ngp_nerf_occ.py --scene garden --data_root data/360_v2
# Proposal Net Estimator
python examples/train_ngp_nerf_prop.py --scene garden --data_root data/360_v2

Vanilla MLP Nerf no conjunto de dados NERF-Syntetic em uma hora.

 # Occupancy Grid Estimator
python examples/train_mlp_nerf.py --scene lego --data_root data/nerf_synthetic

Conjuntos de dados Tensorf em Tanks & Temple e Nerf-sintéticos (plug-in na base de código oficial).

 cd benchmarks/tensorf/
# (set up the environment for that repo)
bash script.sh nerfsyn-nerfacc-occgrid 0
bash script.sh tt-nerfacc-occgrid 0

Nerfs dinâmicos

Veja o benchmarking completo aqui: https://www.nerfacc.com/en/stable/examples/dynamic.html

T-nerf no conjunto de dados D-ERF em uma hora.

 # Occupancy Grid Estimator
python examples/train_mlp_tnerf.py --scene lego --data_root data/dnerf

Planos K no conjunto de dados D-ERF (plug-in na base de código oficial).

 cd benchmarks/kplanes/
# (set up the environment for that repo)
bash script.sh dnerf-nerfacc-occgrid 0

Tineuvox nos conjuntos de dados Hypernerf e D-Enerf (plug-in na base de código oficial).

 cd benchmarks/tineuvox/
# (set up the environment for that repo)
bash script.sh dnerf-nerfacc-occgrid 0
bash script.sh hypernerf-nerfacc-occgrid 0
bash script.sh hypernerf-nerfacc-propnet 0

Nerfs de otimização da câmera

Veja o benchmarking completo aqui: https://www.nerfacc.com/en/stable/examples/camera.html

Barf no conjunto de dados NERF-Syntetic (plug-in na base de código oficial).

 cd benchmarks/barf/
# (set up the environment for that repo)
bash script.sh nerfsyn-nerfacc-occgrid 0

Usos de terceiros:

Bases de código impressionantes.

• Nerfstudio: Um estúdio para colaboração para Nerfs.
• SDFSTUDIO: Uma estrutura unificada para a reconstrução da superfície.
• THREESTUDIO: Uma estrutura unificada para a criação de conteúdo 3D.
• Instant-NSR-PL: NEUS em 10 minutos.
• ModelCope: uma coleção de algoritmos de aprendizado profundo.

Papéis incríveis.

• Representando vídeos volumétricos como mapas dinâmicos de MLP, CVPR 2023
• NERSEMBLE: Reconstrução de Campo de Radiaço de View Multi-View de Cabeças Humanas, ARXIV 2023
• HumanRF: Campos de Radiance Neural de alta fidelidade para humanos em movimento, Arxiv 2023

Problemas comuns de instalação

Importror: .../csrc.so: símbolo indefinido

Se você estiver instalando uma roda pré-construída, verifique se a versão Pytorch e Cuda corresponde à versão Nerfacc (Nerfacc .__ versão__).

Citação

 @article { li2023nerfacc ,
  title = { NerfAcc: Efficient Sampling Accelerates NeRFs. } ,
  author = { Li, Ruilong and Gao, Hang and Tancik, Matthew and Kanazawa, Angjoo } ,
  journal = { arXiv preprint arXiv:2305.04966 } ,
  year = { 2023 }
}