> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/3d-generation/gaussian-splatting.md).

# 3D Gaussian Splatting

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

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

***

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

1. लॉग इन करें [clore.ai](https://clore.ai).
2. पर क्लिक करें **मार्केटप्लेस** और VRAM ≥ 16 GB द्वारा फ़िल्टर करें।
3. एक सर्वर चुनें — RTX 4090 सर्वोत्तम कीमत/प्रदर्शन प्रदान करता है।
4. Docker इमेज को अपने कस्टम इमेज पर सेट करें (स्टेप 2 देखें)।
5. खुले पोर्ट सेट करें: `22` (SSH) और `8080` (वेब व्यूअर)।
6. पर क्लिक करें **किराए पर लें**.

***

## स्टेप 2 — Dockerfile

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

```dockerfile
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` अपने वास्तविक उपयोगकर्ता नाम से):

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

{% hint style="info" %}
Docker Hub पर 3D Gaussian Splatting के लिए कोई आधिकारिक प्री-बिल्ट Docker इमेज नहीं है। आधिकारिक रिपॉजिटरी [graphdeco-inria/gaussian-splatting](https://github.com/graphdeco-inria/gaussian-splatting) एक प्रदान नहीं करता — ऊपर दिए गए Dockerfile से बिल्ड करें। इमेज को आपके लक्षित GPU से मेल खाने वाले सही CUDA आर्किटेक्चर फ़्लैग्स के साथ बनाया जाना चाहिए।
{% endhint %}

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

***

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

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

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

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

***

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

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

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

```bash
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: अपने स्वयं के फ़ोटो प्रोसेस करें

```bash
# 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
```

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

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

```bash
# 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 — एक गॉसियन स्प्लाट ट्रेन करें

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

```bash
cd /workspace/gaussian-splatting

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

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

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

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

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

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

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

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

```
[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 — रेंडर और विजुअलाइज़ करें

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

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

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

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

```bash
# 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
```

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

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

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

```
SSIM : 0.8324
PSNR : 32.81
LPIPS: 0.1893
```

***

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

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

### nerfview/viser का उपयोग करते हुए

```python
# /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)
```

```bash
python /workspace/view_splat.py &
```

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

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

डाउनलोड करें `.ply` फाइल और इसे खोलें [SuperSplat](https://playcanvas.com/super-splat):

```bash
# 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`

***

## उन्नत विकल्प

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

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

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

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

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

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

***

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

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

```bash
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 आर्किटेक्चर के लिए पुनःबिल्ड करें:

```bash
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 में

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

```bash
# अधिकतम गॉसियनों की संख्या कम करें
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 (सीमित)    |

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

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

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

***

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

* [3D Gaussian Splatting GitHub](https://github.com/graphdeco-inria/gaussian-splatting)
* [मूल पेपर (SIGGRAPH 2023)](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/)
* [gsplat — तेज इम्प्लीमेंटेशन](https://github.com/nerfstudio-project/gsplat)
* [SuperSplat — ब्राउज़र व्यूअर](https://playcanvas.com/super-splat)
* [Gaussian Splatting समुदाय (Reddit)](https://www.reddit.com/r/gaussiansplatting/)
* [Awesome Gaussian Splatting](https://github.com/MrNeRF/awesome-3D-gaussian-splatting)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/3d-generation/gaussian-splatting.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.