SAM2

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

हम Meta के सेगमेंट एनीथिंग मॉडल 2 का इन्फरेंस हमारे सर्वरलेस क्लाउड API के माध्यम से समर्थित करते हैं. SAM2 एक प्रॉम्प्ट-योग्य विज़ुअल सेगमेंटेशन मॉडल है जो प्रॉम्प्ट के रूप में बिंदु और बाउंडिंग बॉक्स स्वीकार करता है। हम दो SAM2 एंडपॉइंट्स प्रदान करते हैं:

• /sam2/embed_image, जो एक इमेज एम्बेडिंग उत्पन्न और कैश करता है

• /sam2/segment_image, जो दिए गए प्रॉम्प्ट्स के लिए इंस्टेंस सेगमेंटेशन मास्क लौटाता है

कोड नमूना

SAM2 को सीधे HTTP एंडपॉइंट के माध्यम से इस तरह चलाएँ curl, या inference-sdk रैपर के साथ।

HTTP (curl)

1

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

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

export ROBOFLOW_API_KEY="आपकी-कुंजी-यहाँ"

2

मॉडल चलाएँ

को कॉल करें /sam2/segment_image एंडपॉइंट के साथ curl:

curl --location 'https://serverless.roboflow.com/sam2/segment_image' \\
  --header 'Content-Type: application/json' \
  --data '{
    "api_key": "'"$ROBOFLOW_API_KEY"'",
    "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"
  }'

SDK (Python)

1

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

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

export ROBOFLOW_API_KEY="आपकी-कुंजी-यहाँ"

2

निर्भरताएँ इंस्टॉल करें

ये पैकेज मॉडल को कॉल करते हैं और उसके परिणामों को ड्रॉ करते हैं:

pip install -U inference-sdk supervision opencv-python

3

मॉडल चलाएँ

एकल सकारात्मक बिंदु प्रॉम्प्ट के साथ सेगमेंटेशन एंडपॉइंट को कॉल करें, लौटाए गए पॉलीगॉन्स को supervision के साथ डिटेक्शन्स में बदलें, और इनपुट इमेज पर मास्क बनाकर एक एनोटेटेड PNG सहेजें:

import os
import cv2
import supervision as sv
from inference_sdk import InferenceHTTPClient

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

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 दोनों द्वारा लौटाई गई पॉलीगॉन भविष्यवाणियों को पढ़ता है, इसलिए वही कॉल किसी भी मॉडल के आउटपुट को डिकोड कर देती है।

इन्फरेंस गति

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

मॉडल	विलंबता (ms)
sam2	177.7

के साथ मापा गया segment_image पर hiera_large चेकपॉइंट। SAM2 इमेज एम्बेडिंग्स को कैश करता है, इसलिए यह आंकड़ा हर कॉल पर एक नई इमेज का उपयोग करता है और पूर्ण एन्कोड तथा डिकोड लागत को दर्शाता है। पहले से एन्कोड की गई इमेज को पुनः प्रॉम्प्ट करना काफी तेज़ होता है।

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

• https://serverless.roboflow.com सर्वरलेस Cloud API के लिए।

• http://localhost:9001 एक स्थानीय Inference सर्वर।

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

अतिरिक्त उपयोग विवरणों के लिए, जिसमें एम्बेडिंग कैशिंग और बॉक्स प्रॉम्प्ट शामिल हैं, देखें इनफ़ेरेंस दस्तावेज़ीकरण.

Inference के साथ उपयोग करें (सेल्फ-होस्टेड)

SAM2 को सीधे भी लोड किया जा सकता है inference पैकेज, या इसे आपके द्वारा चलाए गए GPU कंटेनर से सर्व किया जा सकता है। जब आप इमेजों को अपने हार्डवेयर पर ही रखना चाहते हों, या जब आप उसी इमेज को कई बार फिर से प्रॉम्प्ट कर रहे हों, तब यही सही तरीका है।

Docker में चलाएँ

के रूट से SAM2 इमेज बनाएँ inference रिपॉजिटरी:

docker build -f docker/dockerfiles/Dockerfile.sam2 -t sam2 .

फिर एक सर्वर शुरू करें जो SAM2 एंडपॉइंट्स को एक्सपोज़ करता है:

docker run -it --rm -v /tmp/cache/:/tmp/cache/ --gpus=all --net=host sam2

बिंदु api_url उस सर्वर पर (http://localhost:9001) और ऊपर दिए गए कोड नमूने बिना बदलाव के काम करते हैं।

फ्लैश अटेंशन के साथ SAM2 में एक ज्ञात समस्या कुछ GPUs, जिनमें L4 और A100 शामिल हैं, पर। उस थ्रेड से सुधार लागू करें, या ऊपर दी गई Docker इमेज का उपयोग करें, जो इसे पहले से संभालती है।

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) किसी क्षेत्र को बाहर करने के लिए:

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.

वर्कफ़्लोज़ में वीडियो ट्रैकिंग

यह SAM2 वीडियो ट्रैकर ब्लॉक (roboflow_core/segment_anything_2_video@v1) SAM2 के स्ट्रीमिंग वीडियो प्रेडिक्टर को फ्रेम दर फ्रेम चलाता है, और प्रति-वीडियो समयगत मेमोरी बनाए रखता है ताकि ऑब्जेक्ट पहचानें फ्रेमों के बीच बनी रहें। इसे अपस्ट्रीम डिटेक्टर से आए बाउंडिंग बॉक्स दें: यह हर बॉक्स को मास्क में बदलता है और बाद के फ्रेमों पर उसे ट्रैक करता है, तथा ऐसे सेगमेंटेशन प्रेडिक्शंस निकालता है जिनका tracker_id SAM2 जब तक ऑब्जेक्ट को फॉलो करता है, तब तक स्थिर रहता है। मास्क उस डिटेक्शन का वर्ग नाम, वर्ग आईडी, और कॉन्फिडेंस विरासत में लेते हैं जिसने उन्हें प्रॉम्प्ट किया।

• स्टेटफुल और केवल लोकल। यह ब्लॉक प्रति video_metadata.video_identifier, एक ट्रैकिंग सेशन रखता है, इसलिए यह कई स्ट्रीम्स को मल्टीप्लेक्स कर सकता है, लेकिन सेशन प्रोसेस मेमोरी में रहता है। इसके लिए WORKFLOWS_STEP_EXECUTION_MODE=local, एक GPU, और एक स्थायी WebRTC session की आवश्यकता होती है। यह अलग, 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 आकारों को गति स्तरों के रूप में मानें।

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

पाठ प्रॉम्प्ट्स से खुले-शब्दावली वीडियो ट्रैकिंग के लिए, बिना किसी अपस्ट्रीम डिटेक्टर के, SAM3 Video Tracker ब्लॉक देखें SAM3 पेज.

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

जब किसी image Workflow में उपयोग किया जाता है, तो SAM2 दो मोड में से एक में चलता है:

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

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

यह भी देखें

• SAM3 - text prompt से किसी अवधारणा के हर instance को segment करता है।

• सेगमेंट एनीथिंग (SAM) - मूल एकल-वस्तु मॉडल।