Computer Vision 2026: YOLO, SAM, DETR

В компьютерном зрении 2026 года три парадигмы доминируют: детекция объектов в реальном времени (YOLO), семантическая сегментация произвольных объектов (SAM) и детекция на основе трансформеров (DETR). Каждая решает фундаментально разные задачи, но вместе формируют экосистему для анализа визуальных данных. Выбор между ними — компромисс между скоростью, точностью и гибкостью, а не простое предпочтение архитектуры.

YOLO: Скорость ценой точности

YOLO прошел эволюцию от версии 1 (2015) до YOLOv9 (2023), кардинально меняя подход к детекции. Современная архитектура использует spatial pyramid pooling и path aggregation network (PANet), что позволяет эффективно обрабатывать объекты разных масштабов.

Ключевое отличие YOLO от двухэтапных детекторов (Faster R-CNN, Mask R-CNN) — предсказание bounding box’ей и классов за один проход через изображение. Это достигается через разделение изображения на сетку и одновременное предсказание:

# Реализация CSPDarknet-53 из YOLOv8
class CSPDarknet(nn.Module):
    def __init__(self, in_channels=3, depth=53, width=1.0):
        super().__init__()
        base_channels = int(width * 64)
        
        # Initial convolution
        self.stem = ConvBlock(in_channels, base_channels, kernel_size=3, stride=2)
        
        # Feature extraction layers
        self.dark2 = nn.Sequential(*self._make_layer(base_channels, base_channels*2, n=1, stride=2))
        self.dark3 = nn.Sequential(*self._make_layer(base_channels*2, base_channels*4, n=2, stride=2))
        self.dark4 = nn.Sequential(*self._make_layer(base_channels*4, base_channels*8, n=8, stride=2))
        self.dark5 = nn.Sequential(*self._make_layer(base_channels*8, base_channels*16, n=8, stride=2))
        
    def _make_layer(self, in_channels, out_channels, n, stride):
        layers = []
        
        # First block
        layers.append(CSPBlock(in_channels, out_channels, n=1, stride=stride))
        
        # Remaining blocks
        for _ in range(n):
            layers.append(CSPBlock(out_channels, out_channels, n=1))
            
        return nn.Sequential(*layers)

Trade-offs YOLO:

Скорость: 140-200 FPS на GPU (V100) для YOLOv8-nano
Точность для крупных объектов: mAP 0.65-0.72 на COCO

Ограничения: Сложность детекции объектов в группах (crowded scenes)
Мелкие объекты: Точность падает до mAP 0.3-0.4 для объектов <32px

В продакшене я столкнулся с проблемой: YOLOv8-l отлично справлялся с людьми и машинами в городских сценах, но терпел фиаско при детекции мелких объектов вроде знаков или светофоров. Пришлось добавлять post-processing для уточнения результатов.

SAM: Мечта универсальной сегментации

Segment Anything Model (SAM) от Meta Research — парадигмальный сдвиг в сегментации. Вместо обучения на конкретных классах, SAM обучен на концепции “маски” — произвольного набора пикселей. Три компонента делают это возможным:

Image Encoder: Vision Transformer (ViT) для извлечения признаков
Prompt Encoder: Обработка различных типов подсказок (точки, рамки, текст)
Mask Decoder: Прогнозирование масок на основе признаков и подсказок

