# SAM2 Video

Отслеживайте и сегментируйте любые объекты в видео с помощью SAM2.1 от Meta — улучшенной версии SAM2 с повышенной точностью для видео.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Все примеры в этом руководстве можно запустить на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace) маркетплейс.
{% endhint %}

## Аренда на CLORE.AI

1. Посетите [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Отфильтруйте по типу GPU, объему VRAM и цене
3. Выберите **On-Demand** (фиксированная ставка) или **Spot** (цена по ставке)
4. Настройте ваш заказ:
   * Выберите Docker-образ
   * Установите порты (TCP для SSH, HTTP для веб-интерфейсов)
   * Добавьте переменные окружения при необходимости
   * Введите команду запуска
5. Выберите способ оплаты: **CLORE**, **BTC**, или **USDT/USDC**
6. Создайте заказ и дождитесь развертывания

### Доступ к вашему серверу

* Найдите данные для подключения в **Моих заказах**
* Веб-интерфейсы: используйте URL HTTP-порта
* SSH: `ssh -p <port> root@<proxy-address>`

## Что такое SAM2?

SAM2 (Segment Anything Model 2) от Meta AI позволяет:

* Сегментация объектов в видео в реальном времени
* Клик — чтобы отслеживать любой объект
* Последовательное отслеживание при окклюзиях
* Памятееффективная обработка видео

## Что нового в SAM2.1

SAM2.1 приносит значительные улучшения по сравнению с оригинальным SAM2:

* **Улучшенная точность для видео** — Лучше отслеживает при окклюзиях и быстром движении
* **Усовершенствованный модуль памяти** — Более стабильное долгосрочное отслеживание
* **Новые контрольные точки** — `серия sam2.1_hiera_*` с лучшей производительностью
* **Официальный пакет pip** — Установите с помощью `pip install sam-2` (ручная сборка не требуется)
* **Более быстрое инференсирование** — Оптимизированные CUDA-ядра

## Ресурсы

* **GitHub:** [facebookresearch/sam2](https://github.com/facebookresearch/sam2)
* **Статья:** [Статья о SAM2](https://arxiv.org/abs/2408.00714)
* **Демо:** [Демонстрация SAM2](https://sam2.metademolab.com/)
* **Весовые файлы модели:** [Контрольные точки SAM2.1](https://github.com/facebookresearch/sam2#model-checkpoints)

## Рекомендованное оборудование

| Компонент | Минимум       | Рекомендуется | Оптимально    |
| --------- | ------------- | ------------- | ------------- |
| GPU       | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM      | 8GB           | 16GB          | 24 ГБ         |
| CPU       | 4 ядра        | 8 ядер        | 16 ядер       |
| ОЗУ       | 16GB          | 32GB          | 64GB          |
| Хранилище | 30GB SSD      | 50GB NVMe     | 100GB NVMe    |
| Интернет  | 100 Мбит/с    | 500 Мбит/с    | 1 Гбит/с      |

## Быстрое развертывание на CLORE.AI

**Docker-образ:**

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

**Порты:**

```
22/tcp
7860/http
```

**Команда:**

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

## Доступ к вашему сервису

После развертывания найдите ваш `http_pub` URL в **Моих заказах**:

1. Перейдите на **Моих заказах** страницу
2. Нажмите на ваш заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

## Установка

```bash
# Официальный пакет pip (рекомендуется для SAM2.1)
pip install sam-2

# Скачать контрольные точки 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'),
]
"

# Или используйте скрипт загрузки
mkdir -p checkpoints && cd checkpoints
wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt
```

### Альтернатива: из исходников (для разработки)

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

# Скачать контрольные точки SAM2.1
cd checkpoints
bash download_ckpts.sh
```

## Что вы можете создать

### Редактирование видео

* Удалять объекты из видео
* Бесшовно заменять фоны
* Создавать маски для композитинга видео

### Анализ спорта

* Отслеживать игроков в матчах
* Анализировать шаблоны движения
* Генерировать ролики с моментами

### Медицинская визуализация

* Сегментировать органы на CT/MRI-видео
* Отслеживать движение клеток в микроскопии
* Измерять рост со временем

### Наблюдение и безопасность

* Отслеживать объекты между камерами
* Считать людей/транспорт
* Обнаружение аномалий

### Творческие проекты

* Ротоскопинг для VFX
* Интерактивные видеоинсталляции
* Создание контента для AR/VR

## Базовое использование

### Сегментация изображений

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

# Загрузить модель SAM2.1 (улучшенная точность по сравнению с 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)

# Загрузить изображение
image = np.array(Image.open("image.jpg"))
predictor.set_image(image)

# Сегментировать с подсказкой в виде точки
point_coords = np.array([[500, 375]])  # координаты x, y
point_labels = np.array([1])  # 1 = передний план

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

# Получить лучшую маску
best_mask = masks[scores.argmax()]
```

### Отслеживание объектов в видео

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

# Инициализировать видеопрогнозер SAM2.1 (улучшенная точность отслеживания)
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")

# Инициализация с видео
video_path = "./video_frames"  # Каталог с кадрами
inference_state = predictor.init_state(video_path=video_path)

# Добавить точку на первом кадре
predictor.reset_state(inference_state)
frame_idx = 0
obj_id = 1  # ID объекта для отслеживания

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

# Добавить объект для отслеживания
_, 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
)

# Пропагировать через видео
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)
    }
```

## Отслеживание нескольких объектов

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

# Отслеживать несколько объектов
objects_to_track = [
    {"id": 1, "point": [200, 150], "frame": 0},  # Человек 1
    {"id": 2, "point": [400, 200], "frame": 0},  # Человек 2
    {"id": 3, "point": [600, 300], "frame": 0},  # Мяч
]

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

# Пропагировать все объекты
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()
```

## Сегментация по рамке (Box Prompt)

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

# Сегментировать с ограничивающей рамкой
box = np.array([100, 100, 400, 400])  # x1, y1, x2, y2

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

## Интерфейс 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()]

    # Создать наложение
    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="Входное изображение"),
        gr.Number(label="Координата X"),
        gr.Number(label="Координата Y")
    ],
    outputs=gr.Image(label="Сегментированное изображение"),
    title="SAM2 - Segment Anything",
    description="Кликните по координатам, чтобы сегментировать объекты. Запуск на GPU-серверах CLORE.AI."
)

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

