Nerfstudio

Nerfstudio est un cadre modulaire et adapté aux chercheurs pour l'entraînement et le rendu Champs de Radiance Neuronale (NeRF) — une technique qui reconstruit des scènes 3D photoréalistes à partir d'images 2D. Avec plus de 10 000 étoiles sur GitHub, c'est la référence de fait 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, pour une position et une direction de caméra données, renvoie la couleur et la densité en ce point. En s'entraînant sur des dizaines de photographies prises sous différents angles, NeRF apprend une représentation 3D complète pouvant ê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) au port 7007

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

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

Cas d'utilisation :

• Reconstruction de scènes 3D à partir d'images 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	11.8+	12.1+

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 — Louez un GPU sur Clore.ai

1. Connectez-vous à clore.ai.

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

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

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

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

6. Cliquez Louez 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 — Se connecter via SSH

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

Le dromni/nerfstudio l'image utilise utilisateur (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 pour tester immédiatement :

# Téléchargez le jeu de données poster (petit, idéal pour tester)
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 de 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
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 significatif (>60% entre images adjacentes). Déplacez-vous autour de l'objet/ de la scène selon un schéma systématique — cercles, grilles ou huit fonctionnent bien.

---

Étape 4 — Entraînez un NeRF

Entraînement de base avec Nerfacto (recommandé)

Nerfacto est la méthode phare de Nerfstudio, équilibrant 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édez à la visionneuse interactive

Ouvrez votre navigateur et rendez-vous sur :

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

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

• Progression de l'entraînement en direct

• Qualité de rendu NeRF actuelle

• Contrôles caméra interactifs

• Courbes de perte d'entraînement

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

---

Méthodes d'entraînement disponibles

Méthode	Vitesse	Qualité	VRAM	Remarques
nerfacto	Moyen	Élevée	8 Go	Meilleur compromis général
instant-ngp	Rapide	Moyen	6 Go	Entraînement le plus rapide
splatfacto	Rapide	Élevée	8 Go	Projection gaussienne (Gaussian splatting)
tensorf	Moyen	Élevée	12 Go	Bon pour les objets
mipnerf360	Lent	Très élevé	24 Go	Meilleure qualité
vanilla-nerf	Très lent	Élevée	16 Go	Référence de recherche

Entraînement avec Splatfacto (Gaussian Splatting)

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

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

# Dernier checkpoint
ls /home/user/outputs/my_scene/nerfacto/*/nerfstudio_models/

Rendre une vidéo de survol

# Interactif : définissez le chemin 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 un entraînement et une é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 via 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 pour la capture caméra

Paramètre	Recommandation
Recouvrement	≥ 60% entre les images
Images	100–300 (extérieurs), 50–150 (objets)
Mouvement	Mouvement lent et régulier
Éclairage	Constant, éviter les ombres dures
Mise au point	Netteté sur l'ensemble

Améliorer les résultats COLMAP

# Pour les scènes difficiles, utilisez l'appariement 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 n'arrive 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 l'appariement exhaustif : --matching-method exhaustive

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

Visionneuse inaccessible

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

ss -tlnp | grep 7007

La perte d'entraînement n'a pas diminué

Solutions :

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

• Réduire 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 de batch
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 résultats

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

# 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,10 $/h	~30–45 min
RTX 4090	24 Go	~0,35 $/h	~10–15 min
A100 40GB	40 Go	~0,80 $/h	~5–8 min

Commencez par Instant-NGP pour des aperçus rapides, puis passez à Nerfacto ou MipNeRF360 pour la qualité finale. Ce flux de travail économise des coûts de calcul significatifs.

---

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 (24GB)	~$0.12/gpu/hr
Production	RTX 4090 (24GB)	~$0.70/gpu/hr
Scènes à grande échelle / haute résolution	A100 80GB	~$1.20/gpu/hr

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