Nerfstudio

Nerfstudio est un framework modulaire, convivial pour les chercheurs, pour l'entraînement et le rendu Champs de radiance neuronaux (NeRF) — une technique qui reconstruit des scènes 3D photoréalistes à partir d'images 2D. Avec plus de 10 000 étoiles GitHub, c'est la norme de facto pour la recherche et les applications de production NeRF. Exécutez-le sur le cloud GPU de Clore.ai pour reconstruire des scènes 3D à partir de vos propres photos ou vidéos.

---

Qu'est-ce que Nerfstudio ?

NeRF (Neural Radiance Field) représente une scène 3D sous la forme d'un réseau neuronal qui, étant donnée une position et une direction de caméra, renvoie la couleur et la densité à ce point. En s'entraînant sur des dizaines de photographies prises sous différents angles, NeRF apprend une représentation 3D complète qui peut être rendue depuis n'importe quel point de vue.

Nerfstudio fournit :

• Plusieurs méthodes NeRF : Nerfacto, Instant-NGP, Splatfacto, TensoRF, et plus encore

• CLI et API Python

• Visionneuse web interactive (Viser) sur le port 7007

• Export vers des nuages de points, des maillages et des vidéos de survol

• Prise en charge de jeux de données personnalisés via l'intégration COLMAP

Cas d'utilisation :

• Reconstruction de scène 3D à partir de séquences de drone

• Visualisation de produits à partir de photos

• Visites virtuelles à partir de captures de smartphone

• Recherche sur la synthèse de nouvelles vues

---

Prérequis

Exigence	Minimum	Recommandé
VRAM GPU	8 Go	16–24 Go
GPU	RTX 3080	RTX 4090 / A100
RAM	16 Go	32 Go
Stockage	20 Go	50+ Go
CUDA	12.8+	12.8+

Le temps d'entraînement évolue avec la complexité de la scène. Une scène extérieure typique à partir de 100 photos s'entraîne en 10 à 30 minutes sur une RTX 4090. La visionneuse interactive se met à jour en temps réel pendant l'entraînement.

---

Étape 1 — Louer un GPU sur Clore.ai

1. Connectez-vous à clore.ai.

2. Cliquez sur Place de marché et filtrez par VRAM ≥ 16 Go.

3. Sélectionnez un serveur — la RTX 4090 est idéale pour Nerfstudio.

4. Définissez l'image Docker : dromni/nerfstudio:latest

5. Définissez les ports ouverts : 22 (SSH) et 7007 (Visionneuse web Viser).

6. Cliquez sur Louer et attendez que l'instance s'initialise.

Le dromni/nerfstudio l'image est l'image officielle maintenue par la communauté et inclut toutes les dépendances préinstallées (CUDA, tiny-cuda-nn, colmap, ffmpeg).

---

Étape 2 — Connexion via SSH

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

Le dromni/nerfstudio l'image utilise user (pas root) par défaut. Utilisez sudo pour les tâches administratives.

Vérifiez l'installation :

ns-train --help
ns-render --help
ns-viewer --help

---

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

Option A : Utiliser le jeu de données d'exemple fourni

Nerfstudio inclut des jeux de données intégrés à tester immédiatement :

# Téléchargez le jeu de données poster (petit, idéal pour les tests)
ns-download-data nerfstudio --capture-name=poster

# Autres jeux de données disponibles :
# ns-download-data nerfstudio --capture-name=egypt
# ns-download-data nerfstudio --capture-name=floating-tree
# ns-download-data nerfstudio --capture-name=stump

Option B : Traiter vos propres images

Si vous avez des photos ou une vidéo de votre scène :

À partir d'images (pipeline COLMAP) :

# Téléversez vos images via SCP
scp -P <port> -r ./my_photos/ user@<clore-host>:/home/user/data/

# Traitez avec COLMAP pour obtenir les poses de caméra
ns-process-data images \
    --data /home/user/data/my_photos \
    --output-dir /home/user/data/my_scene

À partir d'une vidéo :

