SAM2 Video

Seguimiento y segmentación de objetos en video con SAM2 de Meta en Clore.ai

Realice el seguimiento y segmentación de cualquier objeto en video con SAM2.1 de Meta: la versión mejorada de SAM2 con mayor precisión en video.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Todos los ejemplos en esta guía se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace mercado.

Alquilar en CLORE.AI

1. Visita CLORE.AI Marketplace

2. Filtrar por tipo de GPU, VRAM y precio

3. Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)

4. Configura tu pedido:

   • Selecciona imagen Docker

   • Establece puertos (TCP para SSH, HTTP para interfaces web)

   • Agrega variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera el despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis Pedidos

• Interfaces web: Usa la URL del puerto HTTP

• SSH: ssh -p <port> root@<proxy-address>

¿Qué es SAM2?

SAM2 (Segment Anything Model 2) de Meta AI permite:

• Segmentación de objetos en video en tiempo real

• Hacer clic para rastrear cualquier objeto

• Seguimiento consistente a través de oclusiones

• Procesamiento de video eficiente en memoria

Novedades en SAM2.1

SAM2.1 aporta mejoras significativas sobre el SAM2 original:

• Precisión mejorada en video — Mejor seguimiento a través de oclusiones y movimientos rápidos

• Módulo de memoria mejorado — Seguimiento a largo plazo más consistente

• Nuevos puntos de control — serie sam2.1_hiera_* con mejor rendimiento

• Paquete pip oficial — Instalar con pip install sam-2 (no se requiere compilación manual)

• Inferencia más rápida — Kernels CUDA optimizados

Recursos

• GitHub: facebookresearch/sam2

• Artículo: Artículo de SAM2

• Demostración: Demo de SAM2

• Pesos del modelo: Puntos de control de SAM2.1

Hardware recomendado

Componente	Mínimo	Recomendado	Óptimo
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	8GB	16GB	24GB
CPU	4 núcleos	8 núcleos	16 núcleos
RAM	16GB	32GB	64GB
Almacenamiento	30GB SSD	50GB NVMe	100GB NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Despliegue rápido en CLORE.AI

Imagen Docker:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Puertos:

22/tcp
7860/http

Comando:

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

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Instalación

# Paquete pip oficial (recomendado para SAM2.1)
pip install sam-2

# Descargar puntos de control de 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'),
]
"

# O use el script de descarga
mkdir -p checkpoints && cd checkpoints
wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt

Alternativa: Desde el código fuente (para desarrollo)

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

# Descargar puntos de control de SAM2.1
cd checkpoints
bash download_ckpts.sh

Lo que puedes crear

Edición de video

• Eliminar objetos de videos

• Reemplazar fondos sin interrupciones

• Crear máscaras de video para composición

Análisis deportivo

• Rastrear jugadores durante los partidos

• Analizar patrones de movimiento

• Generar resúmenes de jugadas

Imágenes médicas

• Segmentar órganos en videos de TAC/RM

• Rastrear movimiento celular en microscopía

• Medir crecimiento a lo largo del tiempo

Vigilancia y seguridad

• Rastrear objetos entre cámaras

• Contar personas/vehículos

• Detección de anomalías

Proyectos creativos

• Rotoscopia para VFX

• Instalaciones de video interactivas

• Creación de contenido AR/VR

Uso básico

Segmentación de imágenes

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

# Cargar el modelo SAM2.1 (precisión mejorada respecto a 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)

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

# Segmentar con indicación por punto
point_coords = np.array([[500, 375]])  # coordenadas x, y
point_labels = np.array([1])  # 1 = primer plano

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

# Obtener la mejor máscara
best_mask = masks[scores.argmax()]

Seguimiento de objetos en video

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

# Inicializar el predictor de video SAM2.1 (precisión de seguimiento mejorada)
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")

# Inicializar con video
video_path = "./video_frames"  # Directorio con imágenes de fotogramas
inference_state = predictor.init_state(video_path=video_path)

# Añadir punto en el primer fotograma
predictor.reset_state(inference_state)
frame_idx = 0
obj_id = 1  # ID del objeto para rastrear

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

# Añadir objeto para rastrear
_, 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
)

# Propagar a través del video
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)
    }

Seguimiento multiobjeto

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)

# Rastrear varios objetos
objects_to_track = [
    {"id": 1, "point": [200, 150], "frame": 0},  # Persona 1
    {"id": 2, "point": [400, 200], "frame": 0},  # Persona 2
    {"id": 3, "point": [600, 300], "frame": 0},  # Balón
]

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

