3D गॉसियन स्प्लैटिंग

3D गॉसियन स्प्लैटिंग एक क्रांतिकारी रीयल-टाइम 3D दृश्य पुनर्निर्माण तकनीक है जिसके पास 15,000 से अधिक GitHub स्टार्स। NeRF-आधारित विधियों के विपरीत, गॉसियन स्प्लैटिंग दृश्यों का प्रतिनिधित्व लाखों छोटे 3D गॉसियनों के रूप में करता है जिन्हें रीयल-टाइम फ्रेम दरों पर (100+ FPS) रेंडर किया जा सकता है जबकि फोटोरियलिस्टिक गुणवत्ता प्राप्त करता है। अपने स्वयं के फ़ोटो से 3D दृश्य पुनर्निर्माण और अन्वेषण करने के लिए इसे Clore.ai के GPU क्लाउड पर तैनात करें।

---

3D गॉसियन स्प्लैटिंग क्या है?

पारंपरिक NeRF विधियाँ एक दृश्य को निहित रूप से एक न्यूरल नेटवर्क में एन्कोड करती हैं, जिसका रेंडर समय पर प्रति-पिक्सेल रे मार्चिंग की आवश्यकता होती है। गॉसियन स्प्लैटिंग एक मौलिक रूप से अलग दृष्टिकोण अपनाती है:

1. इनिशियलाइज़ेशन: एक विरल पॉइंट क्लाउड (COLMAP से) से प्रारंभ करें

2. प्रतिनिधित्व: प्रत्येक बिंदु को स्थिति, स्केल, रोटेशन, अपारदर्शिता और स्फेरिकल हार्मोनिक्स रंग के साथ एक 3D गॉसियन में विस्तारित करें

3. ऑप्टिमाइज़ेशन: गॉसियनों को भेद्य रूप से रेंडर करें और प्रशिक्षण छवियों के खिलाफ अनुकूलित करें

4. रेंडरिंग: गॉसियनों को अल्फा-कम्पोजिटिंग के माध्यम से इमेज प्लेन पर प्रोजेक्ट करें (बहुत तेज)

NeRF की तुलना में प्रमुख फायदे:

• रीयल-टाइम रेंडरिंग (1080p पर 100+ FPS)

• बेहतर सूक्ष्म विवरण पुनर्निर्माण

• स्पष्ट 3D प्रतिनिधित्व (संपादन योग्य, एक्सपोर्ट करने योग्य)

• तेज़ प्रशिक्षण (30–60 मिनट बनाम घंटों)

• कंज्यूमर GPU पर काम करता है

---

पूर्व-आवश्यकताएँ

आवश्यकता	न्यूनतम	अनुशंसित
GPU VRAM	12 GB	24 GB
GPU	RTX 3080 12GB	RTX 4090 / A100
RAM	16 GB	32 GB
स्टोरेज	30 GB	60 GB
CUDA	11.7+	12.1+

गॉसियन स्प्लैटिंग के सख्त CUDA आवश्यकताएँ हैं। CUDA संस्करण को diff-gaussian-rasterization कम्पाइल किए गए एक्सटेंशन से मेल खाना चाहिए। दिए गए Dockerfile का उपयोग करने से अनुकूलता समस्याएँ समाप्त हो जाती हैं।

---

चरण 1 — Clore.ai पर एक GPU किराए पर लें

1. लॉग इन करें clore.ai.

2. पर क्लिक करें मार्केटप्लेस और VRAM ≥ 16 GB द्वारा फ़िल्टर करें।

3. एक सर्वर चुनें — RTX 4090 सर्वोत्तम कीमत/प्रदर्शन प्रदान करता है।

4. Docker इमेज को अपने कस्टम इमेज पर सेट करें (स्टेप 2 देखें)।

5. खुले पोर्ट सेट करें: 22 (SSH) और 8080 (वेब व्यूअर)।

6. पर क्लिक करें किराए पर लें.

---

स्टेप 2 — Dockerfile

