{/ Эта страница автоматически передается из навыков SKILL.md с помощью сайта/scripts/generate-skill-docs.py. Редактируйте исходный SKILL.md, а не эту страницу. /}

Сегментируйте любую модель

SAM: нулевая сегментация изображений по точкам, рамкам, маскам.

Метаданные навыки


Источник	Встроенный (устанавливается по умолчанию)
Путь	`навыки/млопсы/модели/сегмент-что-нибудь`
Версия	`1.0.0`
Автор	Исследование оркестра
Лицензия	Массачусетский технологический институт
Зависимости	`сегмент-что-нибудь`, `трансформеры>=4.30.0`, `факел>=1.7.0`
Платформы	Linux, MacOS, Windows
Теги	`Мультимодальный`, `Сегментация изображения`, `Компьютерное зрение`, `SAM`, `Zero-Shot`

Справочник: полный SKILL.md:::информация

Ниже приведено полное описание навыков, которые Hermes загружает при его активации. Агент увидит эту инструкцию, когда навыки активны.

Модель сегментации чего угодно (SAM)

Исчерпывающее руководство по использованию модели Segment Anything от Meta AI для нулевой сегментации изображений.

Когда использовать SAM

Используйте SAM, когда: - Необходимо сегментировать любой объект на изображениях без специального обучения под задачей. - Стройте интерактивные инструменты, аннотации с подсказками в виде точек/рамок. - Генерирует обучающие данные для других моделей компьютерного зрения. - Нужен нулевой перенос на новые изображения доменов. - Строите конвейеры обнаружения/сегментации объектов - Обработка медицинских, спутниковых или специализированных изображений.

Ключевые возможности: - Сегментация с нулевым выстрелом: работает на любом домене изображений без дообучения. - Гибкие подсказки: точки, ограничивающие рамки или рамки маски. - Автоматическая сегментация: автоматически все маскирует объекты. - Высокое качество: обучено на 1,1 миллиарда масок из 11 миллионов изображений. - Несколько размеров моделей: ViT-B (самая быстрая), ViT-L, ViT-H (самая точная) - Экспорт в ONNX: развёртывание в браузерах и на периферийных устройствах.

Вместо этого викор альтернативы: - YOLO/Detectron2: для обнаружения объектов в начале занятий - Mask2Former: для семантической/панорамной сегментации по категориям. - GroundingDINO + SAM: для сегментации по текстовому запросу. - SAM 2: для задач сегментации видео

Быстрый старт

Установка

# Из GitHub
pip install git+https://github.com/facebookresearch/segment-anything.git

# Опциональные зависимости
pip install opencv-python pycocotools matplotlib

# Или используйте HuggingFace transformers
pip install transformers

Загрузка контрольных пунктов

# ViT-H (самая большая, самая точная) - 2.4GB
wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth

# ViT-L (средняя) - 1.2GB
wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_l_0b3195.pth

# ViT-B (самая маленькая, самая быстрая) - 375MB
wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth

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

import numpy as np
from segment_anything import sam_model_registry, SamPredictor