# Téléversez la vidéo
scp -P <port> my_video.mp4 user@<clore-host>:/home/user/data/

# Extrayez les images et traitez-les
ns-process-data video \
    --data /home/user/data/my_video.mp4 \
    --output-dir /home/user/data/my_scene \
    --num-frames-target 200

Pour de meilleurs résultats, utilisez 100–300 photos avec un recouvrement important (>60 % entre les images adjacentes). Faites le tour de l'objet/de la scène selon un schéma systématique — les cercles, les grilles ou les huit fonctionnent bien.

---

Étape 4 — Entraîner un NeRF

Entraînement de base avec Nerfacto (recommandé)

Nerfacto est la méthode phare de Nerfstudio, alliant qualité et vitesse :

ns-train nerfacto \
    --data /home/user/data/my_scene \
    --viewer.websocket-port 7007 \
    --output-dir /home/user/outputs

Entraînement avec Instant-NGP (le plus rapide)

ns-train instant-ngp \
    --data /home/user/data/my_scene \
    --viewer.websocket-port 7007 \
    --output-dir /home/user/outputs

Entraînement avec le jeu de données poster fourni

ns-train nerfacto \
    --data /home/user/data/nerfstudio/poster \
    --viewer.websocket-port 7007

---

Étape 5 — Accéder à la visionneuse interactive

Ouvrez votre navigateur et rendez-vous sur :

http://<clore-host>:<public-port-7007>

Vous verrez une visionneuse 3D propulsée par Viser qui affiche :

• La progression de l'entraînement en direct

• La qualité de rendu NeRF actuelle

• Commandes interactives de caméra

• Courbes de perte d'entraînement

La visionneuse se met à jour toutes les quelques secondes pendant l'entraînement. Vous pouvez faire pivoter, déplacer et zoomer pour inspecter la qualité de la scène au fur et à mesure de l'entraînement.

---

Méthodes d'entraînement disponibles

Méthode	Vitesse	Qualité	VRAM	Remarques
nerfacto	Moyen	Élevée	8 Go	Meilleur choix global
instant-ngp	Rapide	Moyen	6 Go	Entraînement le plus rapide
splatfacto	Rapide	Élevée	8 Go	Splatting gaussien
tensorf	Moyen	Élevée	12 Go	Bon pour les objets
mipnerf360	Lent	Très élevée	24 Go	Meilleure qualité
vanilla-nerf	Très lent	Élevée	16 Go	Référence de recherche

Entraînement avec Splatfacto (splatting gaussien)

ns-train splatfacto \
    --data /home/user/data/my_scene \
    --viewer.websocket-port 7007 \
    --pipeline.model.num-random 50000

---

Étape 6 — Évaluer et rendre

Vérifier les métriques d'entraînement

# Affichez le résumé de l'entraînement
ls /home/user/outputs/my_scene/nerfacto/

