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+

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.

---

Schritt 1 — Mieten Sie eine GPU auf Clore.ai

1. Melden Sie sich an bei 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.

Der dromni/nerfstudio Image ist das community-gepflegte offizielle Image und enthält alle Abhängigkeiten vorinstalliert (CUDA, tiny-cuda-nn, colmap, ffmpeg).

---

Schritt 2 — Verbindung per SSH

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

Der dromni/nerfstudio Image verwendet Benutzer (nicht root) standardmäßig. Verwenden Sie sudo für administrative Aufgaben.

Überprüfen Sie die Installation:

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:

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

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

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

---

Schritt 4 — Trainieren Sie ein NeRF

Grundlegendes Training mit Nerfacto (empfohlen)

Nerfacto ist Nerfstudios Flaggschiffmethode 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 — 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

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.

---

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)

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

# 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

# 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

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

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

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

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)

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

# 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

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.

---

Nützliche Ressourcen

• Nerfstudio GitHub

• Nerfstudio Dokumentation

• dromni/nerfstudio Docker Hub

• Nerfstudio Methodenvergleich

• COLMAP-Dokumentation

---

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 GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.