# 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](https://docs.clore.ai/guides/guides_v2-ru/modeli-zreniya/groundingdino) - Автообнаружение объектов для сегментации
* [Florence-2](https://docs.clore.ai/guides/guides_v2-ru/modeli-zreniya/florence2) - Понимание на стыке зрения и языка
* [Depth Anything](https://docs.clore.ai/guides/guides_v2-ru/obrabotka-izobrazhenii/depth-anything) - Оценка глубины