> 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/nerfstudio.md).

# 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+           |

{% hint style="info" %}
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.
{% endhint %}

***

## Étape 1 — Louez un GPU sur Clore.ai

1. Connectez-vous à [clore.ai](https://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.

{% hint style="info" %}
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).
{% endhint %}

***

## Étape 2 — Se connecter via SSH

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

{% hint style="info" %}
Le `dromni/nerfstudio` l'image utilise `utilisateur` (pas `root`) par défaut. Utilisez `sudo` pour les tâches administratives.
{% endhint %}

Vérifiez l'installation :

```bash
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 :

```bash
# 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) :

```bash
# 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 :

```bash
# 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
```

{% hint style="info" %}
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.
{% endhint %}

***

## É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 :

```bash
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)

```bash
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

```bash
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

{% hint style="info" %}
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.
{% endhint %}

***

## 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)

```bash
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

```bash
# 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

```bash
# 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

```bash
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

```bash
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

```bash
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)

```bash
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 :

```python
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

```bash
# 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é :

```bash
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

```bash
# 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 :

```bash
# 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           |

{% hint style="info" %}
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.
{% endhint %}

***

## Ressources utiles

* [Nerfstudio GitHub](https://github.com/nerfstudio-project/nerfstudio)
* [Documentation Nerfstudio](https://docs.nerf.studio)
* [dromni/nerfstudio Docker Hub](https://hub.docker.com/r/dromni/nerfstudio)
* [Comparaison des méthodes Nerfstudio](https://docs.nerf.studio/nerfology/methods/index.html)
* [Documentation COLMAP](https://colmap.github.io/)

***

## 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](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-3d/nerfstudio.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.