Splatting gaussien 3D

Splatting gaussien 3D est une technique révolutionnaire de reconstruction de scènes 3D en temps réel avec plus de 15 000 étoiles sur GitHub. Contrairement aux méthodes basées sur NeRF, le Gaussian Splatting représente les scènes comme des millions de minuscules gaussiennes 3D pouvant être rendues à des fréquences d’images en temps réel (100+ FPS) tout en atteignant une qualité photoréaliste. Déployez-le sur le cloud GPU de Clore.ai pour reconstruire et explorer des scènes 3D à partir de vos propres photos.

Qu’est-ce que le Splatting gaussien 3D ?

Les méthodes NeRF traditionnelles encodent implicitement une scène dans un réseau neuronal, ce qui nécessite un ray marching par pixel au moment du rendu. Le Gaussian Splatting adopte une approche fondamentalement différente :

Initialisation : Partir d’un nuage de points clairsemé (à partir de COLMAP)
Représentation : Étendre chaque point en une gaussienne 3D avec position, échelle, rotation, opacité et couleur par harmoniques sphériques
Optimisation : Rendre les gaussiennes de manière différentiable et optimiser par rapport aux images d’entraînement
Rendu : Projeter les gaussiennes sur le plan de l’image via le compositing alpha (extrêmement rapide)

Principaux avantages par rapport à NeRF :

Rendu en temps réel (100+ FPS en 1080p)
Meilleure reconstruction des détails fins
Représentation 3D explicite (modifiable, exportable)
Entraînement plus rapide (30–60 min contre des heures)
Fonctionne sur des GPU grand public

Prérequis

Exigence

Minimum

Recommandé

VRAM GPU

12 Go

24 Go

GPU

RTX 3080 12 Go

RTX 4090 / A100

RAM

16 Go

32 Go

Stockage

30 Go

60 Go

CUDA

12.8+

Le Gaussian Splatting a des exigences CUDA strictes. La version de CUDA doit correspondre à diff-gaussian-rasterization l’extension compilée. L’utilisation du Dockerfile fourni élimine les problèmes de compatibilité.

Étape 1 — Louer un GPU sur Clore.ai

Connectez-vous à clore.ai.
Cliquez sur Place de marché et filtrez par VRAM ≥ 16 Go.
Sélectionnez un serveur — la RTX 4090 offre le meilleur rapport qualité/prix.
Définissez l’image Docker sur votre image personnalisée (voir l’étape 2).
Définissez les ports ouverts : 22 (SSH) et 8080 (visionneuse web).
Cliquez sur Louer.

Étape 2 — Dockerfile

