> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/generacion-3d/gaussian-splatting.md). # 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: 1. **Inicialización:** Comienza a partir de una nube de puntos dispersa (de COLMAP) 2. **Representación:** Expande cada punto en un gaussiano 3D con posición, escala, rotación, opacidad y color de armónicos esféricos 3. **Optimización:** Renderiza gaussianos de forma diferenciable y optimiza contra las imágenes de entrenamiento 4. **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+ | 12.8+ | {% hint style="warning" %} 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. {% endhint %} *** ## Paso 1 — Alquila una GPU en Clore.ai 1. Inicia sesión en [clore.ai](https://clore.ai). 2. Haz clic en **Marketplace** y filtra por VRAM ≥ 16 GB. 3. Selecciona un servidor — la RTX 4090 ofrece la mejor relación precio/rendimiento. 4. Configura la imagen Docker en tu imagen personalizada (ver Paso 2). 5. Establece los puertos abiertos: `22` (SSH) y `8080` (visor web). 6. Haz clic en **Alquilar**. *** ## Paso 2 — Dockerfile Compila una imagen Docker personalizada con todas las dependencias: ```dockerfile 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): ```bash docker build -t YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest . docker push YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest ``` {% hint style="info" %} No existe una imagen Docker oficial precompilada para 3D Gaussian Splatting en Docker Hub. El repositorio oficial en [graphdeco-inria/gaussian-splatting](https://github.com/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. {% endhint %} Usa `YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest` en tu configuración de Clore.ai. *** ## Paso 3 — Conéctate por SSH ```bash ssh root@ -p ``` Verifica la compilación: ```bash 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: ```bash 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 ```bash # Subir fotos scp -P -r ./my_photos/ root@:/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 ``` {% hint style="info" %} 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. {% endhint %} ### Opción C: procesar desde video ```bash # 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 ```bash 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 ```bash python train.py \\ -s /workspace/data/tandt/truck \\ -m /workspace/output/truck \\ --iterations 30000 \\ --eval ``` ### Entrenamiento rápido (vista previa rápida) ```bash python train.py \\ -s /workspace/data/my_photos \\ -m /workspace/output/my_scene_fast \\ --iterations 7000 ``` {% hint style="info" %} 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. {% endhint %} ### 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 ```bash 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 ```bash # 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 ```bash 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 ```python # /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) ``` ```bash python /workspace/view_splat.py & ``` Luego abre: `http://:` ### Alternativa: usar SuperSplat (visor basado en navegador) Descarga el `.ply` archivo y ábrelo en [SuperSplat](https://playcanvas.com/super-splat): ```bash # Descargar desde tu máquina local scp -P root@:/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 ```bash # 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) ```bash python train.py \\ -s /workspace/data/my_object \\ -m /workspace/output/my_object \\ --white_background ``` ### Escenas de gran escala ```bash # 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: ```bash 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: ```bash 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 ```bash # 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](https://clore.ai/bare-metal) | \~12–18 min | \~10M+ | | RTX 3080 12GB | 12 GB | $0,05–0,19/h | \~70 min | \~3M (limitado) | {% hint style="info" %} **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. {% endhint %} **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 * [GitHub de 3D Gaussian Splatting](https://github.com/graphdeco-inria/gaussian-splatting) * [Artículo original (SIGGRAPH 2023)](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/) * [gsplat — Implementación rápida](https://github.com/nerfstudio-project/gsplat) * [SuperSplat — Visor en el navegador](https://playcanvas.com/super-splat) * [Comunidad de Gaussian Splatting (Reddit)](https://www.reddit.com/r/gaussiansplatting/) * [Awesome Gaussian Splatting](https://github.com/MrNeRF/awesome-3D-gaussian-splatting) --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-es/generacion-3d/gaussian-splatting.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.