SAM3

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

हम Meta के सेगमेंट एनीथिंग मॉडल 3 के माध्यम से इन्फरेंसिंग सर्वरलेस क्लाउड API. हम दो अलग-अलग SAM3 एंडपॉइंट प्रदान करते हैं:

Roboflow पर SAM3 मॉडल का प्रशिक्षण सशुल्क प्लानों में उपयोग-आधारित बिलिंग. वहाँ से, आप सुविधा का उपयोग करने के लिए SAM3 आर्किटेक्चर पर "Request Feature" बटन से एक्सेस का अनुरोध कर सकते हैं ट्रेनिंग फ्लो.

फाइन-ट्यून किए गए SAM3 मॉडल Serverless Cloud API पर नहीं चल सकते। उन्हें एक पर तैनात करें डेडिकेटेड डिप्लॉयमेंट या स्व-होस्टेड इन्फरेंस. होस्ट किए गए sam3 इस पेज पर एंडपॉइंट्स अप्रभावित हैं।

प्रॉम्प्टेबल कॉन्सेप्ट सेगमेंटेशन (PCS), जो छवि में किसी कॉन्सेप्ट के हर इंस्टेंस को सेगमेंट करता है। कॉन्सेप्ट्स का वर्णन टेक्स्ट प्रॉम्प्ट, उदाहरण बॉक्स, या दोनों से किया जाता है।
प्रॉम्प्टेबल विज़ुअल सेगमेंटेशन (PVS), जो SAM2 की शैली में, बिंदुओं या एक बॉक्स से प्रति अनुरोध एक वस्तु को इंटरैक्टिव रूप से सेगमेंट करता है।

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

आपके पास है

आप चाहते हैं

उपयोग करें

एक टेक्स्ट विवरण (जैसे: "person")

हर मिलते-जुलते इंस्टेंस के लिए मास्क

/sam3/concept_segment

एक उदाहरण वस्तु के चारों ओर एक बॉक्स

हर समान इंस्टेंस के लिए मास्क

/sam3/concept_segment

वस्तुओं को शामिल या बाहर करने के लिए टेक्स्ट और उदाहरण बॉक्स

हर मिलते-जुलते इंस्टेंस के लिए मास्क

/sam3/concept_segment

एक विशिष्ट वस्तु पर एक क्लिक या एक बॉक्स

सिर्फ उस वस्तु के लिए एक मास्क

/sam3/visual_segment

अपनी API कुंजी को api_key क्वेरी पैरामीटर के रूप में हर अनुरोध पर भेजें।

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

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

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

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

import os
import requests

payload = {
    "image": {"type": "url", "value": "https://media.roboflow.com/inference/people-walking.jpg"},
    "prompts": [
        {"type": "text", "text": "व्यक्ति"},
        {"type": "text", "text": "बैकपैक"},
    ],
    "output_prob_thresh": 0.5,
    "format": "polygon",  # या "rle"
}

response = requests.post(
    "https://serverless.roboflow.com/sam3/concept_segment",
    params={"api_key": os.environ["ROBOFLOW_API_KEY"]},
    json=payload,
)
for prompt_result in response.json()["prompt_results"]:
    print(prompt_result["echo"], len(prompt_result["predictions"]), "इंस्टेंस")

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

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

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

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 एक नकारात्मक उदाहरण चिह्नित करता है (ऐसी वस्तुओं को बाहर करें)।

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

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

