3D Gaussian Splatting

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 escenas como millones de pequeños Gaussianos 3D que pueden renderizarse a velocidades de fotogramas en tiempo real (100+ FPS) mientras logra una calidad fotorrealista. Desplé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 NeRF codifican implícitamente una escena en una red neuronal, requiriendo ray marching por píxel en el momento del renderizado. Gaussian Splatting adopta un enfoque fundamentalmente distinto:

1. Inicialización: Comienza a partir de una nube de puntos dispersa (proveniente de COLMAP)

2. Representación: Expande cada punto en un Gaussiano 3D con posición, escala, rotación, opacidad y color en armónicos esféricos

3. Optimización: Renderiza diferenciablemente los Gaussianos y optimiza frente a las imágenes de entrenamiento

4. Renderizado: Proyecta los Gaussianos en el plano de la imagen mediante composición alfa (extremadamente rápido)

Principales ventajas sobre 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 frente a horas)

• Funciona en GPUs de consumo

---

Prerrequisitos

Requisito	Mínimo	Recomendado
VRAM GPU	12 GB	24 GB
GPU	RTX 3080 12GB	RTX 4090 / A100
RAM	16 GB	32 GB
Almacenamiento	30 GB	60 GB
CUDA	11.7+	12.1+

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

1. Inicia sesión en clore.ai.

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

3. Selecciona un servidor: la RTX 4090 ofrece la mejor relación precio/rendimiento.

4. Establece la imagen Docker a tu imagen personalizada (ver Paso 2).

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

6. Haz clic Alquilar.

---

Paso 2 — Dockerfile

Construye una imagen Docker personalizada con todas las dependencias:

FROM pytorch/pytorch:2.1.2-cuda12.1-cudnn8-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 3DGS original
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/cu121 && \
    pip install -r requirements.txt

# Construir 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 subir

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

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

No existe una imagen Docker preconstruida oficial para 3D Gaussian Splatting en Docker Hub. El repositorio oficial en graphdeco-inria/gaussian-splatting no proporciona una — constrúyela a partir del Dockerfile anterior. La imagen debe construirse con las banderas de arquitectura CUDA correctas que coincidan con tu GPU objetivo.

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

---

Paso 3 — Conéctate vía 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('CUDA extension OK')"

---

Paso 4 — Prepara tu conjunto de datos

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

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

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

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

Opción B: Procesar tus propias fotos

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

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

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

El convert.py el script ejecuta la tubería completa de COLMAP: extracción de características, matching, reconstrucción dispersa y undistortion. Esto toma 5–30 minutos dependiendo del número de imágenes.

Opción C: Procesar desde video

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

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

---

Paso 5 — Entrenar un Gaussian Splat

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 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 lleva ~10 minutos en una RTX 4090 y proporciona una buena vista previa de calidad. Las 30.000 iteraciones completas llevan ~30–40 minutos y producen la calidad final.

Progreso del entrenamiento

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

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

PSNR por encima de 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 los 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 en ejecución 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 la 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 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 a gran escala

# Aumentar el intervalo de reinicio de opacidad para escenas exteriores
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

Fallo en la compilación de la extensión CUDA

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

Solución: Reconstruye 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 falla al reconstruir

Soluciones:

• Asegura ≥ 50% de solapamiento entre imágenes

• Usa más fotos (se recomiendan 100+)

• Prueba matching 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 por defecto es ~6M

Elementos flotantes en la escena

Artefactos flotantes por la inicialización de Gaussianos:

• Aumente --densify_grad_threshold para ser más selectivo

• Usa --prune_opacity_threshold 0.005 para eliminar Gaussianos de baja opacidad antes

---

Recomendaciones de GPU en 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 en Clore.ai	Entrenamiento de 30K iteraciones	Máx. Gaussianos
RTX 3090	24 GB	~$0.12/h	~45–55 min	~6M
RTX 4090	24 GB	~$0.70/h	~30–35 min	~6M
A100 40GB	40 GB	~$1.20/h	~12–18 min	~10M+
RTX 3080 12GB	12 GB	~$0.08/h	~70 min	~3M (limitado)

La RTX 3090 a ~$0.12/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 múltiples 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. Solo ejecuta las 30K iteraciones completas para la salida final.

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

---

Recursos Útiles

• 3D Gaussian Splatting en GitHub

• Artículo original (SIGGRAPH 2023)

• gsplat — Implementación rápida

• SuperSplat — Visor en navegador

• Comunidad de Gaussian Splatting (Reddit)

• Awesome Gaussian Splatting