> 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-ru/modeli-dlya-zreniya/sam2-video.md).

# SAM2 Video

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

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

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

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

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

1. Перейдите на [маркетплейс CLORE.AI](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      | 8 ГБ          | 16GB          | 24 ГБ         |
| CPU       | 4 ядра        | 8 ядер        | 16 ядер       |
| ОЗУ       | 16GB          | 32GB          | 64GB          |
| Хранилище | 30GB SSD      | 50GB NVMe     | 100GB NVMe    |
| Интернет  | 100 Мбит/с    | 500 Мбит/с    | 1 Гбит/с      |

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

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

```
pytorch/pytorch:2.11.0-cuda12.8-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 готов!')"
```

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

После развертывания найдите свой `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
```

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

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

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

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

* Отслеживайте игроков на протяжении матчей
* Анализируйте схемы движения
* Создавайте нарезки лучших моментов

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

* Сегментируйте органы в видео КТ/МРТ
* Отслеживайте движение клеток в микроскопии
* Измеряйте рост с течением времени

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

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

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

* Ротоскопинг для 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()
```

## Сегментация по запросу с рамкой

```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 - Сегментируй что угодно",
    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       | 8 ГБ     | Средне        | Отлично         | 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 40 ГБ | \~$0.17          | \~$4.00        | \~$0.70          |
| A100 80 ГБ | \~$0.25          | \~$6.00        | \~$1.00          |

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

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

* Используйте **Spot** рынок для прерываемых задач — примерно треть серверов оценивает spot-цены ниже on-demand (медиана \~13% скидки), остальные совпадают с ними
* Платите **CLORE** токенами
* Сравните цены у разных провайдеров

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

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


---

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