> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-vision/sam2-video.md).

# 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.

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

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

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
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](https://github.com/facebookresearch/sam2)
* **Artículo:** [Artículo de SAM2](https://arxiv.org/abs/2408.00714)
* **Demo:** [Demostración 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 de Docker:**

```
pytorch/pytorch:2.11.0-cuda12.8-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 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

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

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

* 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

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

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

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

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

# 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

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

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

```python

# 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

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

* 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

```python

# 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*](https://clore.ai/marketplace) *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](/guides/guides_v2-es/modelos-de-vision/groundingdino.md) - Detectar automáticamente 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.