> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/models/hi/supported-models/depth-anything-v2.md).

# Depth Anything V2

Depth Anything V2 एक मोनोक्युलर डेप्थ एस्टीमेशन मॉडल है। यह किसी भी इनपुट इमेज के लिए एक सामान्यीकृत डेप्थ मैप (0 और 1 के बीच मान) लौटाता है।

{% hint style="info" %}
Depth Anything V2 Serverless Hosted API पर उपलब्ध नहीं है। इसे एक पर चलाएँ [समर्पित डिप्लॉयमेंट](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) या [स्व-होस्टेड Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted).
{% endhint %}

## कोड सैंपल

{% stepper %}
{% step %}

### अपनी API कुंजी प्राप्त करें

एक Roboflow खाता बनाएँ, अपनी कुंजी यहाँ खोजें [Roboflow API सेटिंग्स पेज](https://app.roboflow.com/settings/api) और इसे अपने शेल में उपलब्ध कराएँ:

```bash
export ROBOFLOW_API_KEY="your-key-here"
```

{% endstep %}

{% step %}

### डिपेंडेंसीज़ इंस्टॉल करें

इंस्टॉल करें [Inference SDK](https://docs.roboflow.com/deployment/self-hosted/self-hosted):

```bash
pip install -U inference-sdk opencv-python supervision
```

{% endstep %}

{% step %}

### मॉडल चलाएँ

सेट करें `api_url` को अपने Dedicated Deployment URL या किसी लोकल Inference सर्वर पर सेट करें। यह स्क्रिप्ट डेप्थ मैप को रंगीन बनाती है और इनपुट के साथ एक साइड-बाय-साइड तुलना लिखती है।

```python
import os
import cv2
import numpy as np
import supervision as sv
from inference_sdk import InferenceHTTPClient

image = sv.load_image_from_url("https://media.roboflow.com/notebooks/examples/bicycle.png")
client = InferenceHTTPClient(
    api_url="https://your-deployment.roboflow.cloud",
    api_key=os.environ["ROBOFLOW_API_KEY"],
)
result = client.depth_estimation(image)

depth = np.array(result["normalized_depth"], dtype=np.float32)
depth = cv2.resize(depth, (image.shape[1], image.shape[0]))
depth_vis = (depth * 255).astype(np.uint8)
depth_color = cv2.applyColorMap(depth_vis, cv2.COLORMAP_INFERNO)

cv2.imwrite("depth_annotated.png", np.hstack([image, depth_color]))
```

<figure><img src="/files/7c18f5730acc2a076ef76f5f8f0a2b97ee35c327" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

## Inference गति

लेटेंसी मापी गई [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted) 1x NVIDIA L4, बैच आकार 1, वार्मअप के बाद औसत पर।

<table data-search="false"><thead><tr><th>मॉडल</th><th>लेटेंसी (ms)</th></tr></thead><tbody><tr><td><code>depth-anything-v2</code></td><td>40.1</td></tr></tbody></table>

Small checkpoint पर मापा गया।

{% hint style="info" %}
सेट करें `api_url` अपने डिप्लॉयमेंट लक्ष्य से मेल खाने के लिए:

* `http://localhost:9001` एक लोकल [Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted) सर्वर के लिए।
* आपका [समर्पित डिप्लॉयमेंट](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) एक निजी endpoint के लिए URL।
  {% endhint %}

## उपलब्ध मॉडल

डेप्थ एस्टीमेशन endpoint और `depth_estimation@v1` वर्कफ़्लो ब्लॉक एक ordinal-depth अनुबंध के पीछे दो मॉडल परिवारों को सेवा देते हैं: एक इमेज-आकार का मैप जो प्रत्येक इमेज के लिए सामान्यीकृत होता है, जहाँ `1.0` सबसे निकट है और `0.0` सबसे दूर है।

* **Depth Anything** (सापेक्ष गहराई): `depth-anything-v2/small`, `depth-anything-v3/small`, `depth-anything-v3/base`
* **YOLO26 depth** (मीट्रिक गहराई, इस पथ पर सामान्यीकृत, काफी तेज़): `yolo26n-depth-768`, `yolo26s-depth-768`, `yolo26m-depth-768`, `yolo26l-depth-768`, `yolo26x-depth-768`

साझा आउटपुट सभी मॉडलों में आकार, रेंज, और निकट-से-दूर क्रम को बनाए रखता है, लेकिन मध्यवर्ती मान मॉडल परिवारों के बीच ज्यामितीय रूप से समकक्ष नहीं होते। मान ordinal proximity scores हैं, भौतिक दूरियाँ नहीं, और उन्हें अलग-अलग छवियों या मॉडल परिवारों के बीच संख्यात्मक रूप से तुलना नहीं करनी चाहिए। YOLO26 checkpoints से मीटर में पूर्ण मीट्रिक गहराई के लिए, उन्हें सीधे यहाँ से लोड करें `inference_models.AutoModel`.

## रिस्पॉन्स फ़ॉर्मेट

यह `/infer/depth-estimation` endpoint सीरियलाइज़ करता है `normalized_depth` अनुरोध के `depth_map_format` फ़ील्ड के अनुसार:

* `json` (डिफ़ॉल्ट): 0 और 1 के बीच फ्लोट्स की एक नेस्टेड सूची। पुराने क्लाइंट्स के साथ wire-compatible, लेकिन 1080x810 इमेज के लिए लगभग 17 MB।
* `png16`: एक base64 16-बिट ग्रेस्केल PNG (quantization step 1/65535, आम तौर पर 10x से अधिक छोटा और सर्व करने में काफी तेज़)।
* `png8`: एक base64 8-बिट ग्रेस्केल PNG (256 गहराई स्तर, लगभग एक और क्रम से छोटा)। विज़ुअलाइज़ेशन और thresholding के लिए ठीक, derivative-आधारित ज्यामितीय उपयोग के लिए lossless नहीं।

SDK का `depth_estimation()` विधि डिफ़ॉल्ट रूप से `json`, इसलिए मौजूदा इंटीग्रेशन को नेस्टेड सूची मिलती रहेगी। पास करें `depth_map_format="png16"` (या `"png8"`) compact payload को अपनाने के लिए: SDK इसे वापस एक में डिकोड करता है `numpy.ndarray` (यदि आपको JSON-serializable आउटपुट चाहिए तो `.tolist()` कॉल करें)।

{% hint style="warning" %}
SDK का `json` डिफ़ॉल्ट अब deprecated है। 2027 के पहले Inference रिलीज़ में से एक में डिफ़ॉल्ट बदलकर `png16` संगतता तोड़ने वाले तरीके से, और `normalized_depth` तब इसे एक के रूप में लौटाया जाएगा `numpy.ndarray`। SDK एक `InferenceSDKDeprecationWarning` जब `json` format का उपयोग किया जाता है। जल्दी से अपनाएँ `png16` जल्दी, या पास करें `depth_map_format="json"` साफ़ तौर पर सूची फ़ॉर्मेट को स्विच के बाद बनाए रखने के लिए। Raw REST कॉलर्स अप्रभावित रहते हैं: सर्वर-साइड डिफ़ॉल्ट बना रहता है `json`.
{% endhint %}

## Inference (self-hosted) के साथ उपयोग करें

आप मॉडल को सीधे भी लोड कर सकते हैं [`inference`](https://docs.roboflow.com/deployment/self-hosted/self-hosted) पैकेज के साथ।

{% stepper %}
{% step %}

### पैकेज इंस्टॉल करें

```bash
pip install "inference[transformers]"
```

उपयोग करें `inference-gpu[transformers]` एक GPU मशीन पर।
{% endstep %}

{% step %}

### Hugging Face से प्रमाणित करें

वज़न Hugging Face से लिए जाते हैं, इसलिए एक [Hugging Face टोकन](https://huggingface.co/join):

```bash
export HUGGING_FACE_HUB_TOKEN=your_token_here
```

{% endstep %}

{% step %}

### मॉडल चलाएँ

```python
from PIL import Image

from inference.models.depth_estimation.depthestimation import DepthEstimator

model = DepthEstimator()

image = Image.open("your_image.jpg")
results = model.predict(image)

depth_map = results[0]["normalized_depth"]
visualization = results[0]["image"]
```

`normalized_depth` प्रति-छवि depth map को रखता है, और `image` एक रंगीन विज़ुअलाइज़ेशन रखता है, जहाँ हल्के रंग पास होते हैं और गहरे रंग दूर होते हैं।
{% endstep %}
{% endstepper %}

### वर्कफ़्लोज़ में निष्पादन मोड

जब इसे एक में उपयोग किया जाता है [वर्कफ़्लो](https://docs.roboflow.com/workflows), डेप्थ एस्टीमेशन दो मोड में से एक में चलता है:

* **लोकल निष्पादन**: मॉडल आपके Inference सर्वर पर चलता है (GPU अनुशंसित)।
* **रिमोट निष्पादन**: मॉडल को एक रिमोट Inference सर्वर पर HTTP के माध्यम से `depth_estimation()` क्लाइंट विधि।