# Dernier point de contrôle
ls /home/user/outputs/my_scene/nerfacto/*/nerfstudio_models/

Rendre une vidéo de survol

# Interactif : définissez le trajet de la caméra dans la visionneuse, puis exportez
# Rendu en ligne de commande :

ns-render camera-path \
    --load-config /home/user/outputs/my_scene/nerfacto/<timestamp>/config.yml \
    --camera-path-filename /home/user/data/my_scene/camera_paths/my_path.json \
    --output-path /home/user/renders/output.mp4

Rendre une spirale interpolée

ns-render interpolate \
    --load-config /home/user/outputs/my_scene/nerfacto/<timestamp>/config.yml \
    --output-path /home/user/renders/spiral.mp4 \
    --render-nearest-camera True \
    --order-poses True

---

Étape 7 — Exporter la géométrie 3D

Exporter le nuage de points

ns-export pointcloud \
    --load-config /home/user/outputs/my_scene/nerfacto/<timestamp>/config.yml \
    --output-dir /home/user/exports/ \
    --num-points 1000000

Exporter le maillage

ns-export marching-cubes \
    --load-config /home/user/outputs/my_scene/nerfacto/<timestamp>/config.yml \
    --output-dir /home/user/exports/ \
    --resolution 1024

Exporter les splats gaussiens (PLY)

ns-export gaussian-splat \
    --load-config /home/user/outputs/my_scene/splatfacto/<timestamp>/config.yml \
    --output-dir /home/user/exports/

---

API Python

Pour l'entraînement et l'évaluation programmatiques :

from nerfstudio.scripts.train import main
from nerfstudio.configs.base_config import ViewerConfig
from nerfstudio.engine.trainer import TrainerConfig

# Exemple d'entraînement avec l'API Python
from nerfstudio.configs.method_configs import method_configs
from pathlib import Path

config = method_configs["nerfacto"]
config.pipeline.datamanager.data = Path("/home/user/data/my_scene")
config.viewer = ViewerConfig(websocket_port=7007, num_rays_per_chunk=1<<15)
config.max_num_iterations = 30000

trainer = config.setup()
trainer.train()

---

Conseils pour les jeux de données personnalisés

Bonnes pratiques de capture de caméra

Paramètre	Recommandation
Recouvrement	≥ 60 % entre les images
Images	100–300 (extérieur), 50–150 (objets)
Mouvement	Mouvement lent et régulier
Éclairage	Constant, évitez les ombres dures
Mise au point	Nette sur toute la séquence

Améliorer les résultats de COLMAP

# Pour les scènes difficiles, utilisez un rapprochement exhaustif (plus lent mais plus précis)
ns-process-data images \
    --data /home/user/data/my_photos \
    --output-dir /home/user/data/my_scene \
    --sfm-tool colmap \
    --matching-method exhaustive

---

Dépannage

COLMAP ne parvient pas à trouver les poses de caméra

Solutions :

• Assurez-vous que les images ont un recouvrement suffisant

• Vérifiez que les images sont nettes (pas de flou de mouvement)

• Essayez le rapprochement exhaustif : --matching-method exhaustive

• Réduisez --num-frames-target pour la vidéo afin de sélectionner de meilleures images

Visionneuse inaccessible

Solution : Assurez-vous que le port 7007 est transféré dans Clore.ai. Testez la connectivité :

ss -tlnp | grep 7007

La perte d'entraînement ne diminue pas

Solutions :

• Vérifiez que COLMAP a réussi (cherchez transforms.json dans le répertoire de sortie)

• Réduisez le taux d'apprentissage : --pipeline.model.field-implementation hash

• Vérifiez la présence d'un ciel dominant (utilisez --pipeline.model.background-color white)

Mémoire insuffisante

# Réduire la taille du lot
ns-train nerfacto \
    --data /home/user/data/my_scene \
    --pipeline.datamanager.train-num-rays-per-batch 2048 \
    --pipeline.datamanager.eval-num-rays-per-batch 1024

---

Télécharger les sorties

Après l'entraînement, téléchargez vos rendus et exportations :

# Depuis votre machine locale
scp -P <port> -r user@<clore-host>:/home/user/renders/ ./local-renders/
scp -P <port> -r user@<clore-host>:/home/user/exports/ ./local-exports/

---

Estimation des coûts

GPU	VRAM	Prix estimé	Scène de 100 images
RTX 3080	10 Go	0,05–0,19 $/h	~30–45 min
RTX 4090	24 Go	0,14–0,42 $/h	~10–15 min
A100 40 Go	40 Go	bare metal	~5–8 min

Commencez avec Instant-NGP pour des aperçus rapides, puis passez à Nerfacto ou MipNeRF360 pour la qualité finale. Ce flux de travail permet d'économiser considérablement les coûts de calcul.

---

Ressources utiles

• Nerfstudio GitHub

• Documentation Nerfstudio

• dromni/nerfstudio Docker Hub

• Comparaison des méthodes Nerfstudio

• Documentation COLMAP

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Production	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Scènes à grande échelle / haute résolution	A100 80 Go	bare metal

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.