> 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/nerfstudio.md).

# 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 दृश्य पुनर्निर्माण
* फ़ोटो से उत्पाद विज़ुअलाइज़ेशन
* स्मार्टफोन कैप्चर से वर्चुअल टूर
* नवीन view synthesis पर शोध

***

## पूर्वापेक्षाएँ

| आवश्यकता | न्यूनतम  | अनुशंसित        |
| -------- | -------- | --------------- |
| GPU VRAM | 8 GB     | 16–24 GB        |
| GPU      | RTX 3080 | RTX 4090 / A100 |
| RAM      | 16 GB    | 32 GB           |
| स्टोरेज  | 20 GB    | 50+ GB          |
| CUDA     | 12.8+    | 12.8+           |

{% 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" %}
यह `dromni/nerfstudio` इमेज समुदाय-रक्षित आधिकारिक इमेज है और इसमें सभी निर्भरताएँ पहले से इंस्टॉल हैं (CUDA, tiny-cuda-nn, colmap, ffmpeg)।
{% endhint %}

***

## चरण 2 — SSH के माध्यम से कनेक्ट करें

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

{% hint style="info" %}
यह `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 <port> -r ./my_photos/ user@<clore-host>:/home/user/data/

# कैमरा पोज़ प्राप्त करने के लिए COLMAP के साथ प्रोसेस करें
ns-process-data images \
    --data /home/user/data/my_photos \
    --output-dir /home/user/data/my_scene
```

#### वीडियो से:

```bash
# वीडियो अपलोड करें
scp -P <port> my_video.mp4 user@<clore-host>:/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 — इंटरैक्टिव व्यूअर तक पहुँचें

अपना browser खोलें और यहाँ जाएँ:

```
http://<clore-host>:<public-port-7007>
```

आप एक 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/<timestamp>/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/<timestamp>/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/<timestamp>/config.yml \
    --output-dir /home/user/exports/ \
    --num-points 1000000
```

### मेश एक्सपोर्ट करें

```bash
ns-export marching-cubes \
    --load-config /home/user/outputs/my_scene/nerfacto/<timestamp>/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/<timestamp>/config.yml \
    --output-dir /home/user/exports/
```

***

## पायथन 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 कैमरा पोज़ ढूँढने में विफल

**समाधान:**

* सुनिश्चित करें कि छवियों में पर्याप्त ओवरलैप हो
* सत्यापित करें कि छवियाँ तीक्ष्ण हैं (कोई motion blur नहीं)
* 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 <port> -r user@<clore-host>:/home/user/renders/ ./local-renders/
scp -P <port> -r user@<clore-host>:/home/user/exports/ ./local-exports/
```

***

## लागत अनुमान

| GPU       | VRAM  | अनुमानित कीमत                             | 100-छवि वाला दृश्य |
| --------- | ----- | ----------------------------------------- | ------------------ |
| RTX 3080  | 10 GB | $0.05–0.19/घंटा                           | \~30–45 मिनट       |
| RTX 4090  | 24 GB | $0.14–0.42/hr                             | \~10–15 मिनट       |
| A100 40GB | 40 GB | [bare metal](https://clore.ai/bare-metal) | \~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.07–0.21/gpu/hr                         |
| प्रोडक्शन                            | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| बड़े पैमाने / उच्च-रिज़ॉल्यूशन दृश्य | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |

> 💡 इस गाइड के सभी उदाहरण [Clore.ai](https://clore.ai/marketplace) GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.


---

# 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/nerfstudio.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.