> 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-fr/generation-3d/gaussian-splatting.md). # 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 : 1. **Initialisation :** Partir d’un nuage de points clairsemé (à partir de COLMAP) 2. **Représentation :** Étendre chaque point en une gaussienne 3D avec position, échelle, rotation, opacité et couleur par harmoniques sphériques 3. **Optimisation :** Rendre les gaussiennes de manière différentiable et optimiser par rapport aux images d’entraînement 4. **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+ | 12.8+ | {% hint style="warning" %} 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é. {% endhint %} *** ## Étape 1 — Louer un GPU sur Clore.ai 1. Connectez-vous à [clore.ai](https://clore.ai). 2. Cliquez sur **Place de marché** et filtrez par VRAM ≥ 16 Go. 3. Sélectionnez un serveur — la RTX 4090 offre le meilleur rapport qualité/prix. 4. Définissez l’image Docker sur votre image personnalisée (voir l’étape 2). 5. Définissez les ports ouverts : `22` (SSH) et `8080` (visionneuse web). 6. Cliquez sur **Louer**. *** ## Étape 2 — Dockerfile Construisez une image Docker personnalisée avec toutes les dépendances : ```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/* # 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) : ```bash docker build -t YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest . docker push YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest ``` {% hint style="info" %} 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](https://github.com/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. {% endhint %} Utilisez `YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest` dans votre configuration Clore.ai. *** ## Étape 3 — Connectez-vous via SSH ```bash ssh root@ -p ``` Vérifiez la compilation : ```bash 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 : ```bash 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 ```bash # Téléverser les photos scp -P -r ./my_photos/ root@:/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 ``` {% hint style="info" %} 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. {% endhint %} ### Option C : traiter à partir d’une vidéo ```bash # 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 ```bash 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 ```bash python train.py \ -s /workspace/data/tandt/truck \ -m /workspace/output/truck \ --iterations 30000 \ --eval ``` ### Entraînement rapide (aperçu rapide) ```bash python train.py \ -s /workspace/data/my_photos \ -m /workspace/output/my_scene_fast \ --iterations 7000 ``` {% hint style="info" %} 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. {% endhint %} ### 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é ```bash 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 ```bash # 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 ```bash 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 ```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("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) ``` ```bash python /workspace/view_splat.py & ``` Ensuite, ouvrez : `http://:` ### Alternative : utiliser SuperSplat (visionneuse basée sur le navigateur) Téléchargez le `.ply` fichier et ouvrez-le dans [SuperSplat](https://playcanvas.com/super-splat): ```bash # Télécharger depuis votre machine locale scp -P root@:/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 ```bash # 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) ```bash python train.py \ -s /workspace/data/my_object \ -m /workspace/output/my_object \ --white_background ``` ### Scènes à grande échelle ```bash # 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 : ```bash 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 : ```bash 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 ```bash # 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](https://clore.ai/bare-metal) | \~12–18 min | \~10 M+ | | RTX 3080 12 Go | 12 Go | 0,05–0,19 $/h | \~70 min | \~3 M (limité) | {% hint style="info" %} **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. {% endhint %} **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 * [GitHub 3D Gaussian Splatting](https://github.com/graphdeco-inria/gaussian-splatting) * [Article original (SIGGRAPH 2023)](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/) * [gsplat — Implémentation rapide](https://github.com/nerfstudio-project/gsplat) * [SuperSplat — Visionneuse navigateur](https://playcanvas.com/super-splat) * [Communauté 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-fr/generation-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.