# Video SAM2

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.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Todos los ejemplos en esta guía se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace) mercado.
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://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](https://github.com/facebookresearch/sam2)
* **Artículo:** [Artículo de SAM2](https://arxiv.org/abs/2408.00714)
* **Demostración:** [Demo de SAM2](https://sam2.metademolab.com/)
* **Pesos del modelo:** [Puntos de control de SAM2.1](https://github.com/facebookresearch/sam2#model-checkpoints)

## 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:**

```bash
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

```bash
# 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)

```bash
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

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

# 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

```python
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

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

# 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

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

# 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

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

    # 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

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

# ... (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:**

```python

# 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

```python

# 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

```python

# 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*](https://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](https://docs.clore.ai/guides/guides_v2-es/modelos-de-vision/groundingdino) - Detección automática de objetos para segmentar
* [Florence-2](https://docs.clore.ai/guides/guides_v2-es/modelos-de-vision/florence2) - Comprensión visión-lenguaje
* [Depth Anything](https://docs.clore.ai/guides/guides_v2-es/procesamiento-de-imagenes/depth-anything) - Estimación de profundidad