> 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/sam2.md).
# SAM2
हम Meta के [सेगमेंट एनीथिंग मॉडल 2](https://github.com/facebookresearch/sam2) हमारे माध्यम से इन्फरेंसिंग [सर्वरलेस क्लाउड API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api). SAM2 एक प्रॉम्प्ट-आधारित विज़ुअल सेगमेंटेशन मॉडल है जो बिंदुओं और बाउंडिंग बॉक्स को प्रॉम्प्ट के रूप में स्वीकार करता है। हम दो SAM2 एंडपॉइंट प्रदान करते हैं:
* `/sam2/embed_image`, जो एक इमेज एम्बेडिंग जनरेट और कैश करता है
* `/sam2/segment_image`, जो दिए गए प्रॉम्प्ट्स के लिए इंस्टेंस सेगमेंटेशन मास्क लौटाता है
## SAM2 API
SAM2 को HTTP एंडपॉइंट के माध्यम से सीधे इस तरह चलाएँ: `curl`या साथ में [`inference-sdk`](https://docs.roboflow.com/reference/inference/inference-sdk) रैपर।
{% tabs %}
{% tab title="HTTP (curl)" icon="webhook" %}
{% stepper %}
{% step %}
### अपनी API कुंजी प्राप्त करें
एक Roboflow खाता बनाएँ, अपनी कुंजी यहाँ खोजें [Roboflow API सेटिंग्स पेज](https://app.roboflow.com/settings/api) और इसे अपने शेल में उपलब्ध कराएँ:
```bash
export ROBOFLOW_API_KEY="your-key-here"
```
{% endstep %}
{% step %}
### मॉडल चलाएँ
कॉल करें `/sam2/segment_image` एंडपॉइंट के साथ `curl`:
```bash
curl --location 'https://serverless.roboflow.com/sam2/segment_image' \
--header 'Content-Type: application/json' \\
--header "Authorization: Bearer $ROBOFLOW_API_KEY" \\
--data '{
"image": {"type": "url", "value": "https://media.roboflow.com/quickstart/traffic.jpg"},
"prompts": {"prompts": [{"points": [{"x": 520, "y": 470, "positive": true}]}]},
"sam2_version_id": "hiera_tiny"
}'
```
{% endstep %}
{% endstepper %}
{% endtab %}
{% tab title="SDK (Python)" icon="python" %}
{% stepper %}
{% step %}
### अपनी API कुंजी प्राप्त करें
एक Roboflow खाता बनाएँ, अपनी कुंजी यहाँ खोजें [Roboflow API सेटिंग्स पेज](https://app.roboflow.com/settings/api) और इसे अपने शेल में उपलब्ध कराएँ:
```bash
export ROBOFLOW_API_KEY="your-key-here"
```
{% endstep %}
{% step %}
### निर्भरताएँ इंस्टॉल करें
ये पैकेज मॉडल को कॉल करते हैं और उसके परिणामों को ड्रॉ करते हैं:
```bash
pip install -U inference-sdk supervision opencv-python
```
{% endstep %}
{% step %}
### मॉडल चलाएँ
एकल सकारात्मक बिंदु प्रॉम्प्ट के साथ सेगमेंटेशन एंडपॉइंट को कॉल करें, लौटाए गए बहुभुजों को supervision के साथ डिटेक्शन्स में बदलें, और इनपुट इमेज पर मास्क ड्रॉ करके एक एनोटेटेड PNG सहेजें:
```python
import os
import cv2
import supervision as sv
from inference_sdk import InferenceHTTPClient, InferenceConfiguration
image = sv.load_image_from_url("https://media.roboflow.com/quickstart/traffic.jpg")
height, width = image.shape[:2]
client = InferenceHTTPClient(
api_url="https://serverless.roboflow.com",
api_key=os.environ["ROBOFLOW_API_KEY"],
).configure(InferenceConfiguration(api_key_transport="header"))
result = client.sam2_segment_image(
inference_input=image,
prompts=[
{"points": [{"x": 520, "y": 470, "positive": True}]}
],
sam2_version_id="hiera_tiny",
)
detections = sv.Detections.from_sam3(sam3_result=result, resolution_wh=(width, height))
annotated = sv.MaskAnnotator().annotate(image.copy(), detections)
cv2.imwrite("traffic_annotated.png", annotated)
```
`sv.Detections.from_sam3` यह उन बहुभुज भविष्यवाणियों को पढ़ता है जो SAM2 और SAM3 दोनों लौटाते हैं, इसलिए वही कॉल किसी भी मॉडल के आउटपुट को डिकोड करती है।
{% endstep %}
{% endstepper %}
{% endtab %}
{% endtabs %}
## SAM2 इन्फरेंस गति
लेटेंसी मापी गई [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted) 1x NVIDIA L4 पर, बैच आकार 1 के साथ, वार्मअप के बाद औसत।
मॉडल
लेटेंसी (ms)
sam2
177.7
के साथ मापा गया `segment_image` पर `hiera_large` चेकपॉइंट। SAM2 इमेज एम्बेडिंग्स को कैश करता है, इसलिए यह चित्र हर कॉल पर एक नई इमेज का उपयोग करता है और पूर्ण एन्कोड तथा डिकोड लागत को दर्शाता है। पहले से एन्कोड की गई इमेज को फिर से प्रॉम्प्ट करना काफी तेज़ होता है।
{% hint style="info" %}
सेट करें `api_url` को अपने परिनियोजन लक्ष्य से मिलाएँ:
* `https://serverless.roboflow.com` सर्वरलेस क्लाउड API के लिए।
* `http://localhost:9001` एक स्थानीय [इन्फ़रेंस](https://docs.roboflow.com/deployment/self-hosted/self-hosted) सर्वर।
* आपका [समर्पित परिनियोजन](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) एक निजी एंडपॉइंट के लिए URL.
{% endhint %}
एंबेडिंग कैशिंग और बॉक्स प्रॉम्प्ट्स सहित अतिरिक्त उपयोग विवरण के लिए देखें [इनफ़रेंस दस्तावेज़ीकरण](https://docs.roboflow.com/deployment/self-hosted/self-hosted).
## स्व-होस्टेड Inference के साथ SAM2 चलाएँ
SAM2 को सीधे इस के साथ भी लोड किया जा सकता है [`inference`](https://docs.roboflow.com/deployment/self-hosted/self-hosted) पैकेज, या इसे आपके द्वारा चलाए गए GPU कंटेनर से सर्व किया जा सकता है। यह सही तरीका है जब आप इमेजों को अपने हार्डवेयर पर रखना चाहते हैं, या जब आप उसी इमेज को कई बार फिर से प्रॉम्प्ट कर रहे हों।
### Docker में चलाएँ
के रूट से SAM2 इमेज बनाइए [Inference रिपॉज़िटरी](https://github.com/roboflow/inference):
```bash
docker build -f docker/dockerfiles/Dockerfile.sam2 -t sam2 .
```
फिर एक सर्वर शुरू करें जो SAM2 एंडपॉइंट्स उपलब्ध कराता हो:
```bash
docker run -it --rm -v /tmp/cache/:/tmp/cache/ --gpus=all --net=host sam2
```
इशारा करें `api_url` उस सर्वर की ओर (`http://localhost:9001`) और ऊपर दिए गए कोड उदाहरण बिना किसी बदलाव के काम करते हैं।
{% hint style="warning" %}
फ्लैश अटेंशन के साथ SAM2 में [एक ज्ञात समस्या](https://github.com/facebookresearch/sam2/issues/48) कुछ GPUs, जिनमें L4 और A100 शामिल हैं, पर। उस थ्रेड से समाधान लागू करें, या ऊपर दिया गया Docker इमेज उपयोग करें, जो इसे पहले से संभालता है।
{% endhint %}
### Python में मॉडल लोड करें
```python
import os
os.environ["API_KEY"] = "YOUR_API_KEY"
from inference.core.entities.requests.sam2 import Sam2PromptSet
from inference.core.utils.postprocess import masks2poly
from inference.models.sam2 import SegmentAnything2
model = SegmentAnything2(model_id="sam2/hiera_large")
image_path = "./hand.png"
# इमेज एम्बेडिंग को पहले से गणना करके कैश करें
embedding, img_shape, image_id = model.embed_image(image_path)
# कैश की गई एम्बेडिंग का उपयोग करके सेगमेंट करें
raw_masks, raw_low_res_masks = model.segment_image(image_path)
raw_masks = raw_masks >= model.predictor.mask_threshold
poly_masks = masks2poly(raw_masks)
```
एम्बेडिंग्स स्वचालित रूप से कैश हो जाती हैं, इसलिए जैसे ही आपको पता चले कि आपको इमेज की ज़रूरत होगी, आप उसे एम्बेड कर सकते हैं और बाद में कम लागत पर फिर से प्रॉम्प्ट कर सकते हैं।
किसी मास्क को परिष्कृत करने के लिए, एक नकारात्मक बिंदु भेजें (`"positive": False`) ताकि किसी क्षेत्र को बाहर किया जा सके:
```python
prompt = Sam2PromptSet(
prompts=[{"points": [{"x": 250, "y": 800, "positive": False}]}]
)
refined_masks, refined_low_res_masks = model.segment_image(image_path, prompts=prompt)
refined_masks = refined_masks >= model.predictor.mask_threshold
```
उपलब्ध `model_id` मान: `sam2/hiera_tiny`, `sam2/hiera_small`, `sam2/hiera_b_plus`, `sam2/hiera_large`.
## Workflows में SAM2 वीडियो ट्रैकिंग
यह **SAM2 वीडियो ट्रैकर** ब्लॉक (`roboflow_core/segment_anything_2_video@v1`) SAM2 के स्ट्रीमिंग वीडियो प्रेडिक्टर को फ्रेम दर फ्रेम चलाता है, और प्रति-वीडियो टाइमपोरल मेमोरी बनाए रखता है ताकि ऑब्जेक्ट की पहचान फ्रेमों के बीच बनी रहे। इसमें किसी अपस्ट्रीम डिटेक्टर से बाउंडिंग बॉक्स दें: यह हर बॉक्स को मास्क में बदलता है और उसे अगले फ्रेमों में ट्रैक करता है, तथा ऐसी सेगमेंटेशन भविष्यवाणियाँ जारी करता है जिनकी `tracker_id` जब तक SAM2 ऑब्जेक्ट को फॉलो करता है, तब तक यह स्थिर रहता है। मास्क उस डिटेक्शन का क्लास नाम, क्लास आईडी, और कॉन्फिडेंस अपनाते हैं जिसने उन्हें प्रॉम्प्ट किया था।
* **स्टेटफुल और केवल लोकल।** यह ब्लॉक प्रति `video_metadata.video_identifier`, एक ट्रैकिंग सेशन रखता है, इसलिए यह कई स्ट्रीम्स को मल्टीप्लेक्स कर सकता है, लेकिन सेशन प्रोसेस मेमोरी में रहता है। इसके लिए आवश्यक है `WORKFLOWS_STEP_EXECUTION_MODE=local`, एक GPU, और एक स्थायी WebRTC सेशन। यह अलग-अलग stateless HTTP अनुरोधों के लिए उपयुक्त नहीं है।
* **प्रॉम्प्ट शेड्यूलिंग।** `prompt_mode` यह नियंत्रित करता है कि डिटेक्टर बॉक्स कब प्रॉम्प्ट के रूप में उपयोग किए जाएँ: `first_frame` (डिफ़ॉल्ट) प्रति सेशन एक बार प्रॉम्प्ट करता है, फिर चुपचाप ट्रैक करता है; `every_n_frames` हर `prompt_interval` फ्रेमों पर फिर से बीजित करता है, जिससे दृश्य में आए ऑब्जेक्ट्स पकड़े जा सकें; `every_frame` हर फ्रेम पर फिर से बीजित करता है, और स्थिर ट्रैकर आईडी के साथ प्रति-फ्रेम डिटेक्शन-से-मास्क एडाप्टर की तरह काम करता है।
* **मॉडल वेरिएंट्स।** `model_id` Hiera बैकबोन चुनता है: `sam2video/tiny`, `sam2video/small` (डिफ़ॉल्ट), `sam2video/base-plus`, `sam2video/large`। यह ब्लॉक यह भी स्वीकार करता है `sam3trackervideo`, SAM3 का विज़ुअली प्रॉम्प्टेड ट्रैकर, जो बहुत बड़े बैकबोन के साथ वही बॉक्स-प्रॉम्प्ट अनुबंध उपयोग करता है। यह लंबे वीडियो और भीड़भाड़ वाले दृश्यों में पहचान को बेहतर बनाए रखता है, लेकिन इसकी गणनागत लागत अधिक होती है: इसे अधिकतम-गुणवत्ता स्तर मानें और `sam2video` आकारों को गति स्तरों के रूप में देखें।
```python
from inference_sdk import InferenceHTTPClient
from inference_sdk.webrtc import StreamConfig, VideoFileSource
WORKFLOW = {
"version": "1.0",
"inputs": [{"type": "InferenceImage", "name": "image"}],
"steps": [
{
"type": "roboflow_core/roboflow_object_detection_model@v2",
"name": "detector",
"images": "$inputs.image",
"model_id": "yolov8n-640",
},
{
"type": "roboflow_core/segment_anything_2_video@v1",
"name": "tracker",
"images": "$inputs.image",
"boxes": "$steps.detector.predictions",
"prompt_mode": "every_n_frames",
"prompt_interval": 30,
},
],
"outputs": [
{
"type": "JsonField",
"name": "predictions",
"selector": "$steps.tracker.predictions",
}
],
}
client = InferenceHTTPClient(
api_url="http://localhost:9001",
api_key="YOUR_API_KEY",
)
session = client.webrtc.stream(
source=VideoFileSource("path/to/video.mp4"),
workflow=WORKFLOW,
config=StreamConfig(data_output=["predictions"]),
)
@session.on_data("predictions")
def handle_predictions(predictions, metadata):
print(predictions)
session.run()
```
बिना किसी अपस्ट्रीम डिटेक्टर के, टेक्स्ट प्रॉम्प्ट्स से open-vocabulary वीडियो ट्रैकिंग के लिए, देखें [SAM3 पेज](/models/hi/supported-models/sam3.md).
### Workflows में निष्पादन मोड
जब इमेज वर्कफ़्लो में उपयोग किया जाता है, SAM2 दो में से एक मोड में चलता है:
* **स्थानीय निष्पादन**: मॉडल आपके Inference सर्वर पर चलता है (GPU की कड़ी सिफारिश की जाती है)।
* **दूरस्थ निष्पादन**: मॉडल को दूरस्थ Inference सर्वर पर HTTP के माध्यम से `sam2_segment_image()` क्लाइंट मेथड।
## यह भी देखें
* [SAM3](/models/hi/supported-models/sam3.md) - टेक्स्ट प्रॉम्प्ट से किसी अवधारणा के हर इंस्टेंस को सेगमेंट करता है।
* [Segment Anything (SAM)](/models/hi/supported-models/sam.md) - मूल सिंगल-ऑब्जेक्ट मॉडल।