3D-Gaussian-Splatting

3D-Gaussian-Splatting ist eine revolutionäre 3D-Szenenrekonstruktion in Echtzeit mit über 15.000 GitHub-Sternen. Im Gegensatz zu NeRF-basierten Methoden stellt Gaussian Splatting Szenen als Millionen winziger 3D-Gaussian dar, die gerendert werden können mit Echtzeit-Bildraten (100+ FPS) und dabei fotorealistische Qualität erreichen. Stelle es in der GPU-Cloud von Clore.ai bereit, um 3D-Szenen aus deinen eigenen Fotos zu rekonstruieren und zu erkunden.

Was ist 3D-Gaussian-Splatting?

Traditionelle NeRF-Methoden kodieren eine Szene implizit in einem neuronalen Netzwerk und erfordern bei der Darstellung ein Ray-Marching pro Pixel. Gaussian Splatting verfolgt einen grundsätzlich anderen Ansatz:

Initialisierung: Beginne mit einer spärlichen Punktwolke (von COLMAP)
Repräsentation: Erweitere jeden Punkt zu einer 3D-Gaussian mit Position, Skalierung, Rotation, Opazität und sphärischen Harmonischen als Farbe
Optimierung: Rendern von Gaussians mit Differenzierbarkeit und Optimierung anhand von Trainingsbildern
Darstellung: Projektiere Gaussians per Alpha-Komposition auf die Bildebene (extrem schnell)

Wichtige Vorteile gegenüber NeRF:

Echtzeit-Rendering (100+ FPS bei 1080p)
Bessere Rekonstruktion feiner Details
Explizite 3D-Repräsentation (bearbeitbar, exportierbar)
Schnelleres Training (30–60 Min. statt Stunden)
Funktioniert auf Consumer-GPUs

Voraussetzungen

Anforderung

Minimum

Schritt 1 — Miete eine GPU auf Clore.ai

Melde dich an bei clore.ai.
Klicken Sie auf Marktplatz und nach VRAM ≥ 16 GB filtern.
Wähle einen Server — die RTX 4090 bietet das beste Preis-Leistungs-Verhältnis.
Setze das Docker-Image auf dein benutzerdefiniertes Image (siehe Schritt 2).
Offene Ports festlegen: 22 (SSH) und 8080 (Web-Viewer).
Klicken Sie auf Mieten.

Schritt 2 — Dockerfile

Erstelle ein benutzerdefiniertes Docker-Image mit allen Abhängigkeiten:

FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

ENV DEBIAN_FRONTEND=noninteractive
ENV TORCH_CUDA_ARCH_LIST="6.0;6.1;7.0;7.5;8.0;8.6;8.9;9.0+PTX"

