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

{% 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 — 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 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.

{% 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 — Connexion via SSH

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

{% hint style="info" %}
Le `dromni/nerfstudio` l'image utilise `user` (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 à tester immédiatement :

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

```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 d'une 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-les
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 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.
{% endhint %}

***

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

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

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

***

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

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

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

```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 l'entraînement et l'é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 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

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

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

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

```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,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](https://clore.ai/bare-metal) | \~5–8 min           |

{% hint style="info" %}
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.
{% 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 (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](https://clore.ai/bare-metal) |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, 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, and the optional `goal` query parameter:

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

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