सभी निर्भरताओं के साथ एक कस्टम Docker इमेज बनाएं:

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/*

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

# SSH कॉन्फ़िगर करें
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

WORKDIR /workspace

# Clone original 3DGS repo
RUN git clone https://github.com/graphdeco-inria/gaussian-splatting /workspace/gaussian-splatting \
    --recursive

# Python निर्भरताएँ इंस्टॉल करें
RUN cd /workspace/gaussian-splatting && \
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 && \
    pip install -r requirements.txt

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

# Install web viewer dependencies
RUN pip install viser==0.1.29 nerfview==0.0.4 trimesh

EXPOSE 22 8080

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

बिल्ड और पुश करें

इमेज बनाकर इसे अपने Docker Hub अकाउंट पर पुश करें (हमें बदलें YOUR_DOCKERHUB_USERNAME अपने वास्तविक उपयोगकर्ता नाम से):

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

Docker Hub पर 3D Gaussian Splatting के लिए कोई आधिकारिक प्री-बिल्ट Docker इमेज नहीं है। आधिकारिक रिपॉजिटरी graphdeco-inria/gaussian-splatting एक प्रदान नहीं करता — ऊपर दिए गए Dockerfile से बिल्ड करें। इमेज को आपके लक्षित GPU से मेल खाने वाले सही CUDA आर्किटेक्चर फ़्लैग्स के साथ बनाया जाना चाहिए।

उपयोग करें YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest को अपनी Clore.ai कॉन्फ़िगरेशन में शामिल करें।

---

स्टेप 3 — SSH के जरिए कनेक्ट करें

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

बिल्ड सत्यापित करें:

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

---

स्टेप 4 — अपना डाटासेट तैयार करें

विकल्प A: Tandt (Tanks and Temples) डाटासेट का उपयोग करें

त्वरित परीक्षण के लिए क्लासिक बेंचमार्क डाटासेट:

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

# Download small test scene
wget https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/datasets/input/tandt.zip
unzip tandt.zip

विकल्प B: अपने स्वयं के फ़ोटो प्रोसेस करें

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

# Run COLMAP processing script (provided with 3DGS)
cd /workspace/gaussian-splatting

python convert.py \
    -s /workspace/data/my_photos \
    --no_gpu   # optional: if COLMAP GPU solver conflicts

The convert.py स्क्रिप्ट पूर्ण COLMAP पाइपलाइन चलाता है: फीचर एक्सट्रैक्शन, मैचिंग, विरल पुनर्निर्माण और अनडिस्टॉर्शन। यह इमेज की संख्या के आधार पर 5–30 मिनट लेता है।

विकल्प C: वीडियो से प्रोसेस करें

# Extract frames from video at 2fps
ffmpeg -i /workspace/data/my_video.mp4 \
    -vf fps=2 \
    /workspace/data/frames/frame_%04d.jpg

# Then run COLMAP processing on the frames
python convert.py -s /workspace/data/frames

---

स्टेप 5 — एक गॉसियन स्प्लाट ट्रेन करें

मानक प्रशिक्षण

cd /workspace/gaussian-splatting

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

Tandt डाटासेट पर प्रशिक्षण

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

तेज़ प्रशिक्षण (त्वरित प्रीव्यू)

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

7,000 इटरेशन्स तक प्रशिक्षण RTX 4090 पर ~10 मिनट लेता है और एक अच्छा गुणवत्ता पूर्वावलोकन देता है। पूरा 30,000 इटरेशन्स ~30–40 मिनट लेता है और अंतिम गुणवत्ता produce करता है।

प्रशिक्षण प्रगति

प्रशिक्षण आउटपुट मॉनिटर करें — आप निम्न मेट्रिक्स देखेंगे:

[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

30 dB से ऊपर PSNR उच्च-गुणवत्ता पुनर्निर्माण को दर्शाता है।

---

स्टेप 6 — रेंडर और विजुअलाइज़ करें

प्रशिक्षित मॉडल से रेंडर करें

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

रेंडर सेव किए जाते हैं: /workspace/output/my_scene/test/ours_30000/renders/.

फ्लाईथ्रू वीडियो बनाएं

# Convert rendered frames to video
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

मेट्रिक्स का मूल्यांकन करें

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

अपेक्षित आउटपुट:

SSIM : 0.8324
PSNR : 32.81
LPIPS: 0.1893

---

स्टेप 7 — इंटरैक्टिव वेब व्यूअर

प्रशिक्षित दृश्य को इंटरैक्टिव रूप से एक्सप्लोर करने के लिए:

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 running at http://0.0.0.0:8080")

# Load PLY file
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)

# Add point cloud to viewer
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 &

फिर खोलें: http://<clore-host>:<public-port-8080>

वैकल्पिक: SuperSplat (ब्राउज़र-आधारित व्यूअर) का उपयोग करें

डाउनलोड करें .ply फाइल और इसे खोलें SuperSplat:

# Download from your local machine
scp -P <port> root@<clore-host>:/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply ./

फिर SuperSplat ब्राउज़र में .ply को ड्रैग-एंड-ड्रॉप करें: https://playcanvas.com/super-splat

---

उन्नत विकल्प

गॉसियनों की संख्या नियंत्रित करें

# अधिक विस्तृत दृश्यों के लिए उच्च डेंसिफिकेशन
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --densify_until_iter 15000 \
    --densify_grad_threshold 0.0002

सफेद पृष्ठभूमि (वस्तुओं के लिए)

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

बड़े पैमाने के दृश्य

# बाहरी दृश्यों के लिए अपारदर्शिता रीसेट अंतराल बढ़ाएँ
python train.py \
    -s /workspace/data/outdoor \
    -m /workspace/output/outdoor \
    --opacity_reset_interval 5000 \
    --iterations 50000

---

वैकल्पिक: gsplat के साथ Gaussian Splatting

gsplat एक तेज़, मेमोरी-प्रभावी इम्प्लीमेंटेशन है:

pip install gsplat

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

---

समस्या निवारण

CUDA एक्सटेंशन बिल्ड फेल होता है

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

समाधान: अपने विशिष्ट GPU आर्किटेक्चर के लिए पुनःबिल्ड करें:

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

COLMAP पुनर्निर्माण में विफल होता है

समाधान:

• सुनिश्चित करें ≥ 50% इमेज ओवरलैप हो

• अधिक फ़ोटो का उपयोग करें (100+ अनुशंसित)

• वीडियो फ्रेम्स के लिए क्रमिक मिलान आज़माएँ: जोड़ें --match sequential convert.py में

प्रशिक्षण के दौरान मेमोरी खत्म होना

# अधिकतम गॉसियनों की संख्या कम करें
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --max_num_splats 2000000  # default is ~6M

दृश्य में फ्लोटर्स

गॉसियन इनिशियलाइज़ेशन से उत्पन्न तैरते हुए आर्टिफैक्ट्स:

• बढ़ाएँ --densify_grad_threshold अधिक चयनात्मक होने के लिए

• उपयोग करें --prune_opacity_threshold 0.005 कम-अपारदर्शिता गॉसियनों को पहले हटाने के लिए

---

Clore.ai GPU सिफारिशें

गॉसियन स्प्लैटिंग प्रशिक्षण GPU-कम्प्यूट गहन है जिसमें बार-बार CUDA कर्नल कॉल होते हैं। VRAM अधिकतम दृश्य जटिलता (गॉसियनों की संख्या) निर्धारित करता है; कम्प्यूट प्रशिक्षण गति निर्धारित करता है।

GPU	VRAM	Clore.ai कीमत	30K इटरेन प्रशिक्षण	अधिकतम गॉसियन्स
RTX 3090	24 GB	~$0.12/घंटा	~45–55 मिनट	~6M
RTX 4090	24 GB	~$0.70/घंटा	~30–35 मिनट	~6M
A100 40GB	40 GB	~$1.20/घंटा	~12–18 मिनट	~10M+
RTX 3080 12GB	12 GB	~$0.08/घंटा	~70 मिनट	~3M (सीमित)

RTX 3090 लगभग ~$0.12/घंटा पर गॉसियन स्प्लैटिंग के लिए सबसे अच्छा विकल्प है एक पूरा 30K इटरेशन प्रशिक्षण रन GPU समय में लगभग ~$0.09–0.11 का खर्च है। एक सत्र में कई दृश्यों के लिए, लागत नगण्य है।

त्वरित प्रयोगों के लिए: पहले 7,000 इटरेशन्स तक ट्रेन करें (~RTX 3090 पर ~15 मिनट, ~$0.03)। वेब व्यूअर में गुणवत्ता देखें। केवल अंतिम आउटपुट के लिए पूरा 30K इटरेशन्स चलाएँ।

COLMAP प्रीप्रोसेसिंग नोट: COLMAP (Structure from Motion) CPU/GPU पर चलता है लेकिन भारी कंप्यूटिंग CPU पर होती है। अधिकांश Clore.ai सर्वरों में 200 से कम इमेज वाले दृश्यों के लिए पर्याप्त CPU होते हैं। 500+ इमेज डाटासेट के लिए, 16+ CPU कोर वाले सर्वर देखें।

---

उपयोगी संसाधन

• 3D Gaussian Splatting GitHub

• मूल पेपर (SIGGRAPH 2023)

• gsplat — तेज इम्प्लीमेंटेशन

• SuperSplat — ब्राउज़र व्यूअर

• Gaussian Splatting समुदाय (Reddit)

• Awesome Gaussian Splatting