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+

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.

---

Schritt 1 — Miete eine GPU auf Clore.ai

1. Melde dich an bei 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.

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

---

Schritt 2 — Verbinde dich per SSH

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

Der dromni/nerfstudio Das Image verwendet user (nicht root) standardmäßig. Verwende sudo für administrative Aufgaben.

Überprüfe die Installation:

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:

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

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

# 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

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.

---

Schritt 4 — Trainiere ein NeRF

Grundtraining mit Nerfacto (empfohlen)

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

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

Training mit Instant-NGP (am schnellsten)

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

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

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.

---

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)

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

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

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

Ein Video-Flythrough rendern

# 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

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

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

Mesh exportieren

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)

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:

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

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

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

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

# 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	~5–8 Min.

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.

---

Nützliche Ressourcen

• Nerfstudio GitHub

• Nerfstudio-Dokumentation

• dromni/nerfstudio Docker Hub

• Nerfstudio-Methodenvergleich

• COLMAP-Dokumentation

---

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

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.