> 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-de/3d-generierung/nerfstudio.md).

# Nerfstudio

**Nerfstudio** ist ein modulares, forschungsfreundliches Framework für das Training und Rendern **Neural Radiance Fields (NeRF)** — eine Technik, die fotorealistische 3D-Szenen aus 2D-Bildern rekonstruiert. Mit über 10.000 GitHub-Sternen ist es der De-facto-Standard für NeRF-Forschung und Produktionsanwendungen. Führe es auf der GPU-Cloud von Clore.ai aus, um 3D-Szenen aus deinen eigenen Fotos oder Videos zu rekonstruieren.

***

## Was ist Nerfstudio?

NeRF (Neural Radiance Field) stellt eine 3D-Szene als neuronales Netz dar, das bei gegebener Kameraposition und -richtung die Farbe und Dichte an diesem Punkt ausgibt. Durch das Training mit Dutzenden von Fotografien, die aus verschiedenen Winkeln aufgenommen wurden, lernt NeRF eine vollständige 3D-Darstellung, die aus jedem Blickwinkel gerendert werden kann.

**Nerfstudio bietet:**

* Mehrere NeRF-Methoden: Nerfacto, Instant-NGP, Splatfacto, TensoRF und mehr
* CLI und Python-API
* Interaktiver Web-Viewer (Viser) auf Port 7007
* Export in Punktwolken, Meshes und Video-Fahrten
* Unterstützung für benutzerdefinierte Datensätze durch COLMAP-Integration

**Anwendungsfälle:**

* 3D-Szenenrekonstruktion aus Drohnenaufnahmen
* Produktvisualisierung aus Fotos
* Virtuelle Rundgänge aus Smartphone-Aufnahmen
* Forschung zu Novel-View-Synthese

***

## Voraussetzungen

| Anforderung | Minimum  | Empfohlen       |
| ----------- | -------- | --------------- |
| GPU-VRAM    | 8 GB     | 16–24 GB        |
| GPU         | RTX 3080 | RTX 4090 / A100 |
| RAM         | 16 GB    | 32 GB           |
| Speicher    | 20 GB    | 50+ GB          |
| CUDA        | 12.8+    | 12.8+           |

{% hint style="info" %}
Die Trainingszeit skaliert mit der Komplexität der Szene. Eine typische Außenszene mit 100 Fotos trainiert auf einer RTX 4090 in 10–30 Minuten. Der interaktive Viewer aktualisiert sich während des Trainings in Echtzeit.
{% endhint %}

***

## Schritt 1 — Miete eine GPU auf Clore.ai

