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

# SAM3

हमारे सर्वरलेस क्लाउड API के माध्यम से Meta के SAM3 मॉडल का उपयोग करें

हम Meta के [सेगमेंट एनीथिंग मॉडल 3](https://github.com/facebookresearch/sam3) पर इनफ़रेंसिंग हमारी [Serverless Cloud API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api). हम दो अलग-अलग SAM3 एंडपॉइंट प्रदान करते हैं:

{% hint style="info" %}
Roboflow पर SAM3 मॉडल का प्रशिक्षण केवल सशुल्क [प्लानों](https://docs.roboflow.com/platform/billing-and-plans#plans) में उपलब्ध है, जिनमें [उपयोग-आधारित बिलिंग](https://docs.roboflow.com/platform/billing-and-plans#credits) शामिल है। वहाँ से, आप सुविधा का उपयोग करने के लिए SAM3 आर्किटेक्चर पर "Request Feature" बटन के साथ एक्सेस का अनुरोध कर सकते हैं [प्रशिक्षण प्रवाह](https://docs.roboflow.com/models/hi/readme.md).

फाइन-ट्यून किए गए SAM3 मॉडल Serverless Cloud API पर नहीं चल सकते। उन्हें परिनियोजित करें [समर्पित परिनियोजन](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) या [सेल्फ-होस्टेड Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted) पर। होस्ट किए गए `sam3` इस पृष्ठ के एंडपॉइंट प्रभावित नहीं होते।
{% endhint %}

* [प्रॉम्प्टेबल कॉन्सेप्ट सेगमेंटेशन](#sam3-concept-segmentation-pcs) (**PCS**), जो चित्र में किसी कॉन्सेप्ट के हर उदाहरण को सेगमेंट करता है। कॉन्सेप्ट को टेक्स्ट प्रॉम्प्ट, उदाहरण बॉक्स, या दोनों से वर्णित किया जाता है।
* [प्रॉम्प्टेबल विज़ुअल सेगमेंटेशन](#sam3-visual-segmentation-pvs) (**PVS**), जो SAM2 की शैली में पॉइंट्स या एक बॉक्स से प्रति अनुरोध एक ऑब्जेक्ट को इंटरैक्टिव रूप से सेगमेंट करता है।

एंडपॉइंट चुनने के लिए इस तालिका का उपयोग करें:

<table data-search="false"><thead><tr><th>आपके पास है</th><th>आप चाहते हैं</th><th>उपयोग करें</th></tr></thead><tbody><tr><td>एक टेक्स्ट विवरण (उदा: "person")</td><td>हर मेल खाने वाले उदाहरण के लिए मास्क</td><td><code>/sam3/concept_segment</code></td></tr><tr><td>एक उदाहरण ऑब्जेक्ट के चारों ओर एक बॉक्स</td><td>हर समान उदाहरण के लिए मास्क</td><td><code>/sam3/concept_segment</code></td></tr><tr><td>ऑब्जेक्ट्स को शामिल या बाहर करने के लिए टेक्स्ट और उदाहरण बॉक्स</td><td>हर मेल खाने वाले उदाहरण के लिए मास्क</td><td><code>/sam3/concept_segment</code></td></tr><tr><td>एक विशिष्ट ऑब्जेक्ट पर एक क्लिक या एक बॉक्स</td><td>केवल उस ऑब्जेक्ट के लिए एक मास्क</td><td><code>/sam3/visual_segment</code></td></tr></tbody></table>

अपनी [API कुंजी](https://app.roboflow.com/settings/api) को एक `Authorization: Bearer` हेडर में हर अनुरोध पर भेजें। पुराना `api_key` क्वेरी पैरामीटर अभी भी काम करता है, लेकिन अनुशंसित नहीं है।

## SAM3 कॉन्सेप्ट सेगमेंटेशन (PCS)

`POST https://serverless.roboflow.com/sam3/concept_segment`

prompts में प्रत्येक एंट्री `प्रॉम्प्ट्स` एक कॉन्सेप्ट का वर्णन करती है। प्रतिक्रिया में प्रत्येक प्रॉम्प्ट के लिए एक `prompt_results` एंट्री होती है, जिसमें पाए गए हर उदाहरण शामिल होते हैं। अनुरोध अधिकतम 16 प्रॉम्प्ट स्वीकार करते हैं।

### टेक्स्ट प्रॉम्प्ट

```python
import os
import requests

payload = {
    "image": {"type": "url", "value": "https://media.roboflow.com/inference/people-walking.jpg"},
    "prompts": [
        {"type": "text", "text": "person"},
        {"type": "text", "text": "backpack"},
    ],
    "output_prob_thresh": 0.5,
    "format": "polygon",  # or "rle"
}

response = requests.post(
    "https://serverless.roboflow.com/sam3/concept_segment",
    headers={"Authorization": f"Bearer {os.environ['ROBOFLOW_API_KEY']}"},
    json=payload,
)
for prompt_result in response.json()["prompt_results"]:
    print(prompt_result["echo"], len(prompt_result["predictions"]), "instances")
```

छवियाँ इनलाइन भी भेजी जा सकती हैं `{"type": "base64", "value": "<BASE64_IMAGE>"}`.

### उदाहरण बॉक्स प्रॉम्प्ट

टेक्स्ट के बजाय, आप एक उदाहरण के साथ प्रॉम्प्ट कर सकते हैं: एक उदाहरण ऑब्जेक्ट के चारों ओर एक बॉक्स। मॉडल मैच होने वाले हर उदाहरण को ढूँढता है, केवल बॉक्स वाले ऑब्जेक्ट को नहीं।

```python
payload = {
    "image": {"type": "url", "value": "https://media.roboflow.com/inference/people-walking.jpg"},
    "prompts": [
        {
            "type": "visual",
            "boxes": [{"x": 1409, "y": 705, "width": 112, "height": 183}],
            "box_labels": [1],
        }
    ],
    "output_prob_thresh": 0.5,
    "format": "polygon",
}
```

बॉक्स पूर्ण पिक्सेल निर्देशांकों का उपयोग करते हैं। दो फ़ॉर्मैट स्वीकार किए जाते हैं:

* `{"x": ..., "y": ..., "width": ..., "height": ...}` जहाँ `x`, `y` ऊपरी-बाएँ कोना है
* `{"x0": ..., "y0": ..., "x1": ..., "y1": ...}` स्पष्ट कोनों के लिए

`box_labels` ज़रूरी है जब `boxes` सेट हो और इसमें प्रति बॉक्स एक एंट्री होनी चाहिए: `1` एक सकारात्मक उदाहरण दर्शाता है (ऐसी वस्तुएँ ढूँढें), `0` एक नकारात्मक उदाहरण दर्शाता है (ऐसी वस्तुएँ बाहर रखें)।

### संयुक्त टेक्स्ट और उदाहरण प्रॉम्प्ट

एक अकेला प्रॉम्प्ट टेक्स्ट और उदाहरण बॉक्स दोनों रख सकता है। यह टेक्स्ट कॉन्सेप्ट को विज़ुअल उदाहरणों से सीमित करने, या नकारात्मक उदाहरणों से मिलती-जुलती वस्तुओं को बाहर रखने के लिए उपयोगी है:

```python
payload = {
    "image": {"type": "url", "value": "https://media.roboflow.com/inference/people-walking.jpg"},
    "prompts": [
        {
            "type": "visual",
            "text": "person",
            "boxes": [
                {"x": 1409, "y": 705, "width": 112, "height": 183},
                {"x": 1216, "y": 496, "width": 124, "height": 184},
            ],
            "box_labels": [1, 0],
        }
    ],
    "output_prob_thresh": 0.5,
    "format": "polygon",
}
```

यहाँ मॉडल पहले (सकारात्मक) उदाहरण से मेल खाने वाले लोगों को सेगमेंट करता है, जबकि दूसरे (नकारात्मक) उदाहरण से मिलते-जुलते उदाहरणों को दबाता है।

## SAM3 विज़ुअल सेगमेंटेशन (PVS)

`POST https://serverless.roboflow.com/sam3/visual_segment`

PVS क्लिक या बॉक्स द्वारा इंगित एक विशिष्ट ऑब्जेक्ट को सेगमेंट करता है। इसे इंटरैक्टिव, human-in-the-loop मास्क परिशोधन के लिए उपयोग करें; जब आप किसी कॉन्सेप्ट के हर उदाहरण चाहते हों, तब PCS का उपयोग करें।

```python
import os
import requests

payload = {
    "image": {"type": "url", "value": "https://media.roboflow.com/inference/people-walking.jpg"},
    "prompts": {
        "prompts": [
            {
                "points": [{"x": 1465, "y": 796, "positive": True}],
                "box": {"x": 1465, "y": 796, "width": 112, "height": 183},
            }
        ]
    },
    "multimask_output": False,
    "format": "json",
}

response = requests.post(
    "https://serverless.roboflow.com/sam3/visual_segment",
    headers={"Authorization": f"Bearer {os.environ['ROBOFLOW_API_KEY']}"},
    json=payload,
)
prediction = response.json()["predictions"][0]
print(prediction["confidence"], len(prediction["masks"]), "polygons")
```

एक प्रॉम्प्ट में शामिल हो सकता है `पॉइंट्स`, एक `बॉक्स`, या दोनों:

* `पॉइंट्स` पूर्ण पिक्सेल निर्देशांक होते हैं। `"positive": true` क्लिक किए गए क्षेत्र को शामिल करता है, `false` इसे बाहर करता है। मास्क को परिष्कृत करने के लिए और पॉइंट्स जोड़ें।
* `बॉक्स` केंद्र-आधारित निर्देशांकों का उपयोग करता है: `x`, `y` बॉक्स का केंद्र है, PCS बॉक्सों के विपरीत जो ऊपर-बाएँ आधारित होते हैं।

प्रतिक्रिया में प्रॉम्प्ट के लिए केवल सबसे अधिक आत्मविश्वास वाला मास्क शामिल होता है। `multimask_output` यह नियंत्रित करता है कि मॉडल कितने आंतरिक मास्क प्रस्ताव उत्पन्न करता है (true होने पर तीन), लेकिन प्रतिक्रिया के लिए हमेशा सबसे अच्छा प्रस्ताव ही चुना जाता है।

{% hint style="warning" %}
प्रति अनुरोध एक प्रॉम्प्ट भेजें। एक PVS अनुरोध में कई प्रॉम्प्ट वर्तमान में केवल एक prediction लौटाते हैं।
{% endhint %}

OpenCV के साथ इंटरैक्टिव डेमो के लिए, यह देखें [GitHub Gist](https://gist.github.com/Erol444/4cbc33c6ac52d83c63f6f9d86ca8a7a4)को देखें, जिसका उपयोग इस वीडियो में किया गया था:

{% embed url="<https://www.youtube.com/watch?v=01xrBzqHZ6c>" %}

## SAM3 इनफ़रेंस गति

इससे मापी गई विलंबता [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>sam3</code></td><td>251.4</td></tr></tbody></table>

एकल टेक्स्ट प्रॉम्प्ट से कॉन्सेप्ट सेगमेंटेशन के साथ मापा गया।

## SAM3 API एंडपॉइंट

{% openapi src="/files/8c88677779c9c87e985947b36dd8351f78f757d6" path="/sam3/concept\_segment" method="post" %}
[sam3.json](https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-c718b36dd4197f87a2e72c28664c6d11516aefc8%2Fsam3.json?alt=media)
{% endopenapi %}

{% openapi src="/files/8c88677779c9c87e985947b36dd8351f78f757d6" path="/sam3/visual\_segment" method="post" %}
[sam3.json](https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-c718b36dd4197f87a2e72c28664c6d11516aefc8%2Fsam3.json?alt=media)
{% endopenapi %}

## सेल्फ-होस्टेड Inference के साथ SAM3 चलाएँ

SAM3 आपके अपने हार्डवेयर पर भी चल सकता है, या तो [`inference`](https://docs.roboflow.com/deployment/self-hosted/self-hosted) पैकेज के साथ इन-प्रोसेस लोड होकर या GPU कंटेनर से सर्व होकर।

### Docker में चलाएँ

```bash
docker run -it --rm -p 9001:9001 --gpus=all roboflow/inference-server:latest
```

सर्वर वही `/sam3/concept_segment` और `/sam3/visual_segment` एंडपॉइंट्स उजागर करता है, जैसा ऊपर बताया गया है, यहाँ `http://localhost:9001`.

### मॉडल को Python में लोड करें

```bash
pip install "inference-gpu[sam3]"
```

```python
import os

os.environ["API_KEY"] = "YOUR_API_KEY"

from inference.core.entities.requests.sam3 import Sam3Prompt
from inference.models.sam3 import SegmentAnything3

model = SegmentAnything3(model_id="sam3/sam3_final")

prompts = [
    # कॉन्सेप्ट के हर उदाहरण को सेगमेंट करें
    Sam3Prompt(type="text", text="person"),
    # एक उदाहरण ऑब्जेक्ट को बॉक्स करें और हर समान उदाहरण को सेगमेंट करें।
    # box_labels: 1 = सकारात्मक उदाहरण, 0 = नकारात्मक उदाहरण।
    Sam3Prompt(
        type="visual",
        boxes=[Sam3Prompt.Box(x=1409, y=705, width=112, height=183)],
        box_labels=[1],
    ),
]

response = model.segment_image(
    image="path/to/your/image.jpg",
    prompts=prompts,
    output_prob_thresh=0.5,
    format="polygon",  # or "rle", "json"
)

for prompt_result in response.prompt_results:
    print(prompt_result.echo.text, len(prompt_result.predictions), "instances")
```

वज़न पहली बार उपयोग पर स्वचालित रूप से डाउनलोड हो जाते हैं।

### Python में इंटरैक्टिव सेगमेंटेशन

`Sam3ForInteractiveImageSegmentation` मानव-इन-द-लूप मास्क परिशोधन के लिए SAM2-शैली के पॉइंट और बॉक्स इंटरफ़ेस को लागू करता है:

```python
from inference.models.sam3 import Sam3ForInteractiveImageSegmentation

model = Sam3ForInteractiveImageSegmentation(model_id="sam3/sam3_final")

embedding, img_shape, image_id = model.embed_image(image="path/to/image.jpg")

masks, scores, logits = model.segment_image(
    image_id=image_id,
    prompts={"points": [{"x": 500, "y": 400, "positive": True}]},
)
```

## वर्कफ़्लो में SAM3 का उपयोग करें

में दो SAM3 इमेज ब्लॉक उपलब्ध हैं [वर्कफ़्लोज़](https://docs.roboflow.com/workflows):

* **SAM 3** कॉन्सेप्ट सेगमेंटेशन चलाता है। जिन क्लासों की आपको आवश्यकता है, उन्हें इसमें दर्ज करें `class_names` (उदाहरण के लिए `["person", "vehicle"]`) और ब्लॉक instance segmentation predictions आउटपुट करता है जिन्हें अन्य स्टेप्स उपयोग कर सकते हैं।
* **SAM 3 Interactive** प्रॉम्प्टेबल विज़ुअल सेगमेंटेशन चलाता है। लेबल किए गए पॉइंट्स प्रदान करें (किस्म `labeled_points`), उदाहरण के लिए `[{"x": 320, "y": 240, "positive": true}]`, और वैकल्पिक रूप से किसी अन्य मॉडल से detections को `boxes` फील्ड से जोड़ें। हर बॉक्स एक अलग प्रॉम्प्ट बन जाता है, और उसका class name अनुमानित मास्क को भेज दिया जाता है।

### वीडियो ट्रैकिंग

यह **SAM3 वीडियो ट्रैकर** ब्लॉक (`roboflow_core/sam3_video@v1`) SAM3 के स्ट्रीमिंग कॉन्सेप्ट ट्रैकर को फ़्रेम दर फ़्रेम चलाता है। आप `class_names`में कॉन्सेप्ट्स को टेक्स्ट के रूप में प्रदान करते हैं, और मॉडल हर फ़्रेम पर फ्यूज़्ड डिटेक्शन और ट्रैकिंग चलाता है। किसी कॉन्सेप्ट से मेल खाने वाली वस्तुएँ एक स्थिर `tracker_id`, बनाए रखती हैं, और, detector-seeded tracking के विपरीत, जो वस्तुएँ स्ट्रीम के बीच में दृश्य में प्रवेश करती हैं, उन्हें बिना दोबारा प्रॉम्प्ट किए और बिना अपस्ट्रीम डिटेक्शन मॉडल के स्वतः पकड़ लिया जाता है। हर मास्क अपने मेल खाने वाले कॉन्सेप्ट को अपनी class name के रूप में और मॉडल के detection score को अपनी confidence के रूप में रखता है (इसके साथ फ़िल्टर करें `threshold`, डिफ़ॉल्ट `0.5`).

* **स्टेटफुल और केवल स्थानीय।** एक ट्रैकिंग सत्र प्रति रखा जाता है `video_metadata.video_identifier`। ब्लॉक को आवश्यकता होती है `WORKFLOWS_STEP_EXECUTION_MODE=local`, एक GPU, और एक स्थायी WebRTC सत्र की।
* **कोई प्रॉम्प्ट शेड्यूलिंग नहीं।** कॉन्सेप्ट प्रॉम्प्ट्स प्रत्येक सत्र में एक बार पंजीकृत किए जाते हैं; सत्र को केवल तब फिर से सीड किया जाता है जब स्ट्रीम पुनः प्रारंभ होती है या `class_names` बदलती है। detector-driven (box-prompted) वीडियो ट्रैकिंग के लिए, SAM2 पृष्ठ पर SAM2 Video Tracker ब्लॉक का उपयोग करें [SAM2 पृष्ठ](https://docs.roboflow.com/models/hi/supported-models/sam2.md), जो `sam3trackervideo` को `model_id`.
* **मॉडल।** `model_id` default होता है `sam3video`, SAM3 वीडियो का HuggingFace transformers पोर्ट, जो फ़्रेम-दर-फ़्रेम स्ट्रीमिंग इंटरफ़ेस प्रदान करता है। मूल `sam3` पैकेज के वीडियो प्रेडिक्टर को पूरा वीडियो पहले से चाहिए और इसे लाइव स्ट्रीम्स के लिए इस्तेमाल नहीं किया जा सकता।

```python
from inference_sdk import InferenceHTTPClient, InferenceConfiguration
from inference_sdk.webrtc import StreamConfig, VideoFileSource

WORKFLOW = {
    "version": "1.0",
    "inputs": [{"type": "InferenceImage", "name": "image"}],
    "steps": [
        {
            "type": "roboflow_core/sam3_video@v1",
            "name": "tracker",
            "images": "$inputs.image",
            "class_names": ["person", "forklift"],
            "threshold": 0.5,
        },
    ],
    "outputs": [
        {
            "type": "JsonField",
            "name": "predictions",
            "selector": "$steps.tracker.predictions",
        }
    ],
}

client = InferenceHTTPClient(
    api_url="http://localhost:9001",
    api_key="YOUR_API_KEY",
).configure(InferenceConfiguration(api_key_transport="header"))

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()
```

## SAM3-3D (बीटा)

SAM3-3D 2D छवि और मास्क को 3D एसेट्स में बदलता है: मेश और Gaussian splats।

{% hint style="warning" %}
SAM3-3D बीटा में है। यह केवल तब उपलब्ध है जब `SAM3_3D_OBJECTS_ENABLED` फ़्लैग सेट हो, 32 GB या अधिक VRAM वाले GPU की आवश्यकता हो, और `inference` पैकेज या स्थानीय Inference सर्वर के माध्यम से चले (यह Serverless Cloud API पर नहीं है)।
{% endhint %}

निर्भरताएँ स्थापित करें (Python 3.10 अनुशंसित):

```bash
pip install --no-cache-dir --no-build-isolation -r requirements/requirements.sam3_3d.txt
```

या 3D-सक्षम GPU कंटेनर बनाकर चलाएँ:

```bash
docker build -t roboflow/roboflow-inference-server-gpu:dev -f docker/dockerfiles/Dockerfile.onnx.gpu.3d .
docker run --gpus all -p 9001:9001 roboflow/roboflow-inference-server-gpu:dev
```

**इनपुट।** एक RGB छवि और `mask_input`, जो ऑब्जेक्ट क्षेत्रों को परिभाषित करता है। मास्क binary arrays के रूप में स्वीकार किए जाते हैं (`(H, W)` या `(N, H, W)`), COCO फ्लैट पॉलीगॉन, point-pair पॉलीगॉन, RLE dicts, या `sv.Detections` SAM2 या किसी अन्य segmentation model से एक object.

**आउटपुट।** `mesh_glb` (संयुक्त scene mesh, GLB), `gaussian_ply` (संयुक्त Gaussian splat, PLY), `objects` (प्रति-ऑब्जेक्ट `mesh_glb`, `gaussian_ply`, और `metadata` रोटेशन, ट्रांसलेशन, और स्केल के साथ), और `समय`.

```python
import os

os.environ["SAM3_3D_OBJECTS_ENABLED"] = "true"
os.environ["SPARSE_ATTN_BACKEND"] = "flash_attn"
os.environ["ATTN_BACKEND"] = "flash_attn"

from inference import get_model
from inference.core.entities.requests.sam3_3d import Sam3_3D_Objects_InferenceRequest

model = get_model("sam3-3d-objects", api_key="YOUR_API_KEY")

request = Sam3_3D_Objects_InferenceRequest(
    image={"type": "file", "value": "image.jpg"},
    mask_input=mask_polygons,  # polygons, binary masks, or RLE
)

response = model.infer_from_request(request)

if response.mesh_glb is not None:
    with open("out_mesh.glb", "wb") as f:
        f.write(response.mesh_glb)

for index, obj in enumerate(response.objects):
    if obj.gaussian_ply is not None:
        with open(f"out_object_{index}.ply", "wb") as f:
            f.write(obj.gaussian_ply)
```

सेट करना `SPARSE_ATTN_BACKEND` और `ATTN_BACKEND` को `flash_attn` पाइपलाइन को तेज़ करता है। Workflows में, SAM3-3D स्थानीय निष्पादन और दूरस्थ निष्पादन का समर्थन निम्न के माध्यम से करता है `sam3_3d_infer()` क्लाइंट मेथड या `/sam3_3d/infer` एंडपॉइंट।

## यह भी देखें

* [SAM2](https://docs.roboflow.com/models/hi/supported-models/sam2.md) - बिंदु और बॉक्स-प्रॉम्प्टेड सेगमेंटेशन, साथ ही डिटेक्टर-सीडेड वीडियो ट्रैकिंग।
* [सेगमेंट एनीथिंग (SAM)](https://docs.roboflow.com/models/hi/supported-models/sam.md) - मूल एकल-ऑब्जेक्ट मॉडल।