## Экспорт масок как видео

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

# ... (код отслеживания из выше)

# Экспорт в видео
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")

    # Применить наложение маски
    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()
```

## Производительность

| Задача                  | Разрешение | GPU      | Скорость |
| ----------------------- | ---------- | -------- | -------- |
| Сегментация изображений | 1024x1024  | RTX 3090 | 50 мс    |
| Сегментация изображений | 1024x1024  | RTX 4090 | 30мс     |
| Видео (на кадр)         | 720p       | RTX 4090 | 45мс     |
| Видео (на кадр)         | 1080p      | A100     | 35мс     |

## Варианты моделей (SAM2.1)

SAM2.1 представляет новые `серия sam2.1_hiera_*` контрольные точки с улучшенной точностью отслеживания в видео:

| Модель                    | Параметры | VRAM     | Скорость      | Качество   | Контрольная точка            |
| ------------------------- | --------- | -------- | ------------- | ---------- | ---------------------------- |
| sam2.1\_hiera\_tiny       | 38M       | 4 ГБ     | Самая быстрая | Хорошо     | sam2.1\_hiera\_tiny.pt       |
| sam2.1\_hiera\_small      | 46M       | 5 ГБ     | Быстро        | Лучше      | sam2.1\_hiera\_small.pt      |
| sam2.1\_hiera\_base\_plus | 80M       | 8GB      | Средне        | Отлично    | sam2.1\_hiera\_base\_plus.pt |
| **sam2.1\_hiera\_large**  | **224M**  | **12GB** | **Медленнее** | **Лучшее** | **sam2.1\_hiera\_large.pt**  |

> **Примечание:** Модели SAM2.1 стабильно превосходят свои аналоги SAM2 по видео-бенчмаркам, особенно для быстро движущихся объектов и длительных окклюзий.

## Распространённые проблемы и решения

### Недостаточно памяти

**Проблема:** Ошибка CUDA: недостаточно памяти на длинных видео

**Решения:**

```python

# Обрабатывать по кускам
chunk_size = 100  # кадров в чанке

for start_frame in range(0, total_frames, chunk_size):
    end_frame = min(start_frame + chunk_size, total_frames)
    # Обработать чанк...
    torch.cuda.empty_cache()  # Очистить память между чанками
```

### Потеря отслеживания

**Проблема:** Отслеживание объекта прерывается в середине видео

**Решения:**

* Добавьте корректирующие точки, когда отслеживание уходит в дрейф
* Используйте подсказки в виде рамки для лучшей начальной сегментации
* Выбирайте более четкие начальные кадры

```python

# Добавить корректирующую точку
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)
)
```

### Медленная обработка

**Проблема:** Обработка видео слишком медленная

**Решения:**

* Используйте меньший вариант модели (tiny/small)
* Уменьшите разрешение видео
* Включите половинную точность (fp16)
* Обрабатывайте на GPU A100

```python

# Использовать меньшую модель SAM2.1 для скорости
predictor = build_sam2_video_predictor(
    "configs/sam2.1/sam2.1_hiera_t.yaml",
    "./checkpoints/sam2.1_hiera_tiny.pt",
    device="cuda"
)
```

### Плохое качество масок

**Проблема:** Границы сегментации грубые

**Решения:**

* Используйте большую модель (large вместо tiny)
* Добавьте больше точечных подсказок
* Комбинируйте точечные и рамочные подсказки

## Устранение неполадок

### Сегментация неточная

* Кликайте точнее по целевому объекту
* Добавьте несколько положительных/отрицательных точек
* Используйте рамочную подсказку для больших объектов

### Ошибка памяти при обработке видео

* Обрабатывайте меньше кадров за раз
* Уменьшите разрешение видео
* Используйте потоковый режим для длинных видео

### Отслеживание потеряно

* Добавляйте больше подсказок, когда объект меняется
* Используйте функцию банка памяти
* Проверьте, что объект не закрыт

### Медленная обработка

* SAM2 требует больших вычислений
* Используйте A100 для длинных видео
* Рассмотрите пропуск кадров

## Оценка стоимости

Типичные ставки на маркетплейсе CLORE.AI (по состоянию на 2024):

| GPU       | Почасовая ставка | Дневная ставка | Сессия 4 часа |
| --------- | ---------------- | -------------- | ------------- |
| 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       |

*Цены варьируются в зависимости от провайдера и спроса. Проверьте* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *для текущих тарифов.*

**Экономьте деньги:**

* Используйте **Spot** рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)
* Платите с помощью **CLORE** токенов
* Сравнивайте цены у разных провайдеров

## Дальнейшие шаги

* [GroundingDINO](/guides/guides_v2-ru/modeli-zreniya/groundingdino.md) - Автообнаружение объектов для сегментации
* [Florence-2](/guides/guides_v2-ru/modeli-zreniya/florence2.md) - Понимание на стыке зрения и языка
* [Depth Anything](/guides/guides_v2-ru/obrabotka-izobrazhenii/depth-anything.md) - Оценка глубины


---

# 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-ru/modeli-zreniya/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.