> 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/gaussian-splatting.md). # 3D गॉसियन स्प्लैटिंग **3D गॉसियन स्प्लैटिंग** एक क्रांतिकारी रियल-टाइम 3D दृश्य पुनर्निर्माण तकनीक है, जिसके पास 15,000 से अधिक GitHub स्टार हैं **15,000 से अधिक GitHub स्टार**. NeRF-आधारित तरीकों के विपरीत, गॉसियन स्प्लैटिंग दृश्यों को लाखों छोटे 3D गॉसियन के रूप में प्रस्तुत करता है, जिन्हें **रियल-टाइम फ्रेम रेट** (100+ FPS) पर फोटोरियलिस्टिक गुणवत्ता हासिल करते हुए। इसे Clore.ai के GPU क्लाउड पर तैनात करें ताकि आप अपनी खुद की तस्वीरों से 3D दृश्यों को पुनर्निर्मित और अन्वेषण कर सकें। *** ## 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 | 12.8+ | 12.8+ | {% 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 image को अपने कस्टम image पर सेट करें (Step 2 देखें)। 5. ओपन पोर्ट सेट करें: `22` (SSH) और `8080` (वेब व्यूअर)। 6. क्लिक करें **किराए पर लें**. *** ## स्टेप 2 — Dockerfile सभी निर्भरताओं के साथ एक कस्टम Docker image बनाएँ: ```dockerfile 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` अपने वास्तविक उपयोगकर्ता नाम से): ```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 image नहीं है। [graphdeco-inria/gaussian-splatting](https://github.com/graphdeco-inria/gaussian-splatting) इसमें कोई image उपलब्ध नहीं है — ऊपर दिए गए Dockerfile से build करें। image को आपके लक्ष्य GPU से मेल खाते सही CUDA architecture flags के साथ build किया जाना चाहिए। {% endhint %} उपयोग करें `YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest` अपनी Clore.ai कॉन्फ़िगरेशन में। *** ## चरण 3 — SSH के माध्यम से कनेक्ट करें ```bash ssh root@ -p ``` बिल्ड सत्यापित करें: ```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 # छोटा टेस्ट दृश्य डाउनलोड करें wget https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/datasets/input/tandt.zip unzip tandt.zip ``` ### विकल्प B: अपनी खुद की तस्वीरों को प्रोसेस करें ```bash # तस्वीरें अपलोड करें scp -P -r ./my_photos/ root@:/workspace/data/ # COLMAP प्रोसेसिंग स्क्रिप्ट चलाएँ (3DGS के साथ प्रदान की गई) cd /workspace/gaussian-splatting python convert.py \\ -s /workspace/data/my_photos \\ --no_gpu # वैकल्पिक: यदि COLMAP GPU solver में टकराव हो ``` {% hint style="info" %} यह `convert.py` स्क्रिप्ट पूरी COLMAP पाइपलाइन चलाती है: फीचर एक्सट्रैक्शन, मैचिंग, स्पार्स पुनर्निर्माण, और अनडिस्टॉर्शन। यह इमेज की संख्या के आधार पर 5–30 मिनट लेता है। {% endhint %} ### विकल्प C: वीडियो से प्रोसेस करें ```bash # वीडियो से 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 — एक गॉसियन स्प्लैट को ट्रेन करें ### मानक प्रशिक्षण ```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" %} 7000 iterations तक प्रशिक्षण RTX 4090 पर लगभग 10 मिनट लेता है और एक अच्छी गुणवत्ता वाला प्रीव्यू देता है। पूर्ण 30,000 iterations में लगभग 30–40 मिनट लगते हैं और अंतिम गुणवत्ता मिलती है। {% endhint %} ### प्रशिक्षण प्रगति प्रशिक्षण आउटपुट मॉनिटर करें — आपको ऐसे मेट्रिक्स दिखेंगे जैसे: ``` [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 — रेंडर और विज़ुअलाइज़ करें ### प्रशिक्षित मॉडल से रेंडर करें ```bash python render.py \\ -m /workspace/output/my_scene \\ --skip_train ``` रेंडर यहाँ सहेजे जाते हैं `/workspace/output/my_scene/test/ours_30000/renders/`. ### एक फ्लाईथ्रू वीडियो बनाएँ ```bash # रेंडर किए गए फ्रेम को वीडियो में बदलें 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 चल रहा है 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) ``` ```bash python /workspace/view_splat.py & ``` फिर खोलें: `http://:` ### विकल्प: SuperSplat का उपयोग करें (ब्राउज़र-आधारित व्यूअर) डाउनलोड करें `.ply` फ़ाइल और इसे खोलें [SuperSplat](https://playcanvas.com/super-splat): ```bash # अपनी लोकल मशीन से डाउनलोड करें scp -P root@:/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply ./ ``` फिर `.ply` को SuperSplat ब्राउज़र में यहाँ ड्रैग-एंड-ड्रॉप करें: `https://playcanvas.com/super-splat` *** ## उन्नत विकल्प ### गॉसियन की संख्या नियंत्रित करें ```bash # अधिक विस्तृत दृश्यों के लिए उच्च densification 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 # आउटडोर दृश्यों के लिए opacity reset interval बढ़ाएँ python train.py \\ -s /workspace/data/outdoor \\ -m /workspace/output/outdoor \\ --opacity_reset_interval 5000 \\ --iterations 50000 ``` *** ## विकल्प: gsplat के साथ गॉसियन स्प्लैटिंग `gsplat` एक तेज़, मेमोरी-कुशल implementation है: ```bash 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 करें: ```bash 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 में ### प्रशिक्षण के दौरान मेमोरी समाप्त ```bash # गॉसियन की अधिकतम संख्या कम करें 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](https://clore.ai/bare-metal) | \~12–18 मिनट | \~10M+ | | RTX 3080 12GB | 12 GB | $0.05–0.19/घंटा | \~70 मिनट | \~3M (सीमित) | {% hint style="info" %} **$0.07–0.21/घंटा पर RTX 3090 सबसे अच्छा विकल्प है** गॉसियन स्प्लैटिंग के लिए। पूर्ण 30K iteration प्रशिक्षण रन में GPU समय में लगभग \~$0.09–0.11 खर्च होता है। एक सत्र में कई दृश्यों के लिए लागत नगण्य है। त्वरित प्रयोगों के लिए: पहले 7,000 iterations तक ट्रेन करें (RTX 3090 पर \~15 मिनट, \~$0.03)। वेब व्यूअर में गुणवत्ता जाँचें। अंतिम आउटपुट के लिए ही पूर्ण 30K iterations चलाएँ। {% endhint %} **COLMAP प्रीप्रोसेसिंग नोट:** COLMAP (Structure from Motion) CPU/GPU पर चलता है, लेकिन भारी compute 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 — तेज़ implementation](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/gaussian-splatting.md?ask=&goal= ``` `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.