Nerfstudio

Nerfstudio es un marco modular y amigable para investigadores para entrenar y renderizar Campos de Radiancia Neurales (NeRF) — una técnica que reconstruye escenas 3D fotorrealistas a partir de imágenes 2D. Con más de 10.000 estrellas en GitHub, es el estándar de facto para la investigación y aplicaciones de producción de NeRF. Ejecútalo en la nube GPU de Clore.ai para reconstruir escenas 3D a partir de tus propias fotos o videos.

---

¿Qué es Nerfstudio?

NeRF (Campo de Radiancia Neural) representa una escena 3D como una red neuronal que, dada una posición y dirección de cámara, devuelve el color y la densidad en ese punto. Al entrenar con docenas de fotografías tomadas desde diferentes ángulos, NeRF aprende una representación 3D completa que puede renderizarse desde cualquier punto de vista.

Nerfstudio proporciona:

• Múltiples métodos NeRF: Nerfacto, Instant-NGP, Splatfacto, TensoRF y más

• CLI y API de Python

• Visor web interactivo (Viser) en el puerto 7007

• Exportación a nubes de puntos, mallas y recorridos en video

• Soporte para conjuntos de datos personalizados mediante integración con COLMAP

Casos de uso:

• Reconstrucción de escenas 3D a partir de imágenes de drones

• Visualización de productos a partir de fotos

• Recorridos virtuales a partir de capturas con smartphone

• Investigación en síntesis de vistas novedosas

---

Prerrequisitos

Requisito	Mínimo	Recomendado
VRAM GPU	8 GB	16–24 GB
GPU	RTX 3080	RTX 4090 / A100
RAM	16 GB	32 GB
Almacenamiento	20 GB	50+ GB
CUDA	11.8+	12.1+

El tiempo de entrenamiento escala con la complejidad de la escena. Una escena exterior típica con 100 fotos se entrena en 10–30 minutos en una RTX 4090. El visor interactivo se actualiza en tiempo real durante el entrenamiento.

---

Paso 1 — Alquila una GPU en Clore.ai

1. Inicia sesión en clore.ai.

2. Haz clic Marketplace y filtra por VRAM ≥ 16 GB.

3. Selecciona un servidor: RTX 4090 es ideal para Nerfstudio.

4. Establecer imagen Docker: dromni/nerfstudio:latest

5. Establecer puertos abiertos: 22 (SSH) y 7007 (visor web Viser).

6. Haz clic Alquilar y espera a que la instancia se inicialice.

El dromni/nerfstudio la imagen es la imagen oficial mantenida por la comunidad e incluye todas las dependencias preinstaladas (CUDA, tiny-cuda-nn, colmap, ffmpeg).

---

Paso 2 — Conéctate vía SSH

ssh user@<clore-host> -p <assigned-ssh-port>

El dromni/nerfstudio la imagen utiliza usuario (no root) por defecto. Usa sudo para tareas administrativas.

Verifica la instalación:

ns-train --help
ns-render --help
ns-viewer --help

---

Paso 3 — Prepara tu conjunto de datos

Opción A: Usa el conjunto de datos de ejemplo proporcionado

Nerfstudio incluye conjuntos de datos integrados para probar de inmediato:

# Descarga el conjunto de datos poster (pequeño, ideal para pruebas)
ns-download-data nerfstudio --capture-name=poster

# Otros conjuntos de datos disponibles:
# ns-download-data nerfstudio --capture-name=egypt
# ns-download-data nerfstudio --capture-name=floating-tree
# ns-download-data nerfstudio --capture-name=stump

Opción B: Procesa tus propias imágenes

Si tienes fotos o video de tu escena:

A partir de imágenes (pipeline COLMAP):

# Sube tus imágenes vía SCP
scp -P <port> -r ./my_photos/ user@<clore-host>:/home/user/data/

# Procesa con COLMAP para obtener las poses de cámara
ns-process-data images \
    --data /home/user/data/my_photos \
    --output-dir /home/user/data/my_scene