# Ключевой компонент SAM: attention mechanism в decoder
class MaskDecoder(nn.Module):
    def __init__(self, transformer_dim, transformer, num_multimask_outputs=3):
        super().__init__()
        self.transformer_dim = transformer_dim
        self.transformer = transformer
        
        self.num_multimask_outputs = num_multimask_outputs
        
        # Прогнозирование масок
        self.iou_prediction_head = MLP(
            transformer_dim, iou_head_depth, num_multimask_outputs
        )
        
        self.output_upscaling = nn.Sequential(
            nn.ConvTranspose2d(transformer_dim, transformer_dim // 4, kernel_size=2, stride=2),
            LayerNorm2d(transformer_dim // 4),
            nn.GELU(),
            nn.ConvTranspose2d(transformer_dim // 4, transformer_dim // 8, kernel_size=2, stride=2),
            LayerNorm2d(transformer_dim // 8),
            nn.GELU(),
            nn.ConvTranspose2d(transformer_dim // 8, transformer_dim, kernel_size=2, stride=2),
        )
        
        self.output_hypernetworks_mlps = nn.ModuleList(
            [MLP(transformer_dim, transformer_dim, 3) for i in range(num_multimask_outputs)]
        )

Trade-offs SAM:

Универсальность: Может сегментировать любой объект без дообучения
Интерактивность: Поддержка различных типов подсказок (точки, рамки, текст)

Ресурсоемкость: Требует >10GB VRAM для инференса
Скорость: Медленный инференс (~5 FPS на A100)

Работая с SAM в медицинском проекте, мы столкнулись с проблемой: модель идеально справлялась с сегментацией органов на КТ-сканах, но “хотела” интерактивности. Без точных подсказок качество падало на 30%. Это неприемлемо для автоматической обработки.

DETR: Трансформеры приходят в детекцию

DETR (DEtection TRansformer) — первый детектор объектов, основанный исключительно на трансформерах. Ключевое отличие от традиционных детекторов — отсутствие специфичных компонентов (anchoring, non-max suppression).

Архитектура DETR включает:

Backbone: CNN (ResNet) для извлечения признаков
Positional Encoding: Добавление информации о позиции пикселей
Transformer Encoder: Обработка извлеченных признаков
Transformer Decoder: Автогрессивное предсказание объектов
Prediction Heads: Прогнозирование классов и координат bounding box’ей

# Критический компонент DETR: bipartite matching loss
class SetLoss(nn.Module):
    def __init__(self, num_classes, matcher, weight_dict, losses):
        super().__init__()
        self.num_classes = num_classes
        self.matcher = matcher
        self.weight_dict = weight_dict
        self.loses = losses
        
    def loss_labels(self, outputs, targets, indices, num_boxes):
        """Classification loss"""
        src_logits = outputs['pred_logits']
        
        idx = self._get_src_permutation_idx(indices)
        target_classes_o = torch.cat([t["labels"][J] for t, (_, J) in zip(targets, indices)])
        target_classes = torch.full(src_logits.shape[:2], self.num_classes,
                                    dtype=torch.int64, device=src_logits.device)
        target_classes[idx] = target_classes_o
        
        loss_ce = F.cross_entropy(src_logits.transpose(1, 2), target_classes)
        losses = {"loss_ce": loss_ce}
        
        return losses
    
    def loss_boxes(self, outputs, targets, indices, num_boxes):
        """Regression loss"""
        if len(indices) == 0:
            return {"loss_bbox": torch.tensor(0).to(outputs['pred_boxes'].device)}
            
        idx = self._get_src_permutation_idx(indices)
        src_boxes = outputs['pred_boxes'][idx]
        target_boxes = torch.cat([t['boxes'][i] for t, (_, i) in zip(targets, indices)], dim=0)
        
        loss_bbox = F.l1_loss(src_boxes, target_boxes, reduction='none')
        losses = {}
        losses['loss_bbox'] = loss_bbox.sum() / num_boxes
        
        return losses

Trade-offs DETR:

Элегантность: Устранение ручной настройки anchor boxes и NMS
Гибкость: Легко расширяем для других задач (например, сегментации)

Скорость обучения: Требует много эпох для сходимости (300+)
Качество: Может уступать специализированным архитектурам на некоторых датасетах

DETR показал себя в проекте автономного вождения, но требовал тонкой настройки гиперпараметров и долгого обучения (в 10 раз дольше, чем YOLO). В итоге мы остановились на гибридном подходе: YOLO для быстрой предобработки и DETR для уточнения результатов.

Реальные цифры: где каждая технология ломается

YOLO:

Проблемы с детекцией объектов в группах (crowded scenes)
Точность для мелких объектов (<32px) падает на 50%
Сложность в адаптации под новые домены без дообучения

SAM:

Высокие требования к ресурсам (GPU с >10GB VRAM)
Скорость инференса неприемлема для real-time приложений
Нестабильное качество на текстурах, похожих на объекты интереса

DETR:

Длительное время обучения (10x больше чем у R-CNN)
Чувствительность к выбору гиперпараметров
Сложности с детекцией мелких объектов

Архитектурная дилемма: что выбрать и почему

YOLO — ваш выбор, если нужна максимальная скорость и работаете с ограниченными ресурсами. Идеально для встраиваемых систем, видеонаблюдения, автономных роботов с ограниченным вычислительным бюджетом. В одном из наших проектов YOLOv8-m на Jetson Nano обеспечивал 30 FPS при обработке видеопотока с 4 камер simultaneously.

SAM — незаменим, когда требуется интерактивная сегментация объектов без дообучения. Подходит для медицинских приложений, аугментации данных, AR/VR, где пользователь может указать объект. В нашем проекте 3D-реконструкции SAM позволя пользователям “вырезать” объекты со снимков, что было невозможно с предыдущими моделями.

DETR — оптимально для облачных систем, где важна точность больше скорости. Используйте, когда нужна универсальная архитектура для нескольких задач (детекция, сегментация) и есть время на длительное обучение. В проекте инвентаризации склада DETR с дообучением на наших данных достиг точности 92%, что было на 15% лучше, чем у YOLO.

В 2026 году эти три технологии не конкурируют, а дополняют друг друга в экосистеме компьютерного зрения. Задача архитектора — выбрать правильный инструмент для конкретной подзадачи. В реальных проектах я часто использую их комбинацию: YOLO для быстрой предварительной обработки, SAM для интерактивной сегментации и DETR для точного позиционирования объектов.