payload = {
    "image": {"type": "url", "value": "https://media.roboflow.com/inference/people-walking.jpg"},
    "prompts": [
        {
            "type": "visual",
            "text": "व्यक्ति",
            "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",
}

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

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

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

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

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",
    params={"api_key": os.environ["ROBOFLOW_API_KEY"]},
    json=payload,
)
prediction = response.json()["predictions"][0]
print(prediction["confidence"], len(prediction["masks"]), "बहुभुज")

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

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

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

प्रति अनुरोध एक प्रॉम्प्ट भेजें। एक PVS अनुरोध में कई प्रॉम्प्ट वर्तमान में केवल एक भविष्यवाणी लौटाते हैं।

OpenCV का उपयोग करके एक इंटरैक्टिव डेमो के लिए, यह देखें GitHub Gist, जिसका उपयोग इस वीडियो में किया गया था:

इन्फरेंस गति

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

मॉडल

लेटेंसी (ms)

sam3

251.4

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

एंडपॉइंट्स

SAM3 PCS (promptable concept segmentation)

post

Concept Segmentation (Text Prompts)

Allows you to segment objects using text prompts.

Image Input: The image field accepts either:

{"type": "url", "value": "<IMAGE_URL>"} - A publicly accessible image URL
{"type": "base64", "value": "<BASE64_DATA>"} - Base64 encoded image data

Prompts: Each prompt in the prompts array should have type: "text" and a text field with the object description.

Query parameters

api_keystringRequired

Your Roboflow API Key. Get one at https://app.roboflow.com/settings/api

Body

formatstringOptional

One of 'polygon', 'rle'

Default: polygon

image_idstringOptional

Optional ID for caching embeddings.

output_prob_threshnumberOptional

Score threshold for outputs.

Default: 0.5

model_idstringOptional

The model ID of SAM3. Use 'sam3/sam3_final' to target the generic base model.

Default: sam3/sam3_final

nms_iou_thresholdnumberOptional

IoU threshold for cross-prompt NMS. If not set, NMS is disabled. Must be in [0.0, 1.0] when set.

Responses

200

Successful Response

application/json

timenumberRequired

The time in seconds it took to produce the segmentation including preprocessing

422

Validation Error

application/json

post/sam3/concept_segment

POST /sam3/concept_segment?api_key=text HTTP/1.1
Host: serverless.roboflow.com
Content-Type: application/json
Accept: */*
Content-Length: 206

{
  "image": {
    "type": "url",
    "value": "https://media.roboflow.com/notebooks/examples/dog.jpeg"
  },
  "prompts": [
    {
      "type": "text",
      "text": "person"
    },
    {
      "type": "text",
      "text": "car"
    }
  ],
  "output_prob_thresh": 0.5,
  "format": "polygon"
}

{
  "prompt_results": [
    {
      "prompt_index": 0,
      "echo": {
        "prompt_index": 0,
        "type": "text",
        "text": "dog",
        "num_boxes": 0
      },
      "predictions": [
        {
          "masks": [
            [
              [
                345,
                251
              ],
              [
                344,
                252
              ],
              [
                343,
                253
              ]
            ]
          ],
          "confidence": 0.89453125,
          "format": "polygon"
        }
      ]
    }
  ],
  "time": 0.221
}

SAM3 PVS (promptable visual segmentation)

post

Interactive Segmentation (SAM 2 Style)

SAM 3 also supports interactive segmentation using points and boxes.

Image Input: The image field accepts either:

{"type": "url", "value": "<IMAGE_URL>"} - A publicly accessible image URL
{"type": "base64", "value": "<BASE64_DATA>"} - Base64 encoded image data

Note: NumPy arrays are NOT supported on the serverless API. Use URL or base64 encoding only.

Prompts: Support point-based prompts with positive/negative clicks for interactive segmentation.

Query parameters

api_keystringRequired

Your Roboflow API Key. Get one at https://app.roboflow.com/settings/api

Body

SAM2 visual segmentation request.

image_idstringOptional

The ID of the image to be segmented used to retrieve cached embeddings. If an embedding is cached, it will be used instead of generating a new embedding. If no embedding is cached, a new embedding will be generated and cached.

Example: image_id

formatstringOptional

The format of the response. Must be one of 'json', 'rle', or 'binary'. If binary, masks are returned as binary numpy arrays. If json, masks are converted to polygons. If rle, masks are converted to RLE format.

Default: jsonExample: json

sam2_version_idstringOptional

The version ID of SAM to be used for this request. Must be one of hiera_tiny, hiera_small, hiera_large, hiera_b_plus

Default: hiera_largeExample: hiera_large

multimask_outputbooleanOptional

If true, the model will return three masks. For ambiguous input prompts (such as a single click), this will often produce better masks than a single prediction.

Default: trueExample: true

save_logits_to_cachebooleanOptional

If True, saves the low-resolution logits to the cache for potential future use.

Default: false

load_logits_from_cachebooleanOptional

If True, attempts to load previously cached low-resolution logits for the given image and prompt set.

Default: false

Responses

200

Successful Response

application/json

timenumberRequired

The time in seconds it took to produce the segmentation including preprocessing

422

Validation Error

application/json

post/sam3/visual_segment

POST /sam3/visual_segment?api_key=text HTTP/1.1
Host: serverless.roboflow.com
Content-Type: application/json
Accept: */*
Content-Length: 294

{
  "image": {
    "type": "url",
    "value": "http://www.example-image-url.com"
  },
  "image_id": "image_id",
  "prompts": [
    {
      "prompts": [
        {
          "points": [
            {
              "positive": true,
              "x": 100,
              "y": 100
            }
          ]
        }
      ]
    }
  ],
  "format": "json",
  "sam2_version_id": "hiera_large",
  "multimask_output": true,
  "save_logits_to_cache": false,
  "load_logits_from_cache": false
}

{
  "prompt_results": [
    {
      "prompt_index": 1,
      "predictions": []
    }
  ],
  "time": 1
}

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

SAM3 आपके अपने हार्डवेयर पर भी चल सकता है, या तो inference पैकेज के साथ इन-प्रोसेस लोड करके या GPU कंटेनर से सर्व करके।

Docker में चलाएँ

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

सर्वर वही /sam3/concept_segment और /sam3/visual_segment ऊपर वर्णित एंडपॉइंट्स को यहाँ एक्सपोज़ करता है http://localhost:9001.

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

pip install "inference-gpu[sam3]"

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="व्यक्ति"),
    # एक उदाहरण वस्तु को बॉक्स करें और हर समान इंस्टेंस को सेगमेंट करें.
    # 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",  # या "rle", "json"
)