A partir de video:

# Sube el video
scp -P <port> my_video.mp4 user@<clore-host>:/home/user/data/

# Extrae fotogramas y procesa
ns-process-data video \
    --data /home/user/data/my_video.mp4 \
    --output-dir /home/user/data/my_scene \
    --num-frames-target 200

Para mejores resultados, usa 100–300 fotos con solapamiento significativo (>60% entre fotogramas adyacentes). Camina alrededor del objeto/escena en un patrón sistemático: círculos, cuadrículas o ochos funcionan bien.

---

Paso 4 — Entrena un NeRF

Entrenamiento básico con Nerfacto (Recomendado)

Nerfacto es el método insignia de Nerfstudio, equilibrando calidad y velocidad:

ns-train nerfacto \
    --data /home/user/data/my_scene \
    --viewer.websocket-port 7007 \
    --output-dir /home/user/outputs

Entrenamiento con Instant-NGP (El más rápido)

ns-train instant-ngp \
    --data /home/user/data/my_scene \
    --viewer.websocket-port 7007 \
    --output-dir /home/user/outputs

Entrenamiento con el conjunto de datos poster proporcionado

ns-train nerfacto \
    --data /home/user/data/nerfstudio/poster \
    --viewer.websocket-port 7007

---

Paso 5 — Accede al visor interactivo

Abra su navegador y navegue a:

http://<clore-host>:<public-port-7007>

Verás un visor 3D impulsado por Viser que muestra:

• Progreso de entrenamiento en vivo

• Calidad de renderizado NeRF actual

• Controles de cámara interactivos

• Curvas de pérdida del entrenamiento

El visor se actualiza cada pocos segundos durante el entrenamiento. Puedes rotar, desplazar y hacer zoom para inspeccionar la calidad de la escena a medida que avanza el entrenamiento.

---

Métodos de entrenamiento disponibles

Método	Velocidad	Calidad	VRAM	Notas
nerfacto	Medio	Alta	8 GB	Mejor en general
instant-ngp	Rápido	Medio	6 GB	Entrenamiento más rápido
splatfacto	Rápido	Alta	8 GB	Gaussian splatting
tensorf	Medio	Alta	12 GB	Bueno para objetos
mipnerf360	Lento	Muy alto	24 GB	Mejor calidad
vanilla-nerf	Muy lento	Alta	16 GB	Línea base de investigación

Entrenamiento con Splatfacto (Gaussian Splatting)

ns-train splatfacto \
    --data /home/user/data/my_scene \
    --viewer.websocket-port 7007 \
    --pipeline.model.num-random 50000

---

Paso 6 — Evaluar y renderizar

Revisa las métricas de entrenamiento

# Ver el resumen de entrenamiento
ls /home/user/outputs/my_scene/nerfacto/

