3D-Gaussian-Splatting

3D Gaussian Splatting ist eine revolutionäre Echtzeit-3D-Szenenrekonstruktionsmethode mit über 15.000 GitHub-Sternen. Im Gegensatz zu NeRF-basierten Methoden stellt Gaussian Splatting Szenen als Millionen winziger 3D-Gaussfunktionen dar, die mit Echtzeit-Bildraten (100+ FPS) gerendert werden können und dabei photorealistische Qualität erreichen. Setzen Sie es auf Clore.ais GPU-Cloud ein, um 3D-Szenen aus Ihren 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 beim Rendern pro Pixel Ray-Marching. Gaussian Splatting verfolgt einen grundlegend anderen Ansatz:

1. Initialisierung: Beginnen Sie mit einer spärlichen Punktwolke (von COLMAP)

2. Darstellung: Erweitern Sie jeden Punkt zu einer 3D-Gaussfunktion mit Position, Skala, Rotation, Opazität und Farbinformationen in Kugelharmonischen

3. Optimierung: Differenzierbar Gaussfunktionen rendern und gegenüber Trainingsbildern optimieren

4. Rendering: Gaussfunktionen mittels Alpha-Komposition auf die Bildebene projizieren (extrem schnell)

Wesentliche Vorteile gegenüber NeRF:

• Echtzeit-Rendering (100+ FPS bei 1080p)

• Bessere Rekonstruktion feiner Details

• Explizite 3D-Darstellung (bearbeitbar, exportierbar)

• Schnelleres Training (30–60 Min statt Stunden)

• Funktioniert auf Consumer-GPUs

---

Voraussetzungen

Anforderung	Minimum	Empfohlen
GPU-VRAM	12 GB	24 GB
GPU	RTX 3080 12GB	RTX 4090 / A100
RAM	16 GB	32 GB
Speicher	30 GB	60 GB
CUDA	11.7+	12.1+

Gaussian Splatting hat strenge CUDA-Anforderungen. Die CUDA-Version muss mit der diff-gaussian-rasterization kompilierten Erweiterung übereinstimmen. Die Verwendung des bereitgestellten Dockerfiles beseitigt Kompatibilitätsprobleme.

---

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 — die RTX 4090 bietet das beste Preis-/Leistungsverhältnis.

4. Setzen Sie das Docker-Image auf Ihr benutzerdefiniertes Image (siehe Schritt 2).

5. Offene Ports festlegen: 22 (SSH) und 8080 (Web-Viewer).

6. Klicken Sie Mieten.

---

Schritt 2 — Dockerfile

Erstellen Sie ein benutzerdefiniertes Docker-Image mit allen Abhängigkeiten:

