Depth Anything V2

Dedicated Deployment या self-hosted Inference पर मोनोक्युलर डेप्थ एस्टीमेशन के लिए Depth Anything V2 का उपयोग करें

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

Depth Anything V2 Serverless Cloud API पर उपलब्ध नहीं है। इसे एक समर्पित डिप्लॉयमेंट या स्व-होस्टेड Inference.

कोड उदाहरण

1

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

एक Roboflow खाता बनाएँ, अपनी कुंजी यहाँ खोजें Roboflow API सेटिंग्स पेज और इसे अपने शेल में उपलब्ध कराएँ:

export ROBOFLOW_API_KEY="your-key-here"

2

निर्भरताओं को इंस्टॉल करें

इंस्टॉल करें Inference SDK:

pip install -U inference-sdk opencv-python supervision

3

मॉडल चलाएँ

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

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]))

इन्फरेंस गति

लेटेंसी मापी गई Roboflow Inference के साथ 1x NVIDIA L4 पर, बैच आकार 1, वार्मअप के बाद औसत।

मॉडल	लेटेंसी (ms)
depth-anything-v2	40.1

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

सेट करें api_url अपने डिप्लॉयमेंट लक्ष्य से मेल कराने के लिए:

• http://localhost:9001 एक स्थानीय इन्फरेंस सर्वर के लिए।

• आपका समर्पित डिप्लॉयमेंट एक निजी एंडपॉइंट के लिए URL।

उपलब्ध मॉडल

डेप्थ एस्टीमेशन endpoint और depth_estimation@v1 Workflow block एक ही ordinal-depth contract के पीछे दो model families को सर्व करता है: एक image-sized map जो प्रति इमेज normalized है, जहाँ 1.0 निकटतम है और 0.0 सबसे दूर है।

• Depth Anything (relative depth): depth-anything-v2/small, depth-anything-v3/small, depth-anything-v3/base

• YOLO26 डेप्थ (metric depth, इस पथ पर normalized, काफी तेज़): yolo26n-depth-768, yolo26s-depth-768, yolo26m-depth-768, yolo26l-depth-768, yolo26x-depth-768

साझा आउटपुट सभी मॉडलों में shape, range, और near-to-far ordering को बनाए रखता है, लेकिन मध्यवर्ती मान model families के बीच ज्यामितीय रूप से समतुल्य नहीं होते। मान ordinal proximity scores हैं, भौतिक दूरी नहीं, और उन्हें अलग-अलग images या model families के बीच संख्यात्मक रूप से तुलना नहीं करनी चाहिए। YOLO26 checkpoints से meters में absolute metric depth के लिए, उन्हें सीधे inference_models.AutoModel.

प्रतिक्रिया प्रारूप

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

• json (डिफ़ॉल्ट): 0 और 1 के बीच के floats की एक नेस्टेड सूची। पुराने क्लाइंट्स के साथ wire-compatible, लेकिन 1080x810 image के लिए लगभग 17 MB।

• png16: 16-बिट ग्रेस्केल PNG का base64 (quantization step 1/65535, आमतौर पर 10x से अधिक छोटा और सर्व करने में बहुत तेज़)।

• png8: 8-बिट ग्रेस्केल PNG का base64 (256 depth levels, लगभग एक और क्रम छोटा)। विज़ुअलाइज़ेशन और thresholding के लिए ठीक, derivative-based geometric उपयोग के लिए lossy।

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

SDK का json डिफ़ॉल्ट अब deprecated है। 2027 के शुरुआती Inference releases में से एक में डिफ़ॉल्ट संगतता तोड़ने वाले तरीके से बदलकर png16 संगतता तोड़ने वाले तरीके से, और normalized_depth तब इसे एक numpy.ndarray. SDK एक InferenceSDKDeprecationWarning जब json फ़ॉर्मेट का उपयोग किया जाता है। जल्दी से opt in करें, या png16 जल्दी, या पास करें depth_map_format="json" स्पष्ट रूप से ताकि स्विच के बाद सूची प्रारूप बना रहे। Raw REST callers अप्रभावित रहते हैं: server-side डिफ़ॉल्ट बना रहता है json.

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

आप मॉडल को सीधे inference पैकेज के साथ भी लोड कर सकते हैं।

1

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

pip install "inference[transformers]"

इस्तेमाल करें inference-gpu[transformers] एक GPU मशीन पर।

2

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

वेट्स Hugging Face से लिए जाते हैं, इसलिए एक Hugging Face टोकन:

export HUGGING_FACE_HUB_TOKEN=your_token_here

3

मॉडल चलाएँ

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 में प्रति-इमेज डेप्थ मैप होता है, और इमेज में एक कलराइज़्ड विज़ुअलाइज़ेशन होता है, जहाँ हल्के रंग निकट होते हैं और गहरे रंग दूर होते हैं।

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

जब किसी Workflowमें उपयोग किया जाता है, तो डेप्थ एस्टीमेशन दो मोड में से एक में चलता है:

• स्थानीय निष्पादन: मॉडल आपके Inference सर्वर पर चलता है (GPU अनुशंसित)।

• दूरस्थ निष्पादन: मॉडल को दूरस्थ Inference सर्वर पर HTTP के माध्यम से depth_estimation() क्लाइंट मेथड के माध्यम से कॉल किया जाता है।