Nerfstudio

Nerfstudio es un marco modular y fácil de usar para investigadores para entrenar y renderizar Campos de radiancia neuronal (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 de NeRF y las aplicaciones de producción. Ejecútalo en la nube de GPU de Clore.ai para reconstruir escenas 3D a partir de tus propias fotos o videos.

---

¿Qué es Nerfstudio?

NeRF (Campo de Radiancia Neuronal) representa una escena 3D como una red neuronal que, dada una posición y una dirección de cámara, devuelve el color y la densidad en ese punto. Al entrenarse con decenas 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

• Compatibilidad con 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 nuevas vistas

---

Requisitos previos

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

El tiempo de entrenamiento escala con la complejidad de la escena. Una escena exterior típica de 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 en Marketplace y filtra por VRAM ≥ 16 GB.

3. Selecciona un servidor — la RTX 4090 es ideal para Nerfstudio.

4. Establece la imagen de Docker: dromni/nerfstudio:latest

5. Establece los puertos abiertos: 22 (SSH) y 7007 (visor web de Viser).

6. Haz clic en 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 por SSH

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

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

Verifica la instalación:

Configuración
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 (flujo de 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 los 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 obtener los mejores resultados, usa 100–300 fotos con un solapamiento significativo (>60% entre fotogramas adyacentes). Rodea el objeto/escena con un patrón sistemático: funcionan bien los círculos, las cuadrículas o los ochos.

---

Paso 4 — Entrena un NeRF

Entrenamiento básico con Nerfacto (recomendado)

Nerfacto es el método insignia de Nerfstudio, que equilibra 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

Abre tu navegador y navega a:

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

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

• Progreso de entrenamiento en vivo

• Calidad actual del renderizado NeRF

• Controles interactivos de cámara

• Curvas de pérdida de 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	La mejor opción general
instant-ngp	Rápido	Medio	6 GB	Entrenamiento más rápido
splatfacto	Rápido	Alta	8 GB	Splatting gaussiano
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 (splatting gaussiano)

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

---

Paso 6 — Evalúa y renderiza

Verificar métricas de entrenamiento

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

# Último punto de control
ls /home/user/outputs/my_scene/nerfacto/*/nerfstudio_models/

Renderiza un recorrido en video

# Interactivo: establece la ruta de la cámara en el visor y luego exporta
# Renderizado desde la 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 — Exporta 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 splats gaussianos (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áticos:

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

Mejores prácticas para capturar cámaras

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

Mejorando los resultados de COLMAP

# Para escenas difíciles, usa coincidencia exhaustiva (más lenta pero más precisa)
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 logra encontrar 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 la coincidencia exhaustiva: --matching-method exhaustive

• Reduce --num-frames-target para video para seleccionar mejores fotogramas

El visor no es 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 se haya ejecutado correctamente (busca transforms.json en el directorio de salida)

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

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

Sin memoria

# Reduce el tamaño del lote
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 est.	Escena de 100 imágenes
RTX 3080	10 GB	$0,05–0,19/h	~30–45 min
RTX 4090	24 GB	$0.14–0.42/h	~10–15 min
A100 40GB	40 GB	bare metal	~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 costo de cómputo significativo.

---

Recursos útiles

• GitHub de Nerfstudio

• Documentación de Nerfstudio

• Docker Hub de dromni/nerfstudio

• Comparación de métodos de Nerfstudio

• Documentación de COLMAP

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Producción	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Escenas a gran escala / de alta resolución	A100 80GB	bare metal

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