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

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

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

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

प्रारंभिककरण: एक विरल पॉइंट क्लाउड से शुरुआत करें (COLMAP से)
प्रतिनिधित्व: प्रत्येक बिंदु को स्थिति, स्केल, रोटेशन, अपारदर्शिता और स्फेरिकल हार्मोनिक्स रंग सहित एक 3D गॉसियन में विस्तारित करें
अनुकूलन: गॉसियन को डिफरेंशिएबल तरीके से रेंडर करें और प्रशिक्षण छवियों के विरुद्ध अनुकूलित करें
रेंडरिंग: ऐल्फा-कॉम्पोज़िटिंग के माध्यम से गॉसियन को इमेज प्लेन पर प्रोजेक्ट करें (अत्यंत तेज़)

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

12.8+

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

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

में लॉग इन करें clore.ai.
क्लिक करें मार्केटप्लेस और VRAM ≥ 16 GB के अनुसार फ़िल्टर करें।
एक सर्वर चुनें — RTX 4090 सर्वोत्तम मूल्य/प्रदर्शन देता है।
Docker image को अपने कस्टम image पर सेट करें (Step 2 देखें)।
ओपन पोर्ट सेट करें: 22 (SSH) और 8080 (वेब व्यूअर)।
क्लिक करें किराए पर लें.

स्टेप 2 — Dockerfile

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

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

# 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

# मूल 3DGS repo क्लोन करें
RUN git clone https://github.com/graphdeco-inria/gaussian-splatting /workspace/gaussian-splatting \\
    --recursive

# Python dependencies इंस्टॉल करें
RUN cd /workspace/gaussian-splatting && \\
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128 && \\
    pip install -r requirements.txt

# CUDA एक्सटेंशन बनाएँ
RUN cd /workspace/gaussian-splatting && \\
    pip install submodules/diff-gaussian-rasterization && \\
    pip install submodules/simple-knn

# वेब व्यूअर निर्भरताएँ इंस्टॉल करें
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 image नहीं है। graphdeco-inria/gaussian-splatting इसमें कोई image उपलब्ध नहीं है — ऊपर दिए गए Dockerfile से build करें। image को आपके लक्ष्य GPU से मेल खाते सही CUDA architecture flags के साथ build किया जाना चाहिए।

उपयोग करें 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

# छोटा टेस्ट दृश्य डाउनलोड करें
wget https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/datasets/input/tandt.zip
unzip tandt.zip

विकल्प B: अपनी खुद की तस्वीरों को प्रोसेस करें

# तस्वीरें अपलोड करें
scp -P <port> -r ./my_photos/ root@<clore-host>:/workspace/data/

# COLMAP प्रोसेसिंग स्क्रिप्ट चलाएँ (3DGS के साथ प्रदान की गई)
cd /workspace/gaussian-splatting

python convert.py \\
    -s /workspace/data/my_photos \\
    --no_gpu   # वैकल्पिक: यदि COLMAP GPU solver में टकराव हो

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

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

# वीडियो से 2fps पर फ्रेम निकालें
ffmpeg -i /workspace/data/my_video.mp4 \\
    -vf fps=2 \\
    /workspace/data/frames/frame_%04d.jpg

# फिर फ्रेम पर COLMAP प्रोसेसिंग चलाएँ
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

7000 iterations तक प्रशिक्षण RTX 4090 पर लगभग 10 मिनट लेता है और एक अच्छी गुणवत्ता वाला प्रीव्यू देता है। पूर्ण 30,000 iterations में लगभग 30–40 मिनट लगते हैं और अंतिम गुणवत्ता मिलती है।

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

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

[ITER 1000] ट्रेन का मूल्यांकन: L1 0.04, PSNR 26.12 dB
[ITER 7000] ट्रेन का मूल्यांकन: L1 0.02, PSNR 29.45 dB
[ITER 30000] ट्रेन का मूल्यांकन: 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/.

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

# रेंडर किए गए फ्रेम को वीडियो में बदलें
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 चल रहा है http://0.0.0.0:8080 पर")

# PLY फ़ाइल लोड करें
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)

# पॉइंट क्लाउड को व्यूअर में जोड़ें
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:

# अपनी लोकल मशीन से डाउनलोड करें
scp -P <port> root@<clore-host>:/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply ./

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

उन्नत विकल्प

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

# अधिक विस्तृत दृश्यों के लिए उच्च densification
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

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

# आउटडोर दृश्यों के लिए opacity reset interval बढ़ाएँ
python train.py \\
    -s /workspace/data/outdoor \\
    -m /workspace/output/outdoor \\
    --opacity_reset_interval 5000 \\
    --iterations 50000

विकल्प: gsplat के साथ गॉसियन स्प्लैटिंग

gsplat एक तेज़, मेमोरी-कुशल implementation है:

pip install gsplat

# gsplat के साथ प्रशिक्षण
python examples/simple_trainer.py \\
    --data_dir /workspace/data/my_photos \\
    --result_dir /workspace/gsplat_output

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

CUDA एक्सटेंशन का build विफल

error: इस डिवाइस पर निष्पादन के लिए कोई kernel image उपलब्ध नहीं है

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

export TORCH_CUDA_ARCH_LIST="8.6"  # RTX 3090/4090 के लिए
cd /workspace/gaussian-splatting
pip install submodules/diff-gaussian-rasterization --force-reinstall

COLMAP पुनर्निर्माण में विफल

समाधान:

≥ 50% इमेज ओवरलैप सुनिश्चित करें
अधिक तस्वीरों का उपयोग करें (100+ अनुशंसित)
वीडियो फ्रेम के लिए sequential matching आज़माएँ: जोड़ें --match sequential को convert.py में

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

# गॉसियन की अधिकतम संख्या कम करें
python train.py \\
    -s /workspace/data/my_photos \\
    -m /workspace/output/my_scene \\
    --max_num_splats 2000000  # डिफ़ॉल्ट लगभग 6M है

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

गॉसियन प्रारंभिककरण से उत्पन्न तैरते आर्टिफ़ैक्ट:

बढ़ाएँ --densify_grad_threshold को अधिक चयनात्मक बनाने के लिए
उपयोग करें --prune_opacity_threshold 0.005 कम-अपारदर्शिता वाले गॉसियन को पहले हटाने के लिए

Clore.ai GPU अनुशंसाएँ

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

GPU

VRAM

Clore.ai मूल्य

30K iter प्रशिक्षण

अधिकतम गॉसियन

RTX 3090

24 GB

$0.07–0.21/hr

~45–55 मिनट

~6M

RTX 4090

24 GB

$0.14–0.42/hr

~30–35 मिनट

~6M

A100 40GB

40 GB

bare metal

~12–18 मिनट

~10M+

RTX 3080 12GB

12 GB

$0.05–0.19/घंटा

~70 मिनट

~3M (सीमित)

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

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

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

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

पिछलाNerfstudio

अगलाअवलोकन

अंतिम अपडेट 1 माह पहले

क्या यह उपयोगी था?