Splatting gaussiano 3D

Splatting gaussiano 3D es una técnica revolucionaria de reconstrucción de escenas 3D en tiempo real con más de 15.000 estrellas en GitHub. A diferencia de los métodos basados en NeRF, Gaussian Splatting representa las escenas como millones de pequeños gaussianos 3D que pueden renderizarse a frecuencias de cuadro en tiempo real (100+ FPS) mientras logra una calidad fotorrealista. Despliégalo en la nube GPU de Clore.ai para reconstruir y explorar escenas 3D a partir de tus propias fotos.

¿Qué es 3D Gaussian Splatting?

Los métodos tradicionales de NeRF codifican implícitamente una escena en una red neuronal, requiriendo ray marching por píxel en tiempo de renderizado. Gaussian Splatting adopta un enfoque fundamentalmente diferente:

Inicialización: Comienza a partir de una nube de puntos dispersa (de COLMAP)
Representación: Expande cada punto en un gaussiano 3D con posición, escala, rotación, opacidad y color de armónicos esféricos
Optimización: Renderiza gaussianos de forma diferenciable y optimiza contra las imágenes de entrenamiento
Renderizado: Proyecta los gaussianos sobre el plano de la imagen mediante composición alfa (extremadamente rápido)

Ventajas clave frente a NeRF:

Renderizado en tiempo real (100+ FPS a 1080p)
Mejor reconstrucción de detalles finos
Representación 3D explícita (editable, exportable)
Entrenamiento más rápido (30–60 min vs horas)
Funciona en GPUs de consumo

Requisitos previos

Requisito

Mínimo

Recomendado

VRAM de GPU

12 GB

24 GB

GPU

RTX 3080 12GB

RTX 4090 / A100

RAM

16 GB

32 GB

Almacenamiento

30 GB

60 GB

CUDA

12.8+

Gaussian Splatting tiene requisitos estrictos de CUDA. La versión de CUDA debe coincidir con la extensión compilada diff-gaussian-rasterization . Usar el Dockerfile proporcionado elimina problemas de compatibilidad.

Paso 1 — Alquila una GPU en Clore.ai

Inicia sesión en clore.ai.
Haz clic en Marketplace y filtra por VRAM ≥ 16 GB.
Selecciona un servidor — la RTX 4090 ofrece la mejor relación precio/rendimiento.
Configura la imagen Docker en tu imagen personalizada (ver Paso 2).
Establece los puertos abiertos: 22 (SSH) y 8080 (visor web).
Haz clic en Alquilar.

Paso 2 — Dockerfile

Compila una imagen Docker personalizada con todas las dependencias:

FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

ENV DEBIAN_FRONTEND=noninteractive
ENV TORCH_CUDA_ARCH_LIST="6.0;6.1;7.0;7.5;8.0;8.6;8.9;9.0+PTX"