for prompt_result in response.prompt_results:
    print(prompt_result.echo.text, len(prompt_result.predictions), "इंस्टेंस")

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

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

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

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

वर्कफ़्लोज़ में उपयोग करें

Two SAM3 image blocks are available in वर्कफ़्लोज़:

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

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

द SAM3 वीडियो ट्रैकर ब्लॉक (roboflow_core/sam3_video@v1) SAM3 के स्ट्रीमिंग कॉन्सेप्ट ट्रैकर को फ्रेम दर फ्रेम चलाता है। आप कॉन्सेप्टों को टेक्स्ट के रूप में class_namesमें देते हैं, और मॉडल हर फ्रेम पर फ्यूज़्ड डिटेक्शन और ट्रैकिंग चलाता है। किसी कॉन्सेप्ट से मेल खाने वाली वस्तुएँ स्थिर tracker_id, बनाए रखती हैं, और detector-seeded tracking के विपरीत, जो वस्तुएँ स्ट्रीम के बीच में दृश्य में प्रवेश करती हैं, उन्हें बिना दोबारा प्रॉम्प्ट किए और बिना upstream detection model के स्वतः पकड़ लिया जाता है। हर मास्क अपने मेल खाने वाले कॉन्सेप्ट को अपने 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 पेज, जो यह भी स्वीकार करता है sam3trackervideo को model_id.
के रूप में model_id मॉडल। sam3video, SAM3 वीडियो का HuggingFace transformers पोर्ट, जो फ्रेम-दर-फ्रेम स्ट्रीमिंग इंटरफ़ेस प्रदान करता है। नेटिव sam3 पैकेज का वीडियो प्रेडिक्टर पूरे वीडियो को पहले से आवश्यक करता है और लाइव स्ट्रीम के लिए उपयोग नहीं किया जा सकता।

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

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.

SAM3-3D बीटा में है। यह केवल तब उपलब्ध है जब SAM3_3D_OBJECTS_ENABLED फ्लैग सेट हो, 32 GB या अधिक VRAM वाला GPU चाहिए, और inference पैकेज या एक स्थानीय Inference सर्वर के माध्यम से चलता है (यह Serverless Cloud API पर नहीं है)।

निर्भरताएँ इंस्टॉल करें (Python 3.10 अनुशंसित):

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

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

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, जो वस्तु क्षेत्रों को परिभाषित करता है। मास्क बाइनरी ऐरे के रूप में स्वीकार किए जाते हैं ((H, W) या (N, H, W)), COCO फ़्लैट पॉलीगॉन, point-pair पॉलीगॉन, RLE dicts, या एक sv.Detections ऑब्जेक्ट SAM2 या किसी अन्य सेगमेंटेशन मॉडल से।

आउटपुट। mesh_glb (संयुक्त दृश्य मेष, GLB), gaussian_ply (संयुक्त Gaussian splat, PLY), objects (प्रति-वस्तु mesh_glb, gaussian_ply, और मेटाडेटा रोटेशन, ट्रांसलेशन और स्केल के साथ), और समय.

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,  # पॉलीगॉन, बाइनरी मास्क, या 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 - पॉइंट और बॉक्स-प्रॉम्प्टेड सेगमेंटेशन, साथ ही डिटेक्टर-सीडेड वीडियो ट्रैकिंग।
सेगमेंट एनीथिंग (SAM) - मूल एकल-ऑब्जेक्ट मॉडल।

पिछलाSAM2 अगलाSmolVLM2

अंतिम अपडेट 10 घंटे पहले

क्या यह उपयोगी था?