FROM pytorch/pytorch:2.1.2-cuda12.1-cudnn8-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/*

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

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

WORKDIR /workspace

# Originales 3DGS-Repository klonen
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/cu121 && \
    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 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

Build und Push

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 bietet keines an — bauen Sie es aus dem obigen Dockerfile. Das Image muss mit den korrekten CUDA-Architekturflags erstellt werden, die zu Ihrer Ziel-GPU passen.

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

---

Schritt 3 — Verbindung per SSH

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

Überprüfen Sie den Build:

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

---

Schritt 4 — Bereiten Sie Ihr Dataset vor

Option A: Verwenden Sie das Tandt (Tanks and Temples) Dataset

Klassisches Benchmark-Dataset für schnelle Tests:

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: Verarbeiten Sie Ihre eigenen Fotos

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

# Führen Sie das COLMAP-Verarbeitungsskript aus (mit 3DGS bereitgestellt)
cd /workspace/gaussian-splatting

python convert.py \
    -s /workspace/data/my_photos \
    --no_gpu   # optional: falls der COLMAP-GPU-Solver Konflikte verursacht

Der convert.py Das Skript führt die gesamte COLMAP-Pipeline aus: Merkmalserkennung, Matching, spärliche Rekonstruktion und Entzerrung. Das dauert je nach Bildanzahl 5–30 Minuten.

Option C: Verarbeitung aus Video

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

# Führen Sie dann die COLMAP-Verarbeitung für die Frames aus
python convert.py -s /workspace/data/frames

---

Schritt 5 — Trainieren Sie einen Gaussian Splat

Standardtraining

cd /workspace/gaussian-splatting

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

Training auf dem Tandt-Dataset

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

Training bis 7.000 Iterationen dauert ~10 Minuten auf einer RTX 4090 und liefert eine gute Vorschauqualität. Vollständige 30.000 Iterationen dauern ~30–40 Minuten und erzeugen die Endqualität.

Trainingsfortschritt

Überwachen Sie die Trainingsausgabe — Sie sehen Metriken wie:

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

PSNR über 30 dB deutet auf eine hochqualitative Rekonstruktion hin.

---

Schritt 6 — Rendern und Visualisieren

Aus trainiertem Modell rendern

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

Gerenderte Bilder werden gespeichert unter /workspace/output/my_scene/test/ours_30000/renders/.

Erstellen Sie ein Flythrough-Video

# Gerenderte Frames in Video konvertieren
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:

Verwendung von 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 &

Öffnen Sie dann: http://<clore-host>:<public-port-8080>

Alternative: Verwenden Sie SuperSplat (browserbasierter Viewer)

Laden Sie die .ply Datei herunter und öffnen Sie sie in SuperSplat:

# Herunterladen von Ihrem lokalen Rechner
scp -P <port> root@<clore-host>:/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply ./

Ziehen Sie dann per Drag & Drop die .ply in den SuperSplat-Browser unter: https://playcanvas.com/super-splat

---

Erweiterte Optionen

Anzahl der Gaussfunktionen 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 im Maßstab

# Erhöhen Sie das Intervall zum Zurücksetzen der Opazität für Außenaufnahmen
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-Erweiterungs-Build schlägt fehl

error: no kernel image is available for execution on the device

Lösung: Bauen Sie neu für Ihre spezifische GPU-Architektur:

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:

• Stellen Sie ≥ 50% Bildüberlappung sicher

• Verwenden Sie mehr Fotos (100+ empfohlen)

• Versuchen Sie sequentielles Matching für Video-Frames: fügen Sie --match sequential zu convert.py hinzu

Während des Trainings kein Speicher mehr

# Reduzieren Sie die maximale Anzahl der Gaussfunktionen
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 Gauss-Initialisierung:

• Erhöhen --densify_grad_threshold um selektiver zu sein

• Verwende --prune_opacity_threshold 0.005 um Gaussfunktionen mit geringer Opazität früher zu entfernen

---

Clore.ai GPU-Empfehlungen

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

GPU	VRAM	Clore.ai-Preis	30K-Iter-Training	Max. Gaussfunktionen
RTX 3090	24 GB	~$0.12/Stunde	~45–55 Min	~6M
RTX 4090	24 GB	~$0.70/Stunde	~30–35 Min	~6M
A100 40GB	40 GB	~$1.20/Stunde	~12–18 Min	~10M+
RTX 3080 12GB	12 GB	~$0.08/Stunde	~70 Min	~3M (begrenzt)

RTX 3090 zu ~$0.12/Stunde ist die beste Wahl für Gaussian Splatting. Ein vollständiger 30K-Iterationen-Trainingslauf kostet ~$0.09–0.11 an GPU-Zeit. Für mehrere Szenen in einer Sitzung sind die Kosten vernachlässigbar.

Für schnelle Experimente: trainieren Sie zunächst bis 7.000 Iterationen (~15 Min auf RTX 3090, ~$0.03). Prüfen Sie die Qualität im Web-Viewer. Führen Sie nur für das endgültige Ergebnis die vollen 30K Iterationen aus.

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

---

Nützliche Ressourcen

• 3D Gaussian Splatting GitHub

• Originalpaper (SIGGRAPH 2023)

• gsplat — schnelle Implementierung

• SuperSplat — Browser-Viewer

• Gaussian Splatting Community (Reddit)

• Awesome Gaussian Splatting