# Propagar todos los objetos
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()

Segmentación con indicación de caja

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)

# Segmentar con cuadro delimitador
box = np.array([100, 100, 400, 400])  # x1, y1, x2, y2

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

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

    # Crear superposición
    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="Imagen de entrada"),
        gr.Number(label="Coordenada X"),
        gr.Number(label="Coordenada Y")
    ],
    outputs=gr.Image(label="Imagen segmentada"),
    title="SAM2 - Segment Anything",
    description="Haga clic en las coordenadas para segmentar objetos. Ejecutándose en servidores GPU de CLORE.AI."
)

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

Exportar máscaras como video

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

# ... (código de seguimiento de arriba)

# Exportar a video
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")

    # Aplicar superposición de máscara
    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()

Rendimiento

Tarea	Resolución	GPU	Velocidad
Segmentación de imágenes	1024x1024	RTX 3090	50ms
Segmentación de imágenes	1024x1024	RTX 4090	30 ms
Video (por fotograma)	720p	RTX 4090	45 ms
Video (por fotograma)	1080p	A100	35ms

Variantes del modelo (SAM2.1)

SAM2.1 introduce nuevos serie sam2.1_hiera_* puntos de control con precisión de seguimiento en video mejorada:

Modelo	Parámetros	VRAM	Velocidad	Calidad	Punto de control
sam2.1_hiera_tiny	38M	4GB	El más rápido	Bueno	sam2.1_hiera_tiny.pt
sam2.1_hiera_small	46M	5GB	Rápido	Mejor	sam2.1_hiera_small.pt
sam2.1_hiera_base_plus	80M	8GB	Medio	Genial	sam2.1_hiera_base_plus.pt
sam2.1_hiera_large	224M	12GB	Más lento	Mejor	sam2.1_hiera_large.pt

Nota: Los modelos SAM2.1 superan de manera consistente a sus homólogos SAM2 en benchmarks de video, especialmente para objetos que se mueven rápido y oclusiones prolongadas.

Problemas comunes y soluciones

Memoria insuficiente

Problema: CUDA fuera de memoria en videos largos

Soluciones:

# Procesar en fragmentos
chunk_size = 100  # fotogramas por fragmento

for start_frame in range(0, total_frames, chunk_size):
    end_frame = min(start_frame + chunk_size, total_frames)
    # Procesar fragmento...
    torch.cuda.empty_cache()  # Limpiar memoria entre fragmentos

Seguimiento perdido

Problema: El seguimiento de objetos falla a mitad del video

Soluciones:

• Añadir puntos de corrección cuando el seguimiento se desplace

• Usar indicaciones de caja para una mejor segmentación inicial

• Elegir fotogramas iniciales más claros

# Añadir punto de corrección
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)
)

Procesamiento lento

Problema: El procesamiento de video es demasiado lento

Soluciones:

• Usar una variante de modelo más pequeña (tiny/small)

• Reducir la resolución del video

• Habilite media precisión (fp16)

• Procesar en GPU A100

# Usar un modelo SAM2.1 más pequeño para velocidad
predictor = build_sam2_video_predictor(
    "configs/sam2.1/sam2.1_hiera_t.yaml",
    "./checkpoints/sam2.1_hiera_tiny.pt",
    device="cuda"
)

Mala calidad de máscaras

Problema: Los bordes de segmentación son irregulares

Soluciones:

• Usar un modelo más grande (large en lugar de tiny)

• Añadir más indicaciones por puntos

• Combinar indicaciones por punto y por caja

Solución de problemas

Segmentación inexacta

• Haga clic con más precisión en el objeto objetivo

• Añadir múltiples puntos positivos/negativos

• Usar indicación por caja para objetos grandes

Error de memoria de video

• Procesar menos fotogramas a la vez

• Reducir la resolución del video

• Usar modo de transmisión para videos largos

Seguimiento perdido

• Añadir más indicaciones cuando el objeto cambie

• Usar la función de banco de memoria

• Comprobar que el objeto no esté ocluido

Procesamiento lento

• SAM2 requiere mucha computación

• Usar A100 para videos largos

• Considerar omitir fotogramas

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
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

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

• Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)

• Paga con CLORE tokens

• Compara precios entre diferentes proveedores

Próximos pasos

• GroundingDINO - Detección automática de objetos para segmentar

• Florence-2 - Comprensión visión-lenguaje

• Depth Anything - Estimación de profundidad