Construisez une image Docker personnalisée avec toutes les dépendances :

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/*

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

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

WORKDIR /workspace

# Cloner le dépôt 3DGS original
RUN git clone https://github.com/graphdeco-inria/gaussian-splatting /workspace/gaussian-splatting \
    --recursive

# Installer les dépendances Python
RUN cd /workspace/gaussian-splatting && \
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128 && \
    pip install -r requirements.txt

# Compiler les extensions CUDA
RUN cd /workspace/gaussian-splatting && \
    pip install submodules/diff-gaussian-rasterization && \
    pip install submodules/simple-knn

# Installer les dépendances de la visionneuse web
RUN pip install viser==0.1.29 nerfview==0.0.4 trimesh

EXPOSE 22 8080

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

Construire et pousser

Construisez l’image et poussez-la vers votre propre compte Docker Hub (remplacez YOUR_DOCKERHUB_USERNAME par votre nom d'utilisateur réel) :

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

Il n’existe pas d’image Docker officielle préconstruite pour 3D Gaussian Splatting sur Docker Hub. Le dépôt officiel à graphdeco-inria/gaussian-splatting n’en fournit pas — construisez-la à partir du Dockerfile ci-dessus. L’image doit être construite avec les bons drapeaux d’architecture CUDA correspondant à votre GPU cible.

Utilisez YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest dans votre configuration Clore.ai.

Étape 3 — Connectez-vous via SSH

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

Vérifiez la compilation :

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

Étape 4 — Préparez votre jeu de données

Option A : utiliser le jeu de données Tandt (Tanks and Temples)

Jeu de données de référence classique pour des tests rapides :

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

# Télécharger une petite scène de test
wget https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/datasets/input/tandt.zip
unzip tandt.zip

Option B : traiter vos propres photos

# Téléverser les photos
scp -P <port> -r ./my_photos/ root@<clore-host>:/workspace/data/

# Exécuter le script de traitement COLMAP (fourni avec 3DGS)
cd /workspace/gaussian-splatting

python convert.py \
    -s /workspace/data/my_photos \
    --no_gpu   # optionnel : si le solveur GPU de COLMAP entre en conflit

Le convert.py le script exécute le pipeline COLMAP complet : extraction des caractéristiques, appariement, reconstruction clairsemée et dédistorsion. Cela prend 5 à 30 minutes selon le nombre d’images.

Option C : traiter à partir d’une vidéo

# Extraire les images de la vidéo à 2 fps
ffmpeg -i /workspace/data/my_video.mp4 \
    -vf fps=2 \
    /workspace/data/frames/frame_%04d.jpg

# Ensuite, lancer le traitement COLMAP sur les images
python convert.py -s /workspace/data/frames

Étape 5 — Entraîner un splat gaussien

Entraînement standard

cd /workspace/gaussian-splatting

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

Entraînement sur le jeu de données Tandt

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

Entraînement rapide (aperçu rapide)

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

L’entraînement jusqu’à 7 000 itérations prend environ 10 minutes sur une RTX 4090 et donne un bon aperçu de la qualité. Les 30 000 itérations complètes prennent environ 30 à 40 minutes et produisent la qualité finale.

Progression de l’entraînement

Surveillez la sortie de l’entraînement — vous verrez des métriques comme :

[ITER 1000] Évaluation de l’entraînement : L1 0.04, PSNR 26.12 dB
[ITER 7000] Évaluation de l’entraînement : L1 0.02, PSNR 29.45 dB
[ITER 30000] Évaluation de l’entraînement : L1 0.01, PSNR 32.80 dB

Un PSNR supérieur à 30 dB indique une reconstruction de haute qualité.

Étape 6 — Rendre et visualiser

Rendu à partir du modèle entraîné

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

Les rendus sont enregistrés dans /workspace/output/my_scene/test/ours_30000/renders/.

Créer une vidéo de survol

# Convertir les images rendues en vidéo
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

Évaluer les métriques

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

Sortie attendue :

SSIM : 0.8324
PSNR : 32.81
LPIPS : 0.1893

Étape 7 — Visionneuse web interactive

Pour explorer la scène entraînée de manière interactive :

Avec 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("Visionneuse en cours d’exécution à http://0.0.0.0:8080")

# Charger le fichier 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)

# Ajouter le nuage de points à la visionneuse
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 &

Ensuite, ouvrez : http://<clore-host>:<public-port-8080>

Alternative : utiliser SuperSplat (visionneuse basée sur le navigateur)

Téléchargez le .ply fichier et ouvrez-le dans SuperSplat:

# Télécharger depuis votre machine locale
scp -P <port> root@<clore-host>:/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply ./

Puis faites un glisser-déposer du .ply dans le navigateur SuperSplat à : https://playcanvas.com/super-splat

Options avancées

Contrôler le nombre de gaussiennes

# Densification plus élevée pour des scènes plus détaillées
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --densify_until_iter 15000 \
    --densify_grad_threshold 0.0002

Fond blanc (pour les objets)

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

Scènes à grande échelle

# Augmenter l’intervalle de réinitialisation de l’opacité pour les scènes extérieures
python train.py \
    -s /workspace/data/outdoor \
    -m /workspace/output/outdoor \
    --opacity_reset_interval 5000 \
    --iterations 50000

Alternative : Gaussian Splatting avec gsplat

gsplat est une implémentation plus rapide et plus économe en mémoire :

pip install gsplat

# Entraînement avec gsplat
python examples/simple_trainer.py \
    --data_dir /workspace/data/my_photos \
    --result_dir /workspace/gsplat_output

Dépannage

La compilation de l’extension CUDA échoue

erreur : aucune image de noyau n’est disponible pour l’exécution sur le périphérique

Solution : Recompilez pour votre architecture GPU spécifique :

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

COLMAP ne parvient pas à reconstruire

Solutions :

Assurez-vous d’un chevauchement d’images ≥ 50 %
Utilisez plus de photos (100+ recommandées)
Essayez l’appariement séquentiel pour les images vidéo : ajoutez --match sequential à convert.py

Mémoire insuffisante pendant l’entraînement

# Réduire le nombre maximal de gaussiennes
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --max_num_splats 2000000  # la valeur par défaut est d’environ 6 M

Artefacts flottants dans la scène

Artefacts flottants issus de l’initialisation gaussienne :

Augmentez --densify_grad_threshold pour être plus sélectif
Utilisez --prune_opacity_threshold 0.005 pour supprimer plus tôt les gaussiennes à faible opacité

Recommandations GPU Clore.ai

L’entraînement du Gaussian Splatting est très intensif en calcul GPU avec des appels fréquents aux noyaux CUDA. La VRAM détermine la complexité maximale de la scène (nombre de gaussiennes) ; la puissance de calcul détermine la vitesse d’entraînement.

GPU

VRAM

Prix Clore.ai

entraînement 30K itérations

Nombre max de gaussiennes

RTX 3090

24 Go

0,07–0,21 $/h

~45–55 min

~6 M

RTX 4090

24 Go

0,14–0,42 $/h

~30–35 min

~6 M

A100 40 Go

40 Go

bare metal

~12–18 min

~10 M+

RTX 3080 12 Go

12 Go

0,05–0,19 $/h

~70 min

~3 M (limité)

La RTX 3090 à 0,07–0,21 $/h est le meilleur choix pour le Gaussian Splatting. Une exécution complète d’entraînement de 30K itérations coûte environ 0,09–0,11 $ en temps GPU. Pour plusieurs scènes dans une session, le coût est négligeable.

Pour des expériences rapides : entraînez d’abord jusqu’à 7 000 itérations (~15 min sur RTX 3090, ~0,03 $). Vérifiez la qualité dans la visionneuse web. N’exécutez les 30K itérations complètes que pour la sortie finale.

Remarque sur le prétraitement COLMAP : COLMAP (Structure from Motion) s’exécute sur CPU/GPU, mais le calcul intensif se fait sur CPU. La plupart des serveurs Clore.ai disposent de CPU suffisants pour des scènes de moins de 200 images. Pour des jeux de données de 500+ images, recherchez des serveurs avec 16 cœurs CPU ou plus.

Ressources utiles

PrécédentNerfstudio

SuivantAperçu

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?