SAM2 Video

Rastrea y segmenta objetos en video con SAM2 de Meta en Clore.ai

Rastrea y segmenta cualquier objeto a través de video con SAM2.1 de Meta — la versión mejorada de SAM2 con mayor precisión de video.

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

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

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

2. Filtra por tipo de GPU, VRAM y precio

3. Elige Bajo demanda (tarifa fija) o Spot (precio ofertado)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Añade variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el método de pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera al 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 de video en tiempo real

• Haz clic para rastrear cualquier objeto

• Seguimiento consistente a través de oclusiones

• Procesamiento de video eficiente en memoria

Novedades en SAM2.1

SAM2.1 trae mejoras significativas con respecto al SAM2 original:

• Precisión de video mejorada — Mejor seguimiento a través de oclusiones y movimiento rápido

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

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

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

• Inferencia más rápida — Núcleos CUDA optimizados

Recursos

• GitHub: facebookresearch/sam2

• Artículo: Artículo de SAM2

• Demo: Demostración 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 de Docker:

pytorch/pytorch:2.11.0-cuda12.8-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 listo!')"

Accediendo a tu servicio

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

1. Ve a Mis pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (p. ej., abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

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

• Elimina objetos de los videos

• Sustituye fondos sin problemas

• Crea máscaras de video para composición

Análisis deportivo

• Rastrea jugadores durante los partidos

• Analiza patrones de movimiento

• Genera resúmenes destacados

Imágenes médicas

• Segmenta órganos en videos de CT/MRI

• Rastrea el movimiento celular en microscopía

• Mide el crecimiento a lo largo del tiempo

Vigilancia y seguridad

• Rastrea objetos entre cámaras

• Cuenta 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 (mejor precisión que 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)

# Segmenta con una indicación de 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 (mejor precisión de seguimiento)
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 seguimiento

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

# Añadir objeto a seguir
_, 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 de múltiples objetos

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 múltiples 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},  # Pelota
]

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)

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

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

Interfaz de 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 - Segmenta cualquier cosa",
    description="Haz clic en las coordenadas para segmentar objetos. Se ejecuta 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 anterior)

# 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	30ms
Video (por fotograma)	720p	RTX 4090	45ms
Video (por fotograma)	1080p	A100	35 ms

Variantes del modelo (SAM2.1)

SAM2.1 introduce nuevos sam2.1_hiera_* puntos de control con precisión de seguimiento de 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	Excelente	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 forma consistente a sus equivalentes SAM2 en las pruebas de video, especialmente en objetos que se mueven rápidamente y oclusiones largas.

Problemas comunes y soluciones

Sin memoria

Problema: CUDA se queda sin memoria en videos largos

Soluciones:

# Procesar en fragmentos
chunk_size = 100  # fotogramas por bloque

for start_frame in range(0, total_frames, chunk_size):
    end_frame = min(start_frame + chunk_size, total_frames)
    # Procesar bloque...
    torch.cuda.empty_cache()  # Liberar memoria entre bloques

Seguimiento perdido

Problema: El seguimiento del objeto falla a mitad del video

Soluciones:

• Añade puntos de corrección cuando el seguimiento se desvíe

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

• Elige 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:

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

• Reduce la resolución del video

• Habilita precisión media (fp16)

• Procesa en una GPU A100

# Usa un modelo SAM2.1 más pequeño para mayor 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 la máscara

Problema: Los bordes de la segmentación son irregulares

Soluciones:

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

• Añade más indicaciones de puntos

• Combina indicaciones de puntos y de caja

Solución de problemas

Segmentación inexacta

• Haz clic con más precisión sobre el objeto objetivo

• Añade múltiples puntos positivos/negativos

• Usa una indicación de caja para objetos grandes

Error de memoria de video

• Procesa menos fotogramas a la vez

• Reduce la resolución del video

• Usa el modo de transmisión para videos largos

Seguimiento perdido

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

• Usa la función de banco de memoria

• Comprueba que el objeto no esté ocluido

Procesamiento lento

• SAM2 requiere mucho cómputo

• Usa una A100 para videos largos

• Considera omitir fotogramas

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir 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 Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa el Spot mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de ~13% de descuento), el resto lo iguala

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Siguientes pasos

• GroundingDINO - Detectar automáticamente objetos para segmentar

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

• Depth Anything - Estimación de profundidad