RUN apt-get update && apt-get install -y \
    git wget curl cmake build-essential \
    libboost-program-options-dev libboost-filesystem-dev \
    libboost-graph-dev libboost-system-dev libboost-test-dev \
    libeigen3-dev libflann-dev libfreeimage-dev \
    libmetis-dev libgoogle-glog-dev libgflags-dev \
    libsqlite3-dev libglew-dev qtbase5-dev libqt5opengl5-dev \
    libcgal-dev libceres-dev \
    ffmpeg libgl1 libglib2.0-0 \
    openssh-server \
    python3-pip python3-dev \
    && rm -rf /var/lib/apt/lists/*

# Installiere COLMAP
RUN apt-get update && apt-get install -y colmap && rm -rf /var/lib/apt/lists/*

# SSH konfigurieren
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

WORKDIR /workspace

# Klone das originale 3DGS-Repo
RUN git clone https://github.com/graphdeco-inria/gaussian-splatting /workspace/gaussian-splatting \
    --recursive

# Python-Abhängigkeiten installieren
RUN cd /workspace/gaussian-splatting && \
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128 && \
    pip install -r requirements.txt

# CUDA-Erweiterungen bauen
RUN cd /workspace/gaussian-splatting && \
    pip install submodules/diff-gaussian-rasterization && \
    pip install submodules/simple-knn

# Abhängigkeiten für den Web-Viewer installieren
RUN pip install viser==0.1.29 nerfview==0.0.4 trimesh

EXPOSE 22 8080

CMD service ssh start && tail -f /dev/null

Bauen und Pushen

Baue das Image und pushe es in dein eigenes Docker-Hub-Konto (ersetze YOUR_DOCKERHUB_USERNAME durch deinen tatsächlichen Benutzernamen):

docker build -t YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest .
docker push YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest

Es gibt kein offizielles vorgefertigtes Docker-Image für 3D Gaussian Splatting auf Docker Hub. Das offizielle Repository unter graphdeco-inria/gaussian-splatting stellt keines bereit — baue es mit dem obigen Dockerfile. Das Image muss mit den korrekten CUDA-Architektur-Flags gebaut werden, die zu deiner Ziel-GPU passen.

Verwende YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest in deiner Clore.ai-Konfiguration.

Schritt 3 — Per SSH verbinden

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

Überprüfe den Build:

cd /workspace/gaussian-splatting
python -c "from diff_gaussian_rasterization import GaussianRasterizationSettings; print('CUDA-Erweiterung OK')"

Schritt 4 — Bereite deinen Datensatz vor

Option A: Verwende den Tandt-(Tanks and Temples)-Datensatz

Klassischer Benchmark-Datensatz für schnelles Testen:

mkdir -p /workspace/data && cd /workspace/data

# Kleine Testszene herunterladen
wget https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/datasets/input/tandt.zip
unzip tandt.zip

Option B: Verarbeite deine eigenen Fotos

# Fotos hochladen
scp -P <port> -r ./my_photos/ root@<clore-host>:/workspace/data/

# COLMAP-Verarbeitungsskript ausführen (mit 3DGS bereitgestellt)
cd /workspace/gaussian-splatting

python convert.py \
    -s /workspace/data/my_photos \
    --no_gpu   # optional: falls der COLMAP-GPU-Solver in Konflikt gerät

Der convert.py das Skript führt die vollständige COLMAP-Pipeline aus: Merkmalsextraktion, Matching, spärliche Rekonstruktion und Entzerrung. Dies dauert je nach Anzahl der Bilder 5–30 Minuten.

Option C: Aus Video verarbeiten

# Extrahiere Frames aus dem Video mit 2fps
ffmpeg -i /workspace/data/my_video.mp4 \
    -vf fps=2 \
    /workspace/data/frames/frame_%04d.jpg

# Dann COLMAP-Verarbeitung für die Frames ausführen
python convert.py -s /workspace/data/frames

Schritt 5 — Gaussian Splat trainieren

Standard-Training

cd /workspace/gaussian-splatting

python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --iterations 30000 \
    --eval

Training auf dem Tandt-Datensatz

python train.py \
    -s /workspace/data/tandt/truck \
    -m /workspace/output/truck \
    --iterations 30000 \
    --eval

Schnelles Training (Schnellvorschau)

python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene_fast \
    --iterations 7000

Das Training bis 7.000 Iterationen dauert auf einer RTX 4090 etwa 10 Minuten und liefert eine gute Qualitätsvorschau. Die vollen 30.000 Iterationen dauern etwa 30–40 Minuten und erzeugen die Endqualität.

Trainingsfortschritt

Beobachte die Trainingsausgabe — du wirst Metriken sehen wie:

[ITER 1000] Bewerte Training: L1 0.04, PSNR 26.12 dB
[ITER 7000] Bewerte Training: L1 0.02, PSNR 29.45 dB
[ITER 30000] Bewerte Training: L1 0.01, PSNR 32.80 dB

Ein PSNR über 30 dB weist auf eine hochwertige Rekonstruktion hin.

Schritt 6 — Rendern und Visualisieren

Aus dem trainierten Modell rendern

python render.py \
    -m /workspace/output/my_scene \
    --skip_train

Renderings werden gespeichert unter /workspace/output/my_scene/test/ours_30000/renders/.

Erstelle ein Flythrough-Video

# Gerenderte Frames in Video umwandeln
ffmpeg -framerate 24 \
    -pattern_type glob \
    -i '/workspace/output/my_scene/test/ours_30000/renders/*.png' \
    -c:v libx264 \
    -pix_fmt yuv420p \
    /workspace/output/flythrough.mp4

Metriken auswerten

python metrics.py -m /workspace/output/my_scene

Erwartete Ausgabe:

SSIM : 0.8324
PSNR : 32.81
LPIPS: 0.1893

Schritt 7 — Interaktiver Web-Viewer

Um die trainierte Szene interaktiv zu erkunden:

Mit nerfview/viser

# /workspace/view_splat.py
import viser
import numpy as np
from plyfile import PlyData
import torch

server = viser.ViserServer(host="0.0.0.0", port=8080)
print("Viewer läuft unter http://0.0.0.0:8080")

# PLY-Datei laden
ply_path = "/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply"
plydata = PlyData.read(ply_path)

xyz = np.stack([
    plydata['vertex']['x'],
    plydata['vertex']['y'],
    plydata['vertex']['z'],
], axis=-1)

# Punktwolke zum Viewer hinzufügen
server.add_point_cloud(
    name="/splat",
    points=xyz,
    colors=np.ones((len(xyz), 3)) * 0.7,
    point_size=0.003,
)

import time
while True:
    time.sleep(0.01)

python /workspace/view_splat.py &

Dann öffne: http://<clore-host>:<public-port-8080>

Alternative: SuperSplat verwenden (browserbasierter Viewer)

Lade die .ply Datei herunter und öffne sie in SuperSplat:

# Von deinem lokalen Rechner herunterladen
scp -P <port> root@<clore-host>:/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply ./

Ziehe dann die .ply im SuperSplat-Browser per Drag-and-drop hinein unter: https://playcanvas.com/super-splat

Erweiterte Optionen

Anzahl der Gaussians steuern

# Höhere Verdichtung für detailliertere Szenen
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --densify_until_iter 15000 \
    --densify_grad_threshold 0.0002

Weißer Hintergrund (für Objekte)

python train.py \
    -s /workspace/data/my_object \
    -m /workspace/output/my_object \
    --white_background

Große Szenen

# Opazitäts-Reset-Intervall für Außenaufnahmen erhöhen
python train.py \
    -s /workspace/data/outdoor \
    -m /workspace/output/outdoor \
    --opacity_reset_interval 5000 \
    --iterations 50000

Alternative: Gaussian Splatting mit gsplat

gsplat ist eine schnellere, speichereffiziente Implementierung:

pip install gsplat

# Training mit gsplat
python examples/simple_trainer.py \
    --data_dir /workspace/data/my_photos \
    --result_dir /workspace/gsplat_output

Fehlerbehebung

CUDA-Erweiterung-Build schlägt fehl

Fehler: Für die Ausführung auf dem Gerät ist kein Kernel-Image verfügbar

Lösung: Für deine spezifische GPU-Architektur neu bauen:

export TORCH_CUDA_ARCH_LIST="8.6"  # Für RTX 3090/4090
cd /workspace/gaussian-splatting
pip install submodules/diff-gaussian-rasterization --force-reinstall

COLMAP kann nicht rekonstruieren

Lösungen:

Stelle ≥ 50 % Bildüberlappung sicher
Verwende mehr Fotos (100+ empfohlen)
Versuche sequentielles Matching für Videoframes: füge --match sequential zu convert.py hinzu

Speicherfehler während des Trainings

# Maximale Anzahl der Gaussians reduzieren
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --max_num_splats 2000000  # Standard ist ~6M

Schwebende Artefakte in der Szene

Schwebende Artefakte durch Gaussian-Initialisierung:

Erhöhen Sie --densify_grad_threshold um selektiver zu sein
Verwende --prune_opacity_threshold 0.005 um Gaussians mit niedriger Opazität früher zu entfernen

GPU-Empfehlungen für Clore.ai

Das Training mit Gaussian Splatting ist GPU-Rechenintensiv mit häufigen CUDA-Kernel-Aufrufen. Der VRAM bestimmt die maximale Szenenkomplexität (Anzahl der Gaussians); die Rechenleistung bestimmt die Trainingsgeschwindigkeit.

GPU

VRAM

Clore.ai-Preis

30K-Iterationen-Training

Maximale Anzahl der Gaussians

RTX 3090

24 GB

ca. 0,07–0,21 $/h

~45–55 Min.

~6M

RTX 4090

24 GB

ca. 0,14–0,42 $/h

~30–35 Min.

~6M

A100 40GB

40 GB

Bare Metal

~12–18 Min.

~10M+

RTX 3080 12GB

12 GB

$0,05–0,19/Std.

~70 Min.

~3M (begrenzt)

RTX 3090 für 0,07–0,21 $/Std. ist die beste Wahl für Gaussian Splatting. Ein vollständiger Trainingslauf mit 30K Iterationen kostet etwa 0,09–0,11 $ an GPU-Zeit. Für mehrere Szenen in einer Sitzung sind die Kosten vernachlässigbar.

Für schnelle Experimente: zuerst auf 7.000 Iterationen trainieren (~15 Min. auf RTX 3090, ~0,03 $). Prüfe die Qualität im Web-Viewer. Führe die vollen 30K Iterationen nur für die finale Ausgabe aus.

Hinweis zur COLMAP-Vorverarbeitung: COLMAP (Structure from Motion) läuft auf CPU/GPU, aber die aufwändige Berechnung erfolgt auf der CPU. Die meisten Clore.ai-Server haben ausreichend CPUs für Szenen mit unter 200 Bildern. Für Datensätze mit 500+ Bildern suche nach Servern mit 16+ CPU-Kernen.

Nützliche Ressourcen

VorherigeNerfstudio

NächsteÜberblick

Zuletzt aktualisiert vor 1 Monat

War das hilfreich?