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


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-vision/sam2-video.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.