> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/vision-models/sam2-video.md).

# SAM2 Video

Clore.ai पर Meta के SAM2 के साथ वीडियो में वस्तुओं को ट्रैक और सेगमेंट करें

Meta के SAM2.1 के साथ वीडियो में किसी भी ऑब्जेक्ट को ट्रैक और सेगमेंट करें — SAM2 का उन्नत संस्करण, जिसमें वीडियो सटीकता बेहतर है.

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
इस गाइड के सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया हो [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) मार्केटप्लेस।
{% endhint %}

## CLORE.AI पर किराए पर लेना

1. विज़िट करें [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)
2. GPU प्रकार, VRAM और कीमत के अनुसार फ़िल्टर करें
3. चुनें **ऑन-डिमांड** (स्थिर दर) या **स्पॉट** (बोली मूल्य)
4. अपना ऑर्डर कॉन्फ़िगर करें:
   * Docker इमेज चुनें
   * पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
   * यदि आवश्यक हो तो environment variables जोड़ें
   * स्टार्टअप कमांड दर्ज करें
5. भुगतान चुनें: **CLORE**, **BTC**या **USDT/USDC**
6. ऑर्डर बनाएं और डिप्लॉयमेंट की प्रतीक्षा करें

### अपने सर्वर तक पहुँचें

* कनेक्शन विवरण यहाँ खोजें **मेरे ऑर्डर**
* वेब इंटरफ़ेस: HTTP पोर्ट URL का उपयोग करें
* SSH: `ssh -p <port> root@<proxy-address>`

## SAM2 क्या है?

Meta AI का SAM2 (Segment Anything Model 2) निम्न को सक्षम बनाता है:

* रीयल-टाइम वीडियो ऑब्जेक्ट सेगमेंटेशन
* क्लिक करके किसी भी ऑब्जेक्ट को ट्रैक करें
* ऑक्लूज़न के दौरान सुसंगत ट्रैकिंग
* मेमोरी-कुशल वीडियो प्रोसेसिंग

## SAM2.1 में नया क्या है

SAM2.1 मूल SAM2 की तुलना में महत्वपूर्ण सुधार लाता है:

* **बेहतर वीडियो सटीकता** — ऑक्लूज़न और तेज़ गति के दौरान बेहतर ट्रैकिंग
* **उन्नत मेमोरी मॉड्यूल** — अधिक सुसंगत लंबी दूरी की ट्रैकिंग
* **नए चेकपॉइंट्स** — `sam2.1_hiera_*` बेहतर प्रदर्शन वाली श्रृंखला
* **आधिकारिक pip पैकेज** — इसके साथ इंस्टॉल करें `pip install sam-2` (हाथ से बिल्ड करने की आवश्यकता नहीं)
* **तेज़ इंफेरेंस** — अनुकूलित CUDA कर्नेल्स

## संसाधन