# Último checkpoint
ls /home/user/outputs/my_scene/nerfacto/*/nerfstudio_models/

Renderizar un recorrido en video

# Interactivo: configura la trayectoria de la cámara en el visor y luego exporta
# Renderizado por línea de comandos:

ns-render camera-path \
    --load-config /home/user/outputs/my_scene/nerfacto/<timestamp>/config.yml \
    --camera-path-filename /home/user/data/my_scene/camera_paths/my_path.json \
    --output-path /home/user/renders/output.mp4

Renderizar espiral interpolada

ns-render interpolate \
    --load-config /home/user/outputs/my_scene/nerfacto/<timestamp>/config.yml \
    --output-path /home/user/renders/spiral.mp4 \
    --render-nearest-camera True \
    --order-poses True

---

Paso 7 — Exportar geometría 3D

Exportar nube de puntos

ns-export pointcloud \
    --load-config /home/user/outputs/my_scene/nerfacto/<timestamp>/config.yml \
    --output-dir /home/user/exports/ \
    --num-points 1000000

Exportar malla

ns-export marching-cubes \
    --load-config /home/user/outputs/my_scene/nerfacto/<timestamp>/config.yml \
    --output-dir /home/user/exports/ \
    --resolution 1024

Exportar Gaussian Splats (PLY)

ns-export gaussian-splat \
    --load-config /home/user/outputs/my_scene/splatfacto/<timestamp>/config.yml \
    --output-dir /home/user/exports/

---

API de Python

Para entrenamiento y evaluación programática:

from nerfstudio.scripts.train import main
from nerfstudio.configs.base_config import ViewerConfig
from nerfstudio.engine.trainer import TrainerConfig

# Ejemplo de entrenamiento con la API de Python
from nerfstudio.configs.method_configs import method_configs
from pathlib import Path

config = method_configs["nerfacto"]
config.pipeline.datamanager.data = Path("/home/user/data/my_scene")
config.viewer = ViewerConfig(websocket_port=7007, num_rays_per_chunk=1<<15)
config.max_num_iterations = 30000

trainer = config.setup()
trainer.train()

---

Consejos para conjuntos de datos personalizados

Buenas prácticas de captura con la cámara

Ajuste	Recomendación
Solapamiento	≥ 60% entre fotogramas
Imágenes	100–300 (exteriores), 50–150 (objetos)
Movimiento	Movimiento lento y constante
Iluminación	Consistente, evita sombras duras
Enfoque	Nítido en todo momento

Mejorando los resultados de COLMAP

# Para escenas difíciles, usa matching exhaustivo (más lento pero más preciso)
ns-process-data images \
    --data /home/user/data/my_photos \
    --output-dir /home/user/data/my_scene \
    --sfm-tool colmap \
    --matching-method exhaustive

---

Solución de problemas

COLMAP no encuentra las poses de cámara

Soluciones:

• Asegúrate de que las imágenes tengan suficiente solapamiento

• Verifica que las imágenes estén nítidas (sin desenfoque por movimiento)

• Prueba el matching exhaustivo: --matching-method exhaustive

• Reducir --num-frames-target para video, para seleccionar mejores fotogramas

Visor no accesible

Solución: Asegúrate de que el puerto 7007 esté reenviado en Clore.ai. Prueba la conectividad:

ss -tlnp | grep 7007

La pérdida de entrenamiento no disminuye

Soluciones:

• Comprueba que COLMAP tuvo éxito (busca transforms.json en el directorio de salida)

• Reduce la tasa de aprendizaje: --pipeline.model.field-implementation hash

• Comprueba si hay cielo dominante (usa --pipeline.model.background-color white)

Falta de memoria

# Reduce el tamaño del batch
ns-train nerfacto \
    --data /home/user/data/my_scene \
    --pipeline.datamanager.train-num-rays-per-batch 2048 \
    --pipeline.datamanager.eval-num-rays-per-batch 1024

---

Descargar salidas

Después del entrenamiento, descarga tus renders y exportaciones:

# Desde tu máquina local
scp -P <port> -r user@<clore-host>:/home/user/renders/ ./local-renders/
scp -P <port> -r user@<clore-host>:/home/user/exports/ ./local-exports/

---

Estimación de Costos

GPU	VRAM	Precio estimado	Escena de 100 imágenes
RTX 3080	10 GB	~$0.10/hr	~30–45 min
RTX 4090	24 GB	~$0.35/hr	~10–15 min
A100 40GB	40 GB	~$0.80/hr	~5–8 min

Comienza con Instant-NGP para vistas previas rápidas, luego cambia a Nerfacto o MipNeRF360 para la calidad final. Este flujo de trabajo ahorra un coste computacional significativo.

---

Recursos Útiles

• Nerfstudio en GitHub

• Documentación de Nerfstudio

• dromni/nerfstudio en Docker Hub

• Comparación de métodos de Nerfstudio

• Documentación de COLMAP

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
Producción	RTX 4090 (24GB)	~$0.70/gpu/hr
Escenas a gran escala / alta resolución	A100 80GB	~$1.20/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.