# Загрузка модели
sam = sam_model_registry["vit_h"](https://github.com/NousResearch/hermes-agent/blob/main/skills/mlops/models/segment-anything/checkpoint="sam_vit_h_4b8939.pth")
sam.to(device="cuda")

# Создание предиктора
predictor = SamPredictor(sam)

# Установка изображения (вычисляет эмбеддинги один раз)
image = cv2.imread("image.jpg")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
predictor.set_image(image)

# Предсказание с точечными подсказками
input_point = np.array([[500, 375]])  # координаты (x, y)
input_label = np.array([1])  # 1 = передний план, 0 = фон

masks, scores, logits = predictor.predict(
    point_coords=input_point,
    point_labels=input_label,
    multimask_output=True  # Возвращает 3 варианта маски
)

# Выбор лучшей маски
best_mask = masks[np.argmax(scores)]

Трансформеры HuggingFace

import torch
from PIL import Image
from transformers import SamModel, SamProcessor

# Загрузка модели и процессора
model = SamModel.from_pretrained("facebook/sam-vit-huge")
processor = SamProcessor.from_pretrained("facebook/sam-vit-huge")
model.to("cuda")

# Обработка изображения с точечной подсказкой
image = Image.open("image.jpg")
input_points = [[[450, 600]]]  # Пакет точек

inputs = processor(image, input_points=input_points, return_tensors="pt")
inputs = {k: v.to("cuda") for k, v in inputs.items()}

# Генерация масок
with torch.no_grad():
    outputs = model(**inputs)

# Постобработка масок до исходного размера
masks = processor.image_processor.post_process_masks(
    outputs.pred_masks.cpu(),
    inputs["original_sizes"].cpu(),
    inputs["reshaped_input_sizes"].cpu()
)

Основные концепции

Архитектура модели

Архитектура SAM:
┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  Энкодер изображ.│────▶│ Энкодер подсказ.│────▶│  Декодер масок  │
│     (ViT)       │     │ (Точки/Рамки)   │     │ (Трансформер)   │
└─────────────────┘     └─────────────────┘     └─────────────────┘
        │                       │                       │
   Эмбеддинги изобр.     Эмбеддинги подсказ.      Маски + IoU
   (вычисляются один раз)  (на подсказку)        предсказания

Варианты моделей

Модель	Контрольная точка	Размер	Скорость	Точность
ВиТ-Х	`vit_h`	2,4 ГБ	Самая медленная	Лучший
ВИТ-Л	`vit_l`	1,2 ГБ	Средняя	Хороший
ВИТ-Б	`vit_b`	375 МБ	Самый быстрый	Хороший

Типы подсказок

Подсказка	Описание	Сценарий использования
Точка (передний план)	Клик по объекту	Выбор одного объекта
Точка (фон)	Клик вне объекта	Исключение области
Ограничивающая рамка	Прямоугольник вокруг объекта	Крупные объекты
Предыдущая маска	Входная маска низкого разрешения	Итеративное уточнение

Интерактивная сегментация

Точечные подсказки

# Одна точка переднего плана
input_point = np.array([[500, 375]])
input_label = np.array([1])

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

# Несколько точек (передний план + фон)
input_points = np.array([[500, 375], [600, 400], [450, 300]])
input_labels = np.array([1, 1, 0])  # 2 переднего плана, 1 фон

masks, scores, logits = predictor.predict(
    point_coords=input_points,
    point_labels=input_labels,
    multimask_output=False  # Одна маска, когда подсказки чёткие
)

Подсказки рамками

# Ограничивающая рамка [x1, y1, x2, y2]
input_box = np.array([425, 600, 700, 875])

masks, scores, logits = predictor.predict(
    box=input_box,
    multimask_output=False
)

Комбинированные подсказки

# Рамка + точки для точного контроля
masks, scores, logits = predictor.predict(
    point_coords=np.array([[500, 375]]),
    point_labels=np.array([1]),
    box=np.array([400, 300, 700, 600]),
    multimask_output=False
)

Итеративное определение

# Первоначальное предсказание
masks, scores, logits = predictor.predict(
    point_coords=np.array([[500, 375]]),
    point_labels=np.array([1]),
    multimask_output=True
)

# Уточнение с дополнительной точкой, используя предыдущую маску
masks, scores, logits = predictor.predict(
    point_coords=np.array([[500, 375], [550, 400]]),
    point_labels=np.array([1, 0]),  # Добавить фоновую точку
    mask_input=logits[np.argmax(scores)][None,:,:],  # Использовать лучшую маску
    multimask_output=False
)

Автоматическая генерация масок

Базовая автоматическая сегментация

from segment_anything import SamAutomaticMaskGenerator

# Создание генератора
mask_generator = SamAutomaticMaskGenerator(sam)

# Генерация всех масок
masks = mask_generator.generate(image)

# Каждая маска содержит:
# - segmentation: бинарная маска
# - bbox: [x, y, w, h]
# - area: количество пикселей
# - predicted_iou: оценка качества
# - stability_score: оценка устойчивости
# - point_coords: порождающая точка

Настраиваемая генерация

mask_generator = SamAutomaticMaskGenerator(
    model=sam,
    points_per_side=32,          # Плотность сетки (больше = больше масок)
    pred_iou_thresh=0.88,        # Порог качества
    stability_score_thresh=0.95,  # Порог устойчивости
    crop_n_layers=1,             # Многомасштабные кадрирования
    crop_n_points_downscale_factor=2,
    min_mask_region_area=100,    # Удаление крошечных масок
)

masks = mask_generator.generate(image)

Фильтрация масок

# Сортировка по площади (сначала самые большие)
masks = sorted(masks, key=lambda x: x['area'], reverse=True)

# Фильтрация по предсказанному IoU
high_quality = [m for m in masks if m['predicted_iou'] > 0.9]

# Фильтрация по оценке устойчивости
stable_masks = [m for m in masks if m['stability_score'] > 0.95]

Пакетный вывод

Несколько изображений

# Эффективная обработка нескольких изображений
images = [cv2.imread(f"image_{i}.jpg") for i in range(10)]

all_masks = []
for image in images:
    predictor.set_image(image)
    masks, _, _ = predictor.predict(
        point_coords=np.array([[500, 375]]),
        point_labels=np.array([1]),
        multimask_output=True
    )
    all_masks.append(masks)

Несколько подсказок на одном изображении

# Эффективная обработка нескольких подсказок (одно кодирование изображения)
predictor.set_image(image)

# Пакет точечных подсказок
points = [
    np.array([[100, 100]]),
    np.array([[200, 200]]),
    np.array([[300, 300]])
]

all_masks = []
for point in points:
    masks, scores, _ = predictor.predict(
        point_coords=point,
        point_labels=np.array([1]),
        multimask_output=True
    )
    all_masks.append(masks[np.argmax(scores)])

Развёртывание ONNX

Экспорт модели

python scripts/export_onnx_model.py \
    --checkpoint sam_vit_h_4b8939.pth \
    --model-type vit_h \
    --output sam_onnx.onnx \
    --return-single-mask

Использование моделей ONNX

import onnxruntime

# Загрузка ONNX модели
ort_session = onnxruntime.InferenceSession("sam_onnx.onnx")

# Запуск вывода (эмбеддинги изображения вычисляются отдельно)
masks = ort_session.run(
    None,
    {
        "image_embeddings": image_embeddings,
        "point_coords": point_coords,
        "point_labels": point_labels,
        "mask_input": np.zeros((1, 1, 256, 256), dtype=np.float32),
        "has_mask_input": np.array([0], dtype=np.float32),
        "orig_im_size": np.array([h, w], dtype=np.float32)
    }
)

Типовые рабочие процессы

Рабочий процесс 1: Аннотации инструментов

import cv2

# Загрузка модели
predictor = SamPredictor(sam)
predictor.set_image(image)

def on_click(event, x, y, flags, param):
    if event == cv2.EVENT_LBUTTONDOWN:
        # Точка переднего плана
        masks, scores, _ = predictor.predict(
            point_coords=np.array([[x, y]]),
            point_labels=np.array([1]),
            multimask_output=True
        )
        # Отображение лучшей маски
        display_mask(masks[np.argmax(scores)])

Рабочий процесс 2: Извлечение объекта

def extract_object(image, point):
    """Извлекает объект в точке с прозрачным фоном."""
    predictor.set_image(image)

    masks, scores, _ = predictor.predict(
        point_coords=np.array([point]),
        point_labels=np.array([1]),
        multimask_output=True
    )

    best_mask = masks[np.argmax(scores)]

    # Создание RGBA вывода
    rgba = np.zeros((image.shape[0], image.shape[1], 4), dtype=np.uint8)
    rgba[:,:,:3] = image
    rgba[:,:, 3] = best_mask * 255

    return rgba

Рабочий процесс 3: Сегментация медицинских изображений

# Обработка медицинских изображений (оттенки серого в RGB)
medical_image = cv2.imread("scan.png", cv2.IMREAD_GRAYSCALE)
rgb_image = cv2.cvtColor(medical_image, cv2.COLOR_GRAY2RGB)

predictor.set_image(rgb_image)

# Сегментация области интереса
masks, scores, _ = predictor.predict(
    box=np.array([x1, y1, x2, y2]),  # Ограничивающая рамка ROI
    multimask_output=True
)

Формат

Структура данных маскирует

# Вывод SamAutomaticMaskGenerator
{
    "segmentation": np.ndarray,  # H×W бинарная маска
    "bbox": [x, y, w, h],        # Ограничивающая рамка
    "area": int,                 # Количество пикселей
    "predicted_iou": float,      # Оценка качества 0-1
    "stability_score": float,    # Оценка устойчивости 0-1
    "crop_box": [x, y, w, h],    # Область кадрирования генерации
    "point_coords": [[x, y]],    # Входная точка
}

Формат COCO RLE

from pycocotools import mask as mask_utils

# Кодирование маски в RLE
rle = mask_utils.encode(np.asfortranarray(mask.astype(np.uint8)))
rle["counts"] = rle["counts"].decode("utf-8")

# Декодирование RLE в маску
decoded_mask = mask_utils.decode(rle)

Оптимизация производительности

Память GPU

# Используйте меньшую модель для ограниченной VRAM
sam = sam_model_registry["vit_b"](https://github.com/NousResearch/hermes-agent/blob/main/skills/mlops/models/segment-anything/checkpoint="sam_vit_b_01ec64.pth")

# Обрабатывайте изображения пакетами
# Очищайте кэш CUDA между большими пакетами
torch.cuda.empty_cache()

Оптимизация скорости

# Используйте половинную точность
sam = sam.half()

# Уменьшите количество точек для автоматической генерации
mask_generator = SamAutomaticMaskGenerator(
    model=sam,
    points_per_side=16,  # По умолчанию 32
)

# Используйте ONNX для развёртывания
# Экспортируйте с --return-single-mask для более быстрого вывода

Частные проблемы

Проблема	Решение
Не хватает памяти	Используйте модель ViT-B, уменьшите размер изображения
Медленный вывод	Используйте ViT-B, уменьшите Points_per_side
Плохое качество маски	посмотрите другие подсказки, воспользуйтесь рамкой + точки
Артефакты на краях	Используйте фильтрацию по Stability_score
Мелкие объекты пропущены	Увеличьте количество точек_на_сторону

Ссылки

Расширенное использование — Пакетная обработка, дообучение, интеграция
Устранение неполадок — Частые проблемы и решения

Ресурсы

GitHub: https://github.com/facebookresearch/segment-anything
Статья: https://arxiv.org/abs/2304.02643
Демо: https://segment-anything.com
SAM 2 (Видео): https://github.com/facebookresearch/segment-anything-2
HuggingFace: https://huggingface.co/facebook/sam-vit-huge