> 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 zum Trainieren 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ühren Sie es auf Clore.ais GPU-Cloud aus, um 3D-Szenen aus Ihren eigenen Fotos oder Videos zu rekonstruieren.

***

## Was ist Nerfstudio?

NeRF (Neural Radiance Field) stellt eine 3D-Szene als neuronales Netzwerk dar, das für eine gegebene Kameraposition und -richtung die Farbe und Dichte an diesem Punkt ausgibt. Durch Training mit Dutzenden von Fotos aus verschiedenen Blickwinkeln lernt NeRF eine vollständige 3D-Repräsentation, die aus jeder Perspektive 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 zu Punktwolken, Netzen (Meshes) und Video-Flythroughs
* Unterstützung für benutzerdefinierte Datensätze über COLMAP-Integration

**Anwendungsfälle:**

* 3D-Szenenrekonstruktion aus Drohnenaufnahmen
* Produktvisualisierung aus Fotos
* Virtuelle Rundgänge aus Smartphone-Aufnahmen
* Forschung zur Synthese neuer Ansichten

***

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

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

***

## Schritt 1 — Mieten Sie eine GPU auf Clore.ai

1. Melden Sie sich an bei [clore.ai](https://clore.ai).
2. Klicken Sie **Marktplatz** und filtern Sie nach VRAM ≥ 16 GB.
3. Wählen Sie einen Server — 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 **Mieten** und warten Sie, bis die Instanz initialisiert ist.

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

***

## Schritt 2 — Verbindung per SSH

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

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

Überprüfen Sie die Installation:

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

***

## Schritt 3 — Bereiten Sie Ihren Datensatz vor

### Option A: Verwenden Sie den bereitgestellten Beispieldatensatz

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

```bash
# Laden Sie den Poster-Datensatz herunter (klein, ideal zum Testen)
ns-download-data nerfstudio --capture-name=poster

# Andere 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: Verarbeiten Sie Ihre eigenen Bilder

Wenn Sie Fotos oder Video Ihrer Szene haben:

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

```bash
# Laden Sie Ihre 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 verwenden Sie **100–300 Fotos** mit signifikanter Überlappung (>60% zwischen benachbarten Frames). Gehen Sie systematisch um das Objekt/die Szene herum — Kreise, Gitter oder Achten funktionieren gut.
{% endhint %}

***

## Schritt 4 — Trainieren Sie ein NeRF

### Grundlegendes Training mit Nerfacto (empfohlen)

Nerfacto ist Nerfstudios Flaggschiffmethode 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 — Greifen Sie auf den interaktiven Viewer zu

Öffnen Sie Ihren Browser und navigieren Sie zu:

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

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

* Live-Trainingsfortschritt
* Aktuelle NeRF-Rendering-Qualität
* Interaktive Kamerasteuerung
* Kurven des Trainingsverlusts

{% hint style="info" %}
Der Viewer aktualisiert alle paar Sekunden während des Trainings. Sie können rotieren, verschieben und zoomen, um die Szenenqualität während des Trainings zu prüfen.
{% endhint %}

***

## Verfügbare Trainingsmethoden

| Methode        | Geschwindigkeit | Qualität  | VRAM  | Hinweise              |
| -------------- | --------------- | --------- | ----- | --------------------- |
| `nerfacto`     | Mittel          | Hoch      | 8 GB  | Beste Allround-Option |
| `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 — Evaluieren und Rendern

### Überprüfen Sie Trainingsmetriken

```bash
# Zeigen Sie die Trainingszusammenfassung an
ls /home/user/outputs/my_scene/nerfacto/

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

### Rendern eines Video-Flythroughs

```bash
# Interaktiv: Kamerapfad im Viewer festlegen, dann exportieren
# Rendering über die 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 Spiralrendering

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

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

# Python-API Trainingsbeispiel
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

### Beste Praktiken bei der Kameraaufnahme

| Einstellung | Empfehlung                               |
| ----------- | ---------------------------------------- |
| Überlappung | ≥ 60% zwischen Frames                    |
| Bilder      | 100–300 (im Freien), 50–150 (Objekte)    |
| Bewegung    | Langsame, gleichmäßige Bewegung          |
| Beleuchtung | Konsistent, vermeiden Sie harte Schatten |
| Fokus       | Scharf über den gesamten Bildbereich     |

### Verbesserung der COLMAP-Ergebnisse

```bash
# Für schwierige Szenen verwenden Sie exhaustive 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:**

* Stellen Sie sicher, dass die Bilder ausreichende Überlappung haben
* Überprüfen Sie, dass die Bilder scharf sind (keine Bewegungsunschärfe)
* Versuchen Sie exhaustive matching: `--matching-method exhaustive`
* Reduzieren Sie `--num-frames-target` um für Video bessere Frames auszuwählen

### Viewer nicht erreichbar

**Lösung:** Stellen Sie sicher, dass Port 7007 in Clore.ai weitergeleitet wird. Testen Sie die Konnektivität:

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

### Trainingsverlust sinkt nicht

**Lösungen:**

* Überprüfen Sie, ob COLMAP erfolgreich war (suchen Sie nach `transforms.json` im Ausgabeverzeichnis)
* Reduzieren Sie die Lernrate: `--pipeline.model.field-implementation hash`
* Prüfen Sie auf dominanten Himmel (verwenden Sie `--pipeline.model.background-color white`)

### Nicht genügend Speicher (Out of Memory)

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

***

## Outputs herunterladen

Nach dem Training laden Sie Ihre Renderings und Exporte herunter:

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

***

## Kostenabschätzung

| GPU       | VRAM  | Geschätzter Preis | Szene mit 100 Bildern |
| --------- | ----- | ----------------- | --------------------- |
| RTX 3080  | 10 GB | \~$0.10/Stunde    | \~30–45 min           |
| RTX 4090  | 24 GB | \~$0.35/Stunde    | \~10–15 min           |
| A100 40GB | 40 GB | \~$0.80/Stunde    | \~5–8 min             |

{% hint style="info" %}
Beginnen Sie mit Instant-NGP für schnelle Vorschauen und wechseln Sie dann zu Nerfacto oder MipNeRF360 für die Endqualität. Dieser Workflow 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/)

***

## Clore.ai GPU-Empfehlungen

| Anwendungsfall                         | Empfohlene GPU  | Geschätzte Kosten auf Clore.ai |
| -------------------------------------- | --------------- | ------------------------------ |
| Entwicklung/Tests                      | RTX 3090 (24GB) | \~$0.12/gpu/hr                 |
| Produktion                             | RTX 4090 (24GB) | \~$0.70/gpu/hr                 |
| Groß angelegte / hochauflösende Szenen | A100 80GB       | \~$1.20/gpu/hr                 |

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

```
GET https://docs.clore.ai/guides/guides_v2-de/3d-generierung/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.