# Nerfstudio **Nerfstudio** एक मॉड्यूलर, शोधक-मैत्रीपूर्ण ढाँचा प्रशिक्षण और रेंडरिंग के लिए **न्यूरल रेडियंस फील्ड्स (NeRF)** — एक तकनीक जो 2D तस्वीरों से फोटोरियलिस्टिक 3D दृश्यों का पुनर्निर्माण करती है। 10,000 से अधिक GitHub स्टार्स के साथ, यह NeRF शोध और प्रोडक्शन एप्लिकेशनों के लिए डि फैक्टो मानक है। अपने स्वयं के फ़ोटो या वीडियो से 3D दृश्य पुनर्निर्मित करने के लिए इसे Clore.ai के GPU क्लाउड पर चलाएँ। *** ## Nerfstudio क्या है? NeRF (Neural Radiance Field) एक 3D दृश्य का प्रतिनिधित्व एक न्यूरल नेटवर्क के रूप में करता है जो कैमरा की स्थिति और दिशा दिए जाने पर उस बिंदु का रंग और घनत्व आउटपुट करता है। अलग-अलग कोणों से ली गई दर्जनों तस्वीरों पर प्रशिक्षण देकर, NeRF एक पूरा 3D प्रतिनिधित्व सीखता है जिसे किसी भी दृश्य बिंदु से रेंडर किया जा सकता है। **Nerfstudio प्रदान करता है:** * एकाधिक NeRF विधियाँ: Nerfacto, Instant-NGP, Splatfacto, TensoRF, और अन्य * CLI और Python API * पोर्ट 7007 पर इंटरैक्टिव वेब व्यूअर (Viser) * पॉइंट क्लाउड, मेश और वीडियो फ्लाइटथ्रू में निर्यात * COLMAP इंटीग्रेशन के माध्यम से कस्टम डेटासेट के लिए समर्थन **उपयोग के मामले:** * ड्रोन फुटेज से 3D दृश्य पुनर्निर्माण * फोटो से उत्पाद विज़ुअलाइज़ेशन * स्मार्टफोन कैप्चर से वर्चुअल टूर * नवीन व्यू सिंथेसिस में शोध *** ## पूर्व-आवश्यकताएँ | आवश्यकता | न्यूनतम | अनुशंसित | | -------- | -------- | --------------- | | GPU VRAM | 8 GB | 16–24 GB | | GPU | RTX 3080 | RTX 4090 / A100 | | RAM | 16 GB | 32 GB | | स्टोरेज | 20 GB | 50+ GB | | CUDA | 11.8+ | 12.1+ | {% hint style="info" %} प्रशिक्षण का समय दृश्य की जटिलता के साथ बढ़ता है। एक सामान्य बाहरी दृश्य जो 100 फोटो से लिया गया है, RTX 4090 पर 10–30 मिनट में ट्रेन होता है। इंटरैक्टिव व्यूअर प्रशिक्षण के दौरान रियल-टाइम में अपडेट होता है। {% endhint %} *** ## चरण 1 — Clore.ai पर एक GPU किराए पर लें 1. लॉग इन करें [clore.ai](https://clore.ai). 2. पर क्लिक करें **मार्केटप्लेस** और VRAM ≥ 16 GB द्वारा फ़िल्टर करें। 3. एक सर्वर चुनें — Nerfstudio के लिए RTX 4090 आदर्श है। 4. Docker इमेज सेट करें: **`dromni/nerfstudio:latest`** 5. खुले पोर्ट सेट करें: `22` (SSH) और `7007` (Viser वेब व्यूअर)। 6. पर क्लिक करें **किराए पर लें** और इंस्टेंस के इनिशियलाइज़ होने का इंतज़ार करें। {% hint style="info" %} The `dromni/nerfstudio` इमेज समुदाय-रक्षित आधिकारिक इमेज है और सभी निर्भरताएँ पहले से स्थापित (CUDA, tiny-cuda-nn, colmap, ffmpeg) शामिल करती है। {% endhint %} *** ## चरण 2 — SSH के द्वारा कनेक्ट करें ```bash ssh user@ -p ``` {% hint style="info" %} The `dromni/nerfstudio` इमेज उपयोग करता है `user` (नही `root`) डिफ़ॉल्ट रूप से। उपयोग करें `sudo` प्रशासनिक कार्यों के लिए। {% endhint %} इंस्टॉलेशन सत्यापित करें: ```bash ns-train --help ns-render --help ns-viewer --help ``` *** ## चरण 3 — अपना डेटासेट तैयार करें ### विकल्प A: प्रदत्त उदाहरण डेटासेट का उपयोग करें Nerfstudio तुरंत परीक्षण के लिए बिल्ट-इन डेटासेट शामिल करता है: ```bash # पोस्टर डेटासेट डाउनलोड करें (छोटा, परीक्षण के लिए अच्छा) ns-download-data nerfstudio --capture-name=poster # अन्य उपलब्ध डेटासेट: # ns-download-data nerfstudio --capture-name=egypt # ns-download-data nerfstudio --capture-name=floating-tree # ns-download-data nerfstudio --capture-name=stump ``` ### विकल्प B: अपनी खुद की छवियों को प्रोसेस करें यदि आपके पास अपने दृश्य की फोटो या वीडियो है: #### छवियों से (COLMAP पाइपलाइन): ```bash # अपनी छवियाँ SCP के माध्यम से अपलोड करें scp -P -r ./my_photos/ user@:/home/user/data/ # कैमरा पोज़ पाने के लिए COLMAP के साथ प्रोसेस करें ns-process-data images \ --data /home/user/data/my_photos \ --output-dir /home/user/data/my_scene ``` #### वीडियो से: ```bash # वीडियो अपलोड करें scp -P my_video.mp4 user@:/home/user/data/ # फ्रेम एक्सट्रैक्ट करें और प्रोसेस करें ns-process-data video \ --data /home/user/data/my_video.mp4 \ --output-dir /home/user/data/my_scene \ --num-frames-target 200 ``` {% hint style="info" %} सर्वोत्तम परिणामों के लिए, उपयोग करें **100–300 फ़ोटो** जिनमें पर्याप्त ओवरलैप हो (>60% आस-पास के फ्रेमों के बीच)। वस्तु/दृश्य के चारों ओर व्यवस्थित पैटर्न में चलें — सर्कल, ग्रिड या फ़िगर-एट्स अच्छी तरह काम करते हैं। {% endhint %} *** ## चरण 4 — एक NeRF ट्रेन करें ### बेसिक ट्रेनिंग Nerfacto के साथ (सिफारिश की गई) Nerfacto Nerfstudio की प्रमुख विधि है, जो गुणवत्ता और गति का संतुलन बनाती है: ```bash ns-train nerfacto \ --data /home/user/data/my_scene \ --viewer.websocket-port 7007 \ --output-dir /home/user/outputs ``` ### Instant-NGP के साथ ट्रेनिंग (सबसे तेज) ```bash ns-train instant-ngp \ --data /home/user/data/my_scene \ --viewer.websocket-port 7007 \ --output-dir /home/user/outputs ``` ### प्रदत्त पोस्टर डेटासेट के साथ ट्रेनिंग ```bash ns-train nerfacto \ --data /home/user/data/nerfstudio/poster \ --viewer.websocket-port 7007 ``` *** ## चरण 5 — इंटरैक्टिव व्यूअर तक पहुँचें अपने ब्राउज़र को खोलें और नेविगेट करें: ``` http://: ``` आप देखेंगे एक 3D व्यूअर जो संचालित है **Viser** जो दिखाता है: * लाइव ट्रेनिंग प्रगति * वर्तमान NeRF रेंडरिंग गुणवत्ता * इंटरैक्टिव कैमरा नियंत्रण * प्रशिक्षण लॉस वक्र {% hint style="info" %} व्यूअर प्रशिक्षण के दौरान हर कुछ सेकेंड में अपडेट होता है। आप दृश्य की गुणवत्ता का निरीक्षण करने के लिए घुमा, पैन और ज़ूम कर सकते हैं जब प्रशिक्षण प्रगति पर हो। {% endhint %} *** ## उपलब्ध प्रशिक्षण विधियाँ | विधि | गति | गुणवत्ता | VRAM | नोट्स | | -------------- | --------- | --------- | ----- | ----------------------- | | `nerfacto` | मध्यम | उच्च | 8 GB | सर्वोत्तम सर्व-आस्पेक्ट | | `instant-ngp` | तेज़ | मध्यम | 6 GB | सबसे तेज़ प्रशिक्षण | | `splatfacto` | तेज़ | उच्च | 8 GB | गौसियन स्प्लैटिंग | | `tensorf` | मध्यम | उच्च | 12 GB | वस्तुओं के लिए अच्छा | | `mipnerf360` | धीमा | बहुत उच्च | 24 GB | सबसे अच्छी गुणवत्ता | | `vanilla-nerf` | बहुत धीमा | उच्च | 16 GB | शोध बेसलाइन | ### Splatfacto (Gaussian Splatting) के साथ प्रशिक्षण ```bash ns-train splatfacto \ --data /home/user/data/my_scene \ --viewer.websocket-port 7007 \ --pipeline.model.num-random 50000 ``` *** ## चरण 6 — मूल्यांकन और रेंडर करें ### प्रशिक्षण मेट्रिक्स जांचें ```bash # प्रशिक्षण सारांश देखें ls /home/user/outputs/my_scene/nerfacto/ # नवीनतम चेकपॉइंट ls /home/user/outputs/my_scene/nerfacto/*/nerfstudio_models/ ``` ### एक वीडियो फ्लाइटथ्रू रेंडर करें ```bash # इंटरैक्टिव: व्यूअर में कैमरा पाथ सेट करें, फिर एक्सपोर्ट करें # कमांड-लाइन रेंडरिंग: ns-render camera-path \ --load-config /home/user/outputs/my_scene/nerfacto//config.yml \ --camera-path-filename /home/user/data/my_scene/camera_paths/my_path.json \ --output-path /home/user/renders/output.mp4 ``` ### इंटरपोलेटेड सर्पिल रेंडर करें ```bash ns-render interpolate \ --load-config /home/user/outputs/my_scene/nerfacto//config.yml \ --output-path /home/user/renders/spiral.mp4 \ --render-nearest-camera True \ --order-poses True ``` *** ## चरण 7 — 3D जेओमेट्री एक्सपोर्ट करें ### पॉइंट क्लाउड एक्सपोर्ट करें ```bash ns-export pointcloud \ --load-config /home/user/outputs/my_scene/nerfacto//config.yml \ --output-dir /home/user/exports/ \ --num-points 1000000 ``` ### मे��्श एक्सपोर्ट करें ```bash ns-export marching-cubes \ --load-config /home/user/outputs/my_scene/nerfacto//config.yml \ --output-dir /home/user/exports/ \ --resolution 1024 ``` ### Gaussian Splats (PLY) एक्सपोर्ट करें ```bash ns-export gaussian-splat \ --load-config /home/user/outputs/my_scene/splatfacto//config.yml \ --output-dir /home/user/exports/ ``` *** ## Python API प्रोग्रामेटिक ट्रेनिंग और मूल्यांकन के लिए: ```python from nerfstudio.scripts.train import main from nerfstudio.configs.base_config import ViewerConfig from nerfstudio.engine.trainer import TrainerConfig # Python API प्रशिक्षण उदाहरण from nerfstudio.configs.method_configs import method_configs from pathlib import Path config = method_configs["nerfacto"] config.pipeline.datamanager.data = Path("/home/user/data/my_scene") config.viewer = ViewerConfig(websocket_port=7007, num_rays_per_chunk=1<<15) config.max_num_iterations = 30000 trainer = config.setup() trainer.train() ``` *** ## कस्टम डेटासेट सुझाव ### कैमरा कैप्चर सर्वोत्तम प्रथाएँ | सेटिंग | सिफारिश | | ------ | --------------------------------- | | ओवरलैप | फ़्रेमों के बीच ≥ 60% | | छवियाँ | 100–300 (बाहरी), 50–150 (वस्तुएँ) | | गति | धीमी, स्थिर गति | | प्रकाश | सुसंगत, तेज़ छायाओं से बचें | | फ़ोकस | संपूर्ण रूप से तीक्ष्ण | ### COLMAP परिणामों को सुधारना ```bash # कठिन दृश्यों के लिए, exhaustive matching का उपयोग करें (धीमा लेकिन अधिक सटीक) ns-process-data images \ --data /home/user/data/my_photos \ --output-dir /home/user/data/my_scene \ --sfm-tool colmap \ --matching-method exhaustive ``` *** ## समस्या निवारण ### COLMAP कैमरा पोज़ नहीं ढूँढ पाता **समाधान:** * सुनिश्चित करें कि छवियों में पर्याप्त ओवरलैप हो * सत्यापित करें कि छवियाँ तीक्ष्ण हैं (कोई मोशन ब्लर नहीं) * exhaustive matching आज़माएँ: `--matching-method exhaustive` * कम करें `--num-frames-target` वीडियो के लिए बेहतर फ्रेम चुनने हेतु ### व्यूअर पहुँच योग्य नहीं **समाधान:** सुनिश्चित करें कि Clore.ai में पोर्ट 7007 फॉरवर्ड किया गया है। कनेक्टिविटी परीक्षण करें: ```bash ss -tlnp | grep 7007 ``` ### प्रशिक्षण लॉस कम नहीं हो रहा **समाधान:** * जांचें कि COLMAP सफल रहा (आउटपुट निर्देशिका में `transforms.json` को देखें) * लर्निंग रेट घटाएँ: `--pipeline.model.field-implementation hash` * प्रमुख आकाश होने की जाँच करें (उपयोग करें `--pipeline.model.background-color white`) ### मेमोरी समाप्त ```bash # बैच साइज कम करें ns-train nerfacto \ --data /home/user/data/my_scene \ --pipeline.datamanager.train-num-rays-per-batch 2048 \ --pipeline.datamanager.eval-num-rays-per-batch 1024 ``` *** ## आउटपुट डाउनलोड करें प्रशिक्षण के बाद, अपने रेंडर और एक्सपोर्ट डाउनलोड करें: ```bash # अपनी लोकल मशीन से scp -P -r user@:/home/user/renders/ ./local-renders/ scp -P -r user@:/home/user/exports/ ./local-exports/ ``` *** ## लागत अनुमान | GPU | VRAM | अनुमानित मूल्य | 100-छवि सीन | | --------- | ----- | -------------- | ------------ | | RTX 3080 | 10 GB | \~$0.10/घंटा | \~30–45 मिनट | | RTX 4090 | 24 GB | \~$0.35/घंटा | \~10–15 मिनट | | A100 40GB | 40 GB | \~$0.80/घंटा | \~5–8 मिनट | {% hint style="info" %} तेज़ प्रीव्यू के लिए Instant-NGP से शुरू करें, फिर अंतिम गुणवत्ता के लिए Nerfacto या MipNeRF360 पर स्विच करें। यह वर्कफ़्लो महत्वपूर्ण कंप्यूट लागत बचाता है। {% endhint %} *** ## उपयोगी संसाधन * [Nerfstudio GitHub](https://github.com/nerfstudio-project/nerfstudio) * [Nerfstudio दस्तावेज़ीकरण](https://docs.nerf.studio) * [dromni/nerfstudio Docker Hub](https://hub.docker.com/r/dromni/nerfstudio) * [Nerfstudio विधि तुलना](https://docs.nerf.studio/nerfology/methods/index.html) * [COLMAP दस्तावेज़ीकरण](https://colmap.github.io/) *** ## Clore.ai GPU सिफारिशें | उपयोग केस | सिफारिश की गई GPU | Clore.ai पर अनुमानित लागत | | ---------------------------- | ----------------- | ------------------------- | | डेवलपमेंट/टेस्टिंग | RTX 3090 (24GB) | \~$0.12/gpu/hr | | प्रोडक्शन | RTX 4090 (24GB) | \~$0.70/gpu/hr | | बड़े पैमाने / उच्च-रिज़ो सीन | A100 80GB | \~$1.20/gpu/hr | > 💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं [Clore.ai](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।