> 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 Cloud API पर उपलब्ध नहीं है। इसे एक [डेडिकेटेड डिप्लॉयमेंट](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) या [स्व-होस्टेड Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted).
{% endhint %}

## Depth Anything V2 API

{% 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, InferenceConfiguration

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"],
).configure(InferenceConfiguration(api_key_transport="header"))
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 %}

## Depth Anything V2 अनुमान गति

लेटेंसी मापी गई [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 चेकपॉइंट पर मापा गया।

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

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

## Depth Anything V2 के उपलब्ध मॉडल

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

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

साझा आउटपुट मॉडल्स के बीच आकृति, दायरा, और निकट-से-दूर क्रम को बनाए रखता है, लेकिन मध्यवर्ती मान model families के बीच ज्यामितीय रूप से समतुल्य नहीं हैं। मान क्रमिक निकटता स्कोर हैं, भौतिक दूरियाँ नहीं, और उन्हें विभिन्न छवियों या model families के बीच संख्यात्मक रूप से तुलना नहीं करनी चाहिए। YOLO26 चेकपॉइंट्स से मीटर में पूर्ण metric depth के लिए, उन्हें सीधे `inference_models.AutoModel`.

## Depth Anything V2 के प्रतिक्रिया प्रारूप

यह `/infer/depth-estimation` endpoint serializes `normalized_depth` अनुरोध के `depth_map_format` फ़ील्ड:

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

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

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

## स्व-होस्टेड Inference के साथ Depth Anything V2 चलाएँ

आप मॉडल को सीधे के साथ भी लोड कर सकते हैं [`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 token](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` में प्रति-छवि डेप्थ मैप होता है, और `छवि` में एक रंगीन विज़ुअलाइज़ेशन होता है, जहाँ हल्के रंग अधिक निकट और गहरे रंग अधिक दूर होते हैं।
{% endstep %}
{% endstepper %}

### Workflows में निष्पादन मोड

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

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