RUN apt-get update && apt-get install -y \\
    git wget curl cmake build-essential \\
    libboost-program-options-dev libboost-filesystem-dev \\
    libboost-graph-dev libboost-system-dev libboost-test-dev \\
    libeigen3-dev libflann-dev libfreeimage-dev \\
    libmetis-dev libgoogle-glog-dev libgflags-dev \\
    libsqlite3-dev libglew-dev qtbase5-dev libqt5opengl5-dev \\
    libcgal-dev libceres-dev \\
    ffmpeg libgl1 libglib2.0-0 \\
    openssh-server \\
    python3-pip python3-dev \\
    && rm -rf /var/lib/apt/lists/*

# Instalar COLMAP
RUN apt-get update && apt-get install -y colmap && rm -rf /var/lib/apt/lists/*

# Configurar SSH
RUN mkdir /var/run/sshd && \\
    echo 'root:clore123' | chpasswd && \\
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

WORKDIR /workspace

# Clonar el repositorio original de 3DGS
RUN git clone https://github.com/graphdeco-inria/gaussian-splatting /workspace/gaussian-splatting \\
    --recursive

# Instalar dependencias de Python
RUN cd /workspace/gaussian-splatting && \\
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128 && \\
    pip install -r requirements.txt

# Compilar extensiones CUDA
RUN cd /workspace/gaussian-splatting && \\
    pip install submodules/diff-gaussian-rasterization && \\
    pip install submodules/simple-knn

# Instalar dependencias del visor web
RUN pip install viser==0.1.29 nerfview==0.0.4 trimesh

EXPOSE 22 8080

CMD service ssh start && tail -f /dev/null

Compilar y publicar

Compila la imagen y súbela a tu propia cuenta de Docker Hub (reemplaza YOUR_DOCKERHUB_USERNAME con tu nombre de usuario real):

docker build -t YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest .
docker push YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest

No existe una imagen Docker oficial precompilada para 3D Gaussian Splatting en Docker Hub. El repositorio oficial en graphdeco-inria/gaussian-splatting no proporciona una; compílala a partir del Dockerfile anterior. La imagen debe compilarse con los indicadores correctos de arquitectura CUDA que coincidan con tu GPU objetivo.

Usa YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest en tu configuración de Clore.ai.

Paso 3 — Conéctate por SSH

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

Verifica la compilación:

cd /workspace/gaussian-splatting
python -c "from diff_gaussian_rasterization import GaussianRasterizationSettings; print('Extensión CUDA OK')"

Paso 4 — Prepara tu conjunto de datos

Opción A: usar el conjunto de datos Tandt (Tanks and Temples)

Conjunto de datos clásico de referencia para pruebas rápidas:

mkdir -p /workspace/data && cd /workspace/data

# Descargar escena pequeña de prueba
wget https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/datasets/input/tandt.zip
unzip tandt.zip

Opción B: procesa tus propias fotos

# Subir fotos
scp -P <port> -r ./my_photos/ root@<clore-host>:/workspace/data/

# Ejecutar el script de procesamiento de COLMAP (incluido con 3DGS)
cd /workspace/gaussian-splatting

python convert.py \\
    -s /workspace/data/my_photos \\
    --no_gpu   # opcional: si el solucionador GPU de COLMAP entra en conflicto

El convert.py el script ejecuta la canalización completa de COLMAP: extracción de características, emparejamiento, reconstrucción dispersa y desdistorsión. Esto tarda de 5 a 30 minutos según la cantidad de imágenes.

Opción C: procesar desde video

# Extraer fotogramas del video a 2fps
ffmpeg -i /workspace/data/my_video.mp4 \\
    -vf fps=2 \\
    /workspace/data/frames/frame_%04d.jpg

# Luego ejecutar el procesamiento de COLMAP sobre los fotogramas
python convert.py -s /workspace/data/frames

Paso 5 — Entrenar un splat gaussiano

Entrenamiento estándar

cd /workspace/gaussian-splatting

python train.py \\
    -s /workspace/data/my_photos \\
    -m /workspace/output/my_scene \\
    --iterations 30000 \\
    --eval

Entrenamiento en el conjunto de datos Tandt

python train.py \\
    -s /workspace/data/tandt/truck \\
    -m /workspace/output/truck \\
    --iterations 30000 \\
    --eval

Entrenamiento rápido (vista previa rápida)

python train.py \\
    -s /workspace/data/my_photos \\
    -m /workspace/output/my_scene_fast \\
    --iterations 7000

Entrenar hasta 7.000 iteraciones tarda ~10 minutos en una RTX 4090 y ofrece una vista previa de buena calidad. Las 30.000 iteraciones completas tardan ~30–40 minutos y producen la calidad final.

Progreso del entrenamiento

Monitorea la salida del entrenamiento — verás métricas como:

[ITER 1000] Evaluando train: L1 0.04, PSNR 26.12 dB
[ITER 7000] Evaluando train: L1 0.02, PSNR 29.45 dB
[ITER 30000] Evaluando train: L1 0.01, PSNR 32.80 dB

Un PSNR superior a 30 dB indica una reconstrucción de alta calidad.

Paso 6 — Renderizar y visualizar

Renderizar desde el modelo entrenado

python render.py \\
    -m /workspace/output/my_scene \\
    --skip_train

Los renders se guardan en /workspace/output/my_scene/test/ours_30000/renders/.

Crear un video de vuelo

# Convertir fotogramas renderizados a video
ffmpeg -framerate 24 \\
    -pattern_type glob \\
    -i '/workspace/output/my_scene/test/ours_30000/renders/*.png' \\
    -c:v libx264 \\
    -pix_fmt yuv420p \\
    /workspace/output/flythrough.mp4

Evaluar métricas

python metrics.py -m /workspace/output/my_scene

Salida esperada:

SSIM : 0.8324
PSNR : 32.81
LPIPS: 0.1893

Paso 7 — Visor web interactivo

Para explorar la escena entrenada de forma interactiva:

Usando nerfview/viser

# /workspace/view_splat.py
import viser
import numpy as np
from plyfile import PlyData
import torch

server = viser.ViserServer(host="0.0.0.0", port=8080)
print("Visor ejecutándose en http://0.0.0.0:8080")

# Cargar archivo PLY
ply_path = "/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply"
plydata = PlyData.read(ply_path)

xyz = np.stack([
    plydata['vertex']['x'],
    plydata['vertex']['y'],
    plydata['vertex']['z'],
], axis=-1)

# Añadir nube de puntos al visor
server.add_point_cloud(
    name="/splat",
    points=xyz,
    colors=np.ones((len(xyz), 3)) * 0.7,
    point_size=0.003,
)

import time
while True:
    time.sleep(0.01)

python /workspace/view_splat.py &

Luego abre: http://<clore-host>:<public-port-8080>

Alternativa: usar SuperSplat (visor basado en navegador)

Descarga el .ply archivo y ábrelo en SuperSplat:

# Descargar desde tu máquina local
scp -P <port> root@<clore-host>:/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply ./

Luego arrastra y suelta el .ply en el navegador de SuperSplat en: https://playcanvas.com/super-splat

Opciones avanzadas

Controlar el número de gaussianos

# Mayor densificación para escenas más detalladas
python train.py \\
    -s /workspace/data/my_photos \\
    -m /workspace/output/my_scene \\
    --densify_until_iter 15000 \\
    --densify_grad_threshold 0.0002

Fondo blanco (para objetos)

python train.py \\
    -s /workspace/data/my_object \\
    -m /workspace/output/my_object \\
    --white_background

Escenas de gran escala

# Aumentar el intervalo de reinicio de opacidad para escenas al aire libre
python train.py \\
    -s /workspace/data/outdoor \\
    -m /workspace/output/outdoor \\
    --opacity_reset_interval 5000 \\
    --iterations 50000

Alternativa: Gaussian Splatting con gsplat

gsplat es una implementación más rápida y eficiente en memoria:

pip install gsplat

# Entrenamiento con gsplat
python examples/simple_trainer.py \\
    --data_dir /workspace/data/my_photos \\
    --result_dir /workspace/gsplat_output

Solución de problemas

Error al compilar la extensión CUDA

error: no kernel image is available for execution on the device

Solución: Reconstrúyelo para la arquitectura específica de tu GPU:

export TORCH_CUDA_ARCH_LIST="8.6"  # Para RTX 3090/4090
cd /workspace/gaussian-splatting
pip install submodules/diff-gaussian-rasterization --force-reinstall

COLMAP no logra reconstruir

Soluciones:

Asegura ≥ 50% de solapamiento de imágenes
Usa más fotos (se recomiendan 100+)
Prueba el emparejamiento secuencial para fotogramas de video: añade --match sequential a convert.py

Memoria insuficiente durante el entrenamiento

# Reducir el número máximo de gaussianos
python train.py \\
    -s /workspace/data/my_photos \\
    -m /workspace/output/my_scene \\
    --max_num_splats 2000000  # el valor predeterminado es ~6M

Objetos flotantes en la escena

Artefactos flotantes de la inicialización gaussiana:

Aumenta --densify_grad_threshold para ser más selectivo
Usa --prune_opacity_threshold 0.005 para eliminar antes los gaussianos de baja opacidad

Recomendaciones de GPU para Clore.ai

El entrenamiento de Gaussian Splatting es intensivo en cómputo GPU con llamadas frecuentes a kernels CUDA. La VRAM determina la complejidad máxima de la escena (número de gaussianos); el cómputo determina la velocidad de entrenamiento.

GPU

VRAM

Precio de Clore.ai

entrenamiento de 30K iteraciones

Máx. gaussianos

RTX 3090

24 GB

$0.07–0.21/h

~45–55 min

~6M

RTX 4090

24 GB

$0.14–0.42/h

~30–35 min

~6M

A100 40GB

40 GB

bare metal

~12–18 min

~10M+

RTX 3080 12GB

12 GB

$0,05–0,19/h

~70 min

~3M (limitado)

La RTX 3090 a $0.07–0.21/h es la mejor opción para Gaussian Splatting. Una ejecución completa de entrenamiento de 30K iteraciones cuesta ~0.09–0.11 $ en tiempo de GPU. Para varias escenas en una sesión, el costo es insignificante.

Para experimentos rápidos: entrena primero hasta 7.000 iteraciones (~15 min en RTX 3090, ~$0.03). Comprueba la calidad en el visor web. Ejecuta las 30K iteraciones completas solo para el resultado final.

Nota sobre el preprocesamiento de COLMAP: COLMAP (Structure from Motion) se ejecuta en CPU/GPU, pero el cálculo intensivo ocurre en la CPU. La mayoría de los servidores de Clore.ai tienen CPUs adecuadas para escenas de menos de 200 imágenes. Para conjuntos de datos de 500+ imágenes, busca servidores con 16 o más núcleos de CPU.

Recursos útiles

AnteriorNerfstudio

SiguienteDescripción general

Última actualización hace 12 días

¿Te fue útil?