1. Melde dich an bei [clore.ai](https://clore.ai).
2. Klicken Sie auf **Marktplatz** und nach VRAM ≥ 16 GB filtern.
3. Wähle einen Server aus — RTX 4090 ist ideal für Nerfstudio.
4. Docker-Image festlegen: **`dromni/nerfstudio:latest`**
5. Offene Ports festlegen: `22` (SSH) und `7007` (Viser-Web-Viewer).
6. Klicken Sie auf **Mieten** und warte, bis die Instanz initialisiert ist.

{% hint style="info" %}
Der `dromni/nerfstudio` Das Image ist das von der Community gepflegte offizielle Image und enthält alle Abhängigkeiten vorinstalliert (CUDA, tiny-cuda-nn, colmap, ffmpeg).
{% endhint %}

***

## Schritt 2 — Verbinde dich per SSH

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

{% hint style="info" %}
Der `dromni/nerfstudio` Das Image verwendet `user` (nicht `root`) standardmäßig. Verwende `sudo` für administrative Aufgaben.
{% endhint %}

Überprüfe die Installation:

```bash
ns-train --help
ns-render --help
ns-viewer --help
```

***

## Schritt 3 — Bereite deinen Datensatz vor

### Option A: Verwende das bereitgestellte Beispieldataset

Nerfstudio enthält integrierte Datensätze zum sofortigen Testen:

```bash
# Lade das Poster-Dataset herunter (klein, ideal zum Testen)
ns-download-data nerfstudio --capture-name=poster

# Weitere verfügbare Datensätze:
# ns-download-data nerfstudio --capture-name=egypt
# ns-download-data nerfstudio --capture-name=floating-tree
# ns-download-data nerfstudio --capture-name=stump
```

### Option B: Verarbeite deine eigenen Bilder

Wenn du Fotos oder Videos deiner Szene hast:

#### Aus Bildern (COLMAP-Pipeline):

```bash
# Lade deine Bilder per SCP hoch
scp -P <port> -r ./my_photos/ user@<clore-host>:/home/user/data/

# Mit COLMAP verarbeiten, um Kameraposen zu erhalten
ns-process-data images \\
    --data /home/user/data/my_photos \\
    --output-dir /home/user/data/my_scene
```

#### Aus Video:

```bash
# Video hochladen
scp -P <port> my_video.mp4 user@<clore-host>:/home/user/data/

# Frames extrahieren und verarbeiten
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" %}
Für beste Ergebnisse verwende **100–300 Fotos** mit signifikanter Überlappung (>60 % zwischen benachbarten Frames). Bewege dich in einem systematischen Muster um das Objekt/die Szene herum — Kreise, Gitter oder Achtformen funktionieren gut.
{% endhint %}

***

## Schritt 4 — Trainiere ein NeRF

### Grundtraining mit Nerfacto (empfohlen)

Nerfacto ist Nerfstudios Vorzeigemethode und balanciert Qualität und Geschwindigkeit:

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

### Training mit Instant-NGP (am schnellsten)

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

### Training mit dem bereitgestellten Poster-Datensatz

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

***

## Schritt 5 — Greife auf den interaktiven Viewer zu

Öffnen Sie Ihren Browser und navigieren Sie zu:

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

Du wirst einen 3D-Viewer sehen, der von **Viser** angetrieben wird und Folgendes zeigt:

* Live-Trainingsfortschritt
* Aktuelle NeRF-Rendering-Qualität
* Interaktive Kamerasteuerung
* Trainingsverlustkurven

{% hint style="info" %}
Der Viewer aktualisiert sich während des Trainings alle paar Sekunden. Du kannst rotieren, schwenken und zoomen, um die Szenenqualität während des Trainingsfortschritts zu prüfen.
{% endhint %}

***

## Verfügbare Trainingsmethoden

| Methode        | Geschwindigkeit | Qualität  | VRAM  | Hinweise             |
| -------------- | --------------- | --------- | ----- | -------------------- |
| `nerfacto`     | Mittel          | Hoch      | 8 GB  | Am besten allround   |
| `instant-ngp`  | Schnell         | Mittel    | 6 GB  | Schnellstes Training |
| `splatfacto`   | Schnell         | Hoch      | 8 GB  | Gaussian Splatting   |
| `tensorf`      | Mittel          | Hoch      | 12 GB | Gut für Objekte      |
| `mipnerf360`   | Langsam         | Sehr hoch | 24 GB | Beste Qualität       |
| `vanilla-nerf` | Sehr langsam    | Hoch      | 16 GB | Forschungs-Baseline  |

### Training mit Splatfacto (Gaussian Splatting)

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

***

## Schritt 6 — Auswerten und Rendern

### Trainingsmetriken prüfen

```bash
# Trainingszusammenfassung anzeigen
ls /home/user/outputs/my_scene/nerfacto/

# Letzter Checkpoint
ls /home/user/outputs/my_scene/nerfacto/*/nerfstudio_models/
```

### Ein Video-Flythrough rendern

```bash
# Interaktiv: Lege im Viewer den Kamerapfad fest, dann exportieren
# Rendering per Kommandozeile:

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

### Interpolierte Spirale rendern

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

***

## Schritt 7 — 3D-Geometrie exportieren

### Punktwolke exportieren

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

### Mesh exportieren

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

### Gaussian Splats exportieren (PLY)

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

***

## Python-API

Für programmatisches Training und Auswertung:

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

# Trainingsbeispiel für die Python-API
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()
```

***

## Tipps für benutzerdefinierte Datensätze

### Best Practices für die Kameraaufnahme

| Einstellung | Empfehlung                            |
| ----------- | ------------------------------------- |
| Überlappung | ≥ 60 % zwischen den Frames            |
| Bilder      | 100–300 (im Freien), 50–150 (Objekte) |
| Bewegung    | Langsame, gleichmäßige Bewegung       |
| Beleuchtung | Gleichmäßig, harte Schatten vermeiden |
| Fokus       | Durchgehend scharf                    |

### COLMAP-Ergebnisse verbessern

```bash
# Bei schwierigen Szenen verwende exhaustives Matching (langsamer, aber genauer)
ns-process-data images \\
    --data /home/user/data/my_photos \\
    --output-dir /home/user/data/my_scene \\
    --sfm-tool colmap \\
    --matching-method exhaustive
```

***

## Fehlerbehebung

### COLMAP findet keine Kameraposen

**Lösungen:**

* Stelle sicher, dass die Bilder ausreichend überlappen
* Verifiziere, dass die Bilder scharf sind (keine Bewegungsunschärfe)
* Probiere exhaustives Matching: `--matching-method exhaustive`
* Reduziere `--num-frames-target` für Video, um bessere Frames auszuwählen

### Viewer nicht erreichbar

**Lösung:** Stelle sicher, dass Port 7007 in Clore.ai weitergeleitet wird. Verbindung testen:

```bash
ss -tlnp | grep 7007
```

### Trainingsverlust nimmt nicht ab

**Lösungen:**

* Prüfe, ob COLMAP erfolgreich war (achte auf `transforms.json` im Ausgabeverzeichnis)
* Lernrate reduzieren: `--pipeline.model.field-implementation hash`
* Auf dominanten Himmel prüfen (verwende `--pipeline.model.background-color white`)

### Speicher erschöpft

```bash
# Batch-Größe reduzieren
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
```

***

## Ausgaben herunterladen

Lade nach dem Training deine Renderings und Exporte herunter:

```bash
# Von deinem lokalen Rechner
scp -P <port> -r user@<clore-host>:/home/user/renders/ ./local-renders/
scp -P <port> -r user@<clore-host>:/home/user/exports/ ./local-exports/
```

***

## Kostenschätzung

| GPU       | VRAM  | Geschätzter Preis                         | Szene mit 100 Bildern |
| --------- | ----- | ----------------------------------------- | --------------------- |
| RTX 3080  | 10 GB | $0,05–0,19/Std.                           | \~30–45 Min.          |
| RTX 4090  | 24 GB | ca. 0,14–0,42 $/h                         | \~10–15 Min.          |
| A100 40GB | 40 GB | [Bare Metal](https://clore.ai/bare-metal) | \~5–8 Min.            |

{% hint style="info" %}
Beginne mit Instant-NGP für schnelle Vorschauen und wechsle dann für die finale Qualität zu Nerfacto oder MipNeRF360. Dieser Arbeitsablauf spart erhebliche Rechenkosten.
{% endhint %}

***

## Nützliche Ressourcen

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

***

## GPU-Empfehlungen für Clore.ai

| Anwendungsfall                      | Empfohlene GPU   | Geschätzte Kosten bei Clore.ai            |
| ----------------------------------- | ---------------- | ----------------------------------------- |
| Entwicklung/Testen                  | RTX 3090 (24 GB) | 0,07–0,21 $/GPU/Stunde                    |
| Produktion                          | RTX 4090 (24 GB) | 0,14–0,42 $/GPU/Stunde                    |
| Großskalige / hochauflösende Szenen | A100 80GB        | [Bare Metal](https://clore.ai/bare-metal) |

> 💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf [Clore.ai](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

# 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-de/3d-generierung/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.