SAM2 वीडियो

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

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

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

इस मार्गदर्शिका के सभी उदाहरणों को GPU सर्वरों पर चलाया जा सकता है जिन्हें के माध्यम से किराए पर लिया जाता है CLORE.AI मार्केटप्लेस मार्केटप्लेस।

CLORE.AI पर किराये पर लेना

1. पर जाएँ CLORE.AI मार्केटप्लेस

2. GPU प्रकार, VRAM, और मूल्य के अनुसार फ़िल्टर करें

3. चुनें ऑन-डिमांड (निश्चित दर) या स्पॉट (बिड प्राइस)

4. अपना ऑर्डर कॉन्फ़िगर करें:

   • Docker इमेज चुनें

   • पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)

   • यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें

   • स्टार्टअप कमांड दर्ज करें

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

• पेपर: SAM2 पेपर

• डेमो: SAM2 डेमो

• मॉडल वेट्स: SAM2.1 चेकपॉइंट्स

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

घटक	न्यूनतम	अनुशंसित	सर्वोत्तम
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.5.1-cuda12.4-cudnn9-devel

पोर्ट:

22/tcp
7860/http

कमांड:

cd /workspace && \
pip install sam-2 && \
python -c "from sam2.build_sam import build_sam2; print('SAM2.1 ready!')"

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

डिप्लॉयमेंट के बाद, अपना खोजें http_pub URL में मेरे ऑर्डर:

1. जाएँ मेरे ऑर्डर पृष्ठ

2. अपने ऑर्डर पर क्लिक करें

3. खोजें http_pub URL (उदा., abc123.clorecloud.net)

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

इंस्टॉलेशन

# आधिकारिक 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

विकल्प: स्रोत से (विकास के लिए)

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 सामग्री निर्माण

मूल उपयोग

इमेज सेगमेंटेशन

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

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

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

मल्टी-ऑब्जेक्ट ट्रैकिंग

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

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

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 इंटरफ़ेस

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="इनपुट इमेज"),
        gr.Number(label="X coordinate"),
        gr.Number(label="Y coordinate")
    ],
    outputs=gr.Image(label="Segmented Image"),
    title="SAM2 - Segment Anything",
    description="ऑब्जेक्ट सेगमेंट करने के लिए निर्देशांक क्लिक करें। CLORE.AI GPU सर्वरों पर चल रहा है।"
)

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

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

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 आउट ऑफ़ मेमोरी

समाधान:

# चंक्स में प्रोसेस करें
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()  # चंक के बीच मेमोरी साफ़ करें

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

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

समाधान:

• जब ट्रैकिंग ड्रिफ्ट करे तो करेक्ट्शन पॉइंट्स जोड़ें

• बेहतर प्रारंभिक सेगमेंटेशन के लिए बॉक्स प्रॉम्प्ट का उपयोग करें

• क्लियर प्रारंभिक फ्रेम चुनें

# करेक्ट्शन पॉइंट जोड़ें
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 पर प्रोसेस करें

# गति के लिए छोटा 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 मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)

• भुगतान करें CLORE टोकन के साथ

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले कदम

• GroundingDINO - स्वचालित रूप से सेगमेंट करने के लिए ऑब्जेक्ट्स का पता लगाना

• Florence-2 - विजन-लैंग्वेज समझ

• Depth Anything - डेप्थ अनुमान