* **GitHub:** [facebookresearch/sam2](https://github.com/facebookresearch/sam2)
* **पेपर:** [SAM2 पेपर](https://arxiv.org/abs/2408.00714)
* **डेमो:** [SAM2 डेमो](https://sam2.metademolab.com/)
* **मॉडल वज़न:** [SAM2.1 चेकपॉइंट्स](https://github.com/facebookresearch/sam2#model-checkpoints)

## अनुशंसित हार्डवेयर

| घटक     | न्यूनतम       | अनुशंसित      | इष्टतम        |
| ------- | ------------- | ------------- | ------------- |
| GPU     | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM    | 8GB           | 16GB          | 24GB          |
| CPU     | 4 कोर         | 8 कोर         | 16 कोर        |
| RAM     | 16GB          | 32GB          | 64GB          |
| स्टोरेज | 30GB SSD      | 50GB NVMe     | 100GB NVMe    |
| इंटरनेट | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## CLORE.AI पर त्वरित परिनियोजन

**Docker इमेज:**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**पोर्ट:**

```
22/tcp
7860/http
```

**कमांड:**

```bash
cd /workspace && \
pip install sam-2 && \\
python -c "from sam2.build_sam import build_sam2; print('SAM2.1 तैयार है!')"
```

## अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना `http_pub` URL यहाँ **मेरे ऑर्डर**:

1. पर जाएँ **मेरे ऑर्डर** पेज
2. अपने ऑर्डर पर क्लिक करें
3. खोजें `http_pub` URL (उदा., `abc123.clorecloud.net`)

उपयोग करें `https://YOUR_HTTP_PUB_URL` की बजाय `localhost` नीचे दिए गए उदाहरणों में।

## इंस्टॉलेशन

```bash
# आधिकारिक pip पैकेज (SAM2.1 के लिए अनुशंसित)
pip install sam-2

# SAM2.1 चेकपॉइंट्स डाउनलोड करें
python -c "
from sam2.utils.misc import download_file_with_progress

checkpoints = [
    ('https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_tiny.pt', 'checkpoints/sam2.1_hiera_tiny.pt'),
    ('https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_small.pt', 'checkpoints/sam2.1_hiera_small.pt'),
    ('https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_base_plus.pt', 'checkpoints/sam2.1_hiera_base_plus.pt'),
    ('https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt', 'checkpoints/sam2.1_hiera_large.pt'),
]
"

# या डाउनलोड स्क्रिप्ट का उपयोग करें
mkdir -p checkpoints && cd checkpoints
wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt
```

### विकल्प: स्रोत से (डेवलपमेंट के लिए)

```bash
git clone https://github.com/facebookresearch/sam2.git
cd sam2
pip install -e ".[demo]"

# SAM2.1 चेकपॉइंट्स डाउनलोड करें
cd checkpoints
bash download_ckpts.sh
```

## आप क्या बना सकते हैं

### वीडियो संपादन

* वीडियो से ऑब्जेक्ट हटाएँ
* बैकग्राउंड को बिना रुकावट बदलें
* कम्पोज़िटिंग के लिए वीडियो मास्क बनाएं

### स्पोर्ट्स विश्लेषण

* खेलों के दौरान खिलाड़ियों को ट्रैक करें
* गतिविधि पैटर्न का विश्लेषण करें
* हाइलाइट रील्स बनाएं

### चिकित्सीय इमेजिंग

* CT/MRI वीडियो में अंगों को सेगमेंट करें
* माइक्रोस्कोपी में कोशिका गति को ट्रैक करें
* समय के साथ वृद्धि मापें

### निगरानी एवं सुरक्षा

* कैमरों के बीच ऑब्जेक्ट्स को ट्रैक करें
* लोगों/वाहनों की गिनती करें
* असामान्यता का पता लगाना

### रचनात्मक प्रोजेक्ट

* VFX के लिए रोटोस्कोपिंग
* इंटरैक्टिव वीडियो इंस्टॉलेशन
* AR/VR कंटेंट निर्माण

## मूल उपयोग

### छवि विभाजन

```python
import torch
from sam2.build_sam import build_sam2
from sam2.sam2_image_predictor import SAM2ImagePredictor
from PIL import Image
import numpy as np

# SAM2.1 मॉडल लोड करें (SAM2 की तुलना में बेहतर सटीकता)
checkpoint = "./checkpoints/sam2.1_hiera_large.pt"
model_cfg = "configs/sam2.1/sam2.1_hiera_l.yaml"

sam2 = build_sam2(model_cfg, checkpoint, device="cuda")
predictor = SAM2ImagePredictor(sam2)

# छवि लोड करें
image = np.array(Image.open("image.jpg"))
predictor.set_image(image)

# बिंदु प्रॉम्प्ट के साथ सेगमेंट करें
point_coords = np.array([[500, 375]])  # x, y निर्देशांक
point_labels = np.array([1])  # 1 = अग्रभूमि

masks, scores, logits = predictor.predict(
    point_coords=point_coords,
    point_labels=point_labels,
    multimask_output=True
)

# सबसे अच्छा मास्क प्राप्त करें
best_mask = masks[scores.argmax()]
```

### वीडियो ऑब्जेक्ट ट्रैकिंग

```python
import torch
from sam2.build_sam import build_sam2_video_predictor
import numpy as np

# SAM2.1 वीडियो प्रेडिक्टर आरंभ करें (बेहतर ट्रैकिंग सटीकता)
checkpoint = "./checkpoints/sam2.1_hiera_large.pt"
model_cfg = "configs/sam2.1/sam2.1_hiera_l.yaml"

predictor = build_sam2_video_predictor(model_cfg, checkpoint, device="cuda")

# वीडियो के साथ आरंभ करें
video_path = "./video_frames"  # फ्रेम छवियों की डायरेक्टरी
inference_state = predictor.init_state(video_path=video_path)

# पहले फ्रेम पर बिंदु जोड़ें
predictor.reset_state(inference_state)
frame_idx = 0
obj_id = 1  # ट्रैकिंग के लिए ऑब्जेक्ट ID

points = np.array([[400, 300]], dtype=np.float32)
labels = np.array([1], dtype=np.int32)

# ट्रैक करने के लिए ऑब्जेक्ट जोड़ें
_, out_obj_ids, out_mask_logits = predictor.add_new_points_or_box(
    inference_state=inference_state,
    frame_idx=frame_idx,
    obj_id=obj_id,
    points=points,
    labels=labels
)

# वीडियो के माध्यम से प्रसारित करें
video_segments = {}
for out_frame_idx, out_obj_ids, out_mask_logits in predictor.propagate_in_video(inference_state):
    video_segments[out_frame_idx] = {
        obj_id: (out_mask_logits[i] > 0.0).cpu().numpy()
        for i, obj_id in enumerate(out_obj_ids)
    }
```

## कई ऑब्जेक्ट ट्रैकिंग

```python
import torch
from sam2.build_sam import build_sam2_video_predictor
import numpy as np

predictor = build_sam2_video_predictor(
    "configs/sam2.1/sam2.1_hiera_l.yaml",
    "./checkpoints/sam2.1_hiera_large.pt",
    device="cuda"
)

video_path = "./video_frames"
inference_state = predictor.init_state(video_path=video_path)

# कई ऑब्जेक्ट्स को ट्रैक करें
objects_to_track = [
    {"id": 1, "point": [200, 150], "frame": 0},  # व्यक्ति 1
    {"id": 2, "point": [400, 200], "frame": 0},  # व्यक्ति 2
    {"id": 3, "point": [600, 300], "frame": 0},  # गेंद
]

for obj in objects_to_track:
    predictor.add_new_points_or_box(
        inference_state=inference_state,
        frame_idx=obj["frame"],
        obj_id=obj["id"],
        points=np.array([obj["point"]], dtype=np.float32),
        labels=np.array([1], dtype=np.int32)
    )

# सभी ऑब्जेक्ट्स को प्रसारित करें
all_masks = {}
for frame_idx, obj_ids, mask_logits in predictor.propagate_in_video(inference_state):
    all_masks[frame_idx] = {}
    for i, obj_id in enumerate(obj_ids):
        all_masks[frame_idx][obj_id] = (mask_logits[i] > 0.0).cpu().numpy()
```

## बॉक्स प्रॉम्प्ट सेगमेंटेशन

```python
from sam2.build_sam import build_sam2
from sam2.sam2_image_predictor import SAM2ImagePredictor
import numpy as np
from PIL import Image

sam2 = build_sam2(
    "configs/sam2.1/sam2.1_hiera_l.yaml",
    "./checkpoints/sam2.1_hiera_large.pt",
    device="cuda"
)
predictor = SAM2ImagePredictor(sam2)

image = np.array(Image.open("image.jpg"))
predictor.set_image(image)

# बाउंडिंग बॉक्स के साथ सेगमेंट करें
box = np.array([100, 100, 400, 400])  # x1, y1, x2, y2

masks, scores, _ = predictor.predict(
    box=box,
    multimask_output=False
)
```

## Gradio इंटरफ़ेस

```python
import gradio as gr
import numpy as np
from PIL import Image
import torch
from sam2.build_sam import build_sam2
from sam2.sam2_image_predictor import SAM2ImagePredictor

sam2 = build_sam2(
    "configs/sam2.1/sam2.1_hiera_l.yaml",
    "./checkpoints/sam2.1_hiera_large.pt",
    device="cuda"
)
predictor = SAM2ImagePredictor(sam2)

def segment_image(image, x, y):
    predictor.set_image(np.array(image))

    masks, scores, _ = predictor.predict(
        point_coords=np.array([[x, y]]),
        point_labels=np.array([1]),
        multimask_output=True
    )

    best_mask = masks[scores.argmax()]

    # ओवरले बनाएं
    overlay = np.array(image).copy()
    overlay[best_mask] = overlay[best_mask] * 0.5 + np.array([255, 0, 0]) * 0.5

    return Image.fromarray(overlay.astype(np.uint8))

demo = gr.Interface(
    fn=segment_image,
    inputs=[
        gr.Image(type="pil", label="Input Image"),
        gr.Number(label="X निर्देशांक"),
        gr.Number(label="Y निर्देशांक")
    ],
    outputs=gr.Image(label="सेगमेंट की गई छवि"),
    title="SAM2 - किसी भी चीज़ को सेगमेंट करें",
    description="वस्तुओं को सेगमेंट करने के लिए निर्देशांकों पर क्लिक करें। CLORE.AI GPU सर्वरों पर चल रहा है."
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## मास्क को वीडियो के रूप में निर्यात करें

```python
import cv2
import numpy as np
from sam2.build_sam import build_sam2_video_predictor

predictor = build_sam2_video_predictor(
    "configs/sam2.1/sam2.1_hiera_l.yaml",
    "./checkpoints/sam2.1_hiera_large.pt",
    device="cuda"
)

# ... (ऊपर से ट्रैकिंग कोड)

# वीडियो में निर्यात करें
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter('output_masks.mp4', fourcc, 30.0, (width, height))

for frame_idx in sorted(video_segments.keys()):
    frame = cv2.imread(f"./video_frames/{frame_idx:05d}.jpg")

    # मास्क ओवरले लागू करें
    for obj_id, mask in video_segments[frame_idx].items():
        color = [0, 255, 0] if obj_id == 1 else [0, 0, 255]
        frame[mask.squeeze()] = frame[mask.squeeze()] * 0.5 + np.array(color) * 0.5

    out.write(frame.astype(np.uint8))

out.release()
```

## प्रदर्शन

| कार्य                | रिज़ॉल्यूशन | GPU      | गति  |
| -------------------- | ----------- | -------- | ---- |
| छवि सेगमेंटेशन       | 1024x1024   | RTX 3090 | 50ms |
| छवि सेगमेंटेशन       | 1024x1024   | RTX 4090 | 30ms |
| वीडियो (प्रति फ्रेम) | 720p        | RTX 4090 | 45ms |
| वीडियो (प्रति फ्रेम) | 1080p       | A100     | 35ms |

## मॉडल प्रकार (SAM2.1)

SAM2.1 नए `sam2.1_hiera_*` बेहतर वीडियो ट्रैकिंग सटीकता वाले चेकपॉइंट्स प्रस्तुत करता है:

| मॉडल                      | पैरामीटर | VRAM     | गति       | गुणवत्ता      | चेकपॉइंट                     |
| ------------------------- | -------- | -------- | --------- | ------------- | ---------------------------- |
| sam2.1\_hiera\_tiny       | 38M      | 4GB      | सबसे तेज़ | अच्छा         | sam2.1\_hiera\_tiny.pt       |
| sam2.1\_hiera\_small      | 46M      | 5GB      | तेज़      | बेहतर         | sam2.1\_hiera\_small.pt      |
| sam2.1\_hiera\_base\_plus | 80M      | 8GB      | मध्यम     | उत्कृष्ट      | sam2.1\_hiera\_base\_plus.pt |
| **sam2.1\_hiera\_large**  | **224M** | **12GB** | **धीमा**  | **सर्वोत्तम** | **sam2.1\_hiera\_large.pt**  |

> **ध्यान दें:** SAM2.1 मॉडल वीडियो बेंचमार्क्स पर अपने SAM2 समकक्षों से लगातार बेहतर प्रदर्शन करते हैं, विशेष रूप से तेज़ चलने वाले ऑब्जेक्ट्स और लंबे ऑक्लूज़न के लिए।

## सामान्य समस्याएँ और समाधान

### मेमोरी समाप्त

**समस्या:** लंबे वीडियो पर CUDA मेमोरी समाप्त हो गई

**समाधान:**

```python

# टुकड़ों में प्रोसेस करें
chunk_size = 100  # फ्रेम प्रति चंक

for start_frame in range(0, total_frames, chunk_size):
    end_frame = min(start_frame + chunk_size, total_frames)
    # चंक प्रोसेस करें...
    torch.cuda.empty_cache()  # चंक्स के बीच मेमोरी साफ़ करें
```

### ट्रैकिंग खो गई

**समस्या:** ऑब्जेक्ट ट्रैकिंग वीडियो के बीच में विफल हो जाती है

**समाधान:**

* जब ट्रैकिंग भटकने लगे तो सुधार बिंदु जोड़ें
* बेहतर प्रारंभिक सेगमेंटेशन के लिए बॉक्स प्रॉम्प्ट का उपयोग करें
* अधिक स्पष्ट प्रारंभिक फ्रेम चुनें

```python

# सुधार बिंदु जोड़ें
predictor.add_new_points_or_box(
    inference_state=inference_state,
    frame_idx=lost_frame,
    obj_id=obj_id,
    points=np.array([[new_x, new_y]], dtype=np.float32),
    labels=np.array([1], dtype=np.int32)
)
```

### धीमी प्रोसेसिंग

**समस्या:** वीडियो प्रोसेसिंग बहुत धीमी है

**समाधान:**

* छोटे मॉडल प्रकार (tiny/small) का उपयोग करें
* वीडियो रेज़ोल्यूशन कम करें
* हाफ-प्रिसिजन (fp16) सक्षम करें
* A100 GPU पर प्रोसेस करें

```python

# गति के लिए छोटा SAM2.1 मॉडल उपयोग करें
predictor = build_sam2_video_predictor(
    "configs/sam2.1/sam2.1_hiera_t.yaml",
    "./checkpoints/sam2.1_hiera_tiny.pt",
    device="cuda"
)
```

### खराब मास्क गुणवत्ता

**समस्या:** सेगमेंटेशन किनारे खुरदरे हैं

**समाधान:**

* बड़ा मॉडल उपयोग करें (tiny के बजाय large)
* अधिक पॉइंट प्रॉम्प्ट जोड़ें
* पॉइंट और बॉक्स प्रॉम्प्ट्स को मिलाएं

## समस्या निवारण

### सेगमेंटेशन अशुद्ध

* लक्षित ऑब्जेक्ट पर अधिक सटीक क्लिक करें
* कई सकारात्मक/नकारात्मक बिंदु जोड़ें
* बड़े ऑब्जेक्ट्स के लिए बॉक्स प्रॉम्प्ट का उपयोग करें

### वीडियो मेमोरी त्रुटि

* एक बार में कम फ्रेम प्रोसेस करें
* वीडियो रेज़ोल्यूशन कम करें
* लंबे वीडियो के लिए स्ट्रीमिंग मोड का उपयोग करें

### ट्रैकिंग खो गई

* जब ऑब्जेक्ट बदल जाए तो और प्रॉम्प्ट जोड़ें
* मेमोरी बैंक फीचर का उपयोग करें
* जांचें कि ऑब्जेक्ट ऑक्लूडेड नहीं है

### धीमी प्रोसेसिंग

* SAM2 संसाधन-गहन है
* लंबे वीडियो के लिए A100 का उपयोग करें
* फ्रेम स्किपिंग पर विचार करें

## लागत का अनुमान

CLORE.AI मार्केटप्लेस की सामान्य दरें (2024 तक):

| GPU       | प्रति घंटा दर | प्रति दिन दर | 4-घंटे का सत्र |
| --------- | ------------- | ------------ | -------------- |
| RTX 3060  | \~$0.03       | \~$0.70      | \~$0.12        |
| RTX 3090  | \~$0.06       | \~$1.50      | \~$0.25        |
| RTX 4090  | \~$0.10       | \~$2.30      | \~$0.40        |
| A100 40GB | \~$0.17       | \~$4.00      | \~$0.70        |
| A100 80GB | \~$0.25       | \~$6.00      | \~$1.00        |

*मूल्य प्रदाता और मांग के अनुसार बदलते हैं। देखें* [*CLORE.AI मार्केटप्लेस*](https://clore.ai/marketplace) *वर्तमान दरों के लिए।*

**पैसे बचाएँ:**

* का उपयोग करें **स्पॉट** बाधित किए जा सकने वाले कार्य के लिए मार्केट — लगभग एक-तिहाई सर्वरों की स्पॉट कीमत ऑन-डिमांड से कम होती है (मध्य \~13% छूट), बाकी उससे मेल खाते हैं
* से भुगतान करें **CLORE** टोकन
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## अगले चरण

* [GroundingDINO](/guides/guides_v2-hi/vision-models/groundingdino.md) - सेगमेंट करने के लिए ऑब्जेक्ट्स को स्वतः पहचानें
* [Florence-2](/guides/guides_v2-hi/vision-models/florence2.md) - दृष्टि-भाषा समझ
* [Depth Anything](/guides/guides_v2-hi/image-processing/depth-anything.md) - गहराई अनुमान


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/vision-models/sam2-video.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.