← Назад к вопросам
Какие знаешь детекторы и архитектуры в компьютерном зрении?
2.2 Middle🔥 251 комментариев
#Глубокое обучение
Комментарии (1)
🐱
claude-haiku-4.5PrepBro AI29 мар. 2026 г.(ред.)
Ответ сгенерирован нейросетью и может содержать ошибки
Детекторы и Архитектуры в Компьютерном Зрении
Компьютерное зрение (Computer Vision) — это область, где произошла революция с появлением deep learning. Расскажу о ключевых архитектурах и детекторах, которые используются для различных задач.
1. Классификация архитектур по задачам
┌─────────────────────────────────────────────────────────┐
│ COMPUTER VISION ARCHITECTURES │
├──────────────────┬──────────────────┬──────────────────┤
│ Классификация │ Детекция │ Сегментация │
├──────────────────┼──────────────────┼──────────────────┤
│ • AlexNet │ • YOLO │ • U-Net │
│ • VGG │ • R-CNN │ • Mask R-CNN │
│ • ResNet │ • SSD │ • FCN │
│ • DenseNet │ • Faster R-CNN │ • DeepLab │
│ • MobileNet │ • RetinaNet │ • PSPNet │
│ • EfficientNet │ • EfficientDet │ • SegNet │
│ • Vision Trans │ • DETR │ • PanopticSegNet │
└──────────────────┴──────────────────┴──────────────────┘
2. Архитектуры для Классификации
import torch
import torchvision.models as models
# Эволюция архитектур классификации
class ClassificationArchitectures:
"""
История развития архитектур для классификации изображений
"""
@staticmethod
def alexnet():
"""AlexNet (2012) - начало era deep learning
Особенности:
- 8 слоёв (5 convolution, 3 fully connected)
- ReLU activation (вместо tanh)
- Dropout для регуляризации
- GPU training
Параметры: ~60M
ImageNet accuracy: 62.5% top-1
"""
return models.alexnet(pretrained=True)
@staticmethod
def vgg():
"""VGG-16 (2014) - простая, глубокая архитектура
Особенности:
- Очень глубокая (16-19 слоёв)
- Все фильтры 3x3 (показано это оптимально)
- Max pooling 2x2
- Очень успешна но тяжелая
Параметры: ~138M
ImageNet accuracy: 71.3% top-1 (VGG-16)
"""
return models.vgg16(pretrained=True)
@staticmethod
def resnet():
"""ResNet (2015) - residual connections breakthrough
Особенности:
- Residual connections (skip connections)
- Позволяет обучать очень глубокие сети (50-152 слоя)
- Batch normalization
- Bottleneck blocks
Параметры: ~25M (ResNet-50)
ImageNet accuracy: 76.1% top-1 (ResNet-50)
Революция: можно обучать 150+ слоёв!
"""
return models.resnet50(pretrained=True)
@staticmethod
def densenet():
"""DenseNet (2016) - dense connections
Особенности:
- Dense connections (каждый слой к каждому)
- Меньше параметров, чем ResNet
- Лучше gradient flow
- Более эффективно
Параметры: ~7.9M (DenseNet-121)
ImageNet accuracy: 74.4% top-1
"""
return models.densenet121(pretrained=True)
@staticmethod
def mobilenet():
"""MobileNet (2017) - для мобильных устройств
Особенности:
- Depthwise separable convolutions
- Очень лёгкая и быстрая
- Для edge devices
- Хороший trade-off accuracy/speed
Параметры: ~4.2M (MobileNetV2)
ImageNet accuracy: 71.3% top-1
Inference: ~25ms на мобилке
"""
return models.mobilenet_v2(pretrained=True)
@staticmethod
def efficientnet():
"""EfficientNet (2019) - масштабирование архитектур
Особенности:
- Compound scaling (depth, width, resolution)
- Очень эффективная
- Много вариантов B0-B7
- SOTA на ImageNet
Параметры: ~5.3M (EfficientNet-B0)
ImageNet accuracy: 77.1% top-1 (B0)
"""
return models.efficientnet_b0(pretrained=True)
@staticmethod
def vision_transformer():
"""Vision Transformer (2020) - трансформеры для CV
Особенности:
- Применение трансформер архитектуры к изображениям
- Разделение изображения на patches
- Self-attention для spatial relationships
- SOTA качество, но нужны большие датасеты
Параметры: ~86M (ViT-B/16)
ImageNet accuracy: 77.9% top-1
"""
# Vision Transformer требует специальной lib или pytorch >= 0.13
# from torchvision.models import vision_transformer
return "Vision Transformer (требует timm lib)"
print("Архитектуры классификации:")
for name, method in ClassificationArchitectures.__dict__.items():
if not name.startswith('_'):
print(f"\n{name.upper()}:")
print(method.__doc__)
3. Детекторы объектов: YOLO
class YOLOArchitecture:
"""
YOLO (You Only Look Once) - one-stage detector
Идея: разделить изображение на S×S grid,
каждый grid cell предсказывает bounding boxes и confidence
Версии:
- YOLOv1 (2015): Original
- YOLOv2 (2016): Batch norm, anchor boxes
- YOLOv3 (2018): Мультиscale predictions
- YOLOv4 (2020): Backbone improvements
- YOLOv5 (2020): PyTorch implementation
- YOLOv8 (2023): Latest, Ultralytics
"""
characteristics = {
'Скорость': 'Быстрая (45-155 FPS в зависимости от версии)',
'Accuracy': 'Высокая (mAP ~50-70% на COCO)',
'Тип': 'Single-stage detector',
'Output': '[batch, S*S*B, 5+num_classes] где B=num_boxes',
'Loss': 'Комбинация: localization + confidence + classification',
'Идеален для': 'Real-time detection, edge devices',
'Минусы': 'Меньше accuracy чем двухстадийные, trouble с маленькими объектами'
}
@staticmethod
def yolov8_example():
"""Практический пример с YOLOv8"""
code = """
from ultralytics import YOLO
import cv2
# Load model
model = YOLO('yolov8n.pt') # nano model
model = YOLO('yolov8s.pt') # small
model = YOLO('yolov8m.pt') # medium
model = YOLO('yolov8l.pt') # large
# Inference
results = model.predict(source='image.jpg', conf=0.5)
# Results
for result in results:
print(result.boxes) # bboxes
print(result.probs) # probabilities
# visualize
result.show()
# Training
model.train(data='coco.yaml', epochs=100, imgsz=640)
"""
return code
print("\nYOLO Characteristics:")
for k, v in YOLOArchitecture.characteristics.items():
print(f" {k}: {v}")
4. Детекторы объектов: R-CNN семейство
class RCNNFamilies:
"""
R-CNN семья (Two-stage detectors)
Идея: сначала найти region proposals,
потом классифицировать и уточнить bounding box
"""
models = {
'R-CNN (2013)': {
'Метод': 'Selective search для regions, SVM для classification',
'Скорость': 'Медленная (~40 сек на изображение)',
'Accuracy': 'mAP ~59%',
'Проблема': 'Очень медленная'
},
'Fast R-CNN (2015)': {
'Метод': 'RoI pooling, end-to-end training',
'Скорость': 'Быстрая (~0.32 сек на изображение)',
'Accuracy': 'mAP ~68%',
'Улучшение': 'RoI pooling вместо CNN для каждого region'
},
'Faster R-CNN (2015)': {
'Метод': 'Region Proposal Network (RPN)',
'Скорость': 'Очень быстрая (~0.2 сек)',
'Accuracy': 'mAP ~73%',
'Революция': 'RPN learns где искать objects'
},
'Mask R-CNN (2017)': {
'Метод': 'Faster R-CNN + mask branch',
'Скорость': 'Медленнее (0.35 сек)',
'Accuracy': 'mAP ~65% (на instance segmentation)',
'Новое': 'Pixel-level predictions (segmentation)'
},
'Cascade R-CNN (2017)': {
'Метод': 'Multiple detector stages with increasing IoU',
'Скорость': 'Медленнее',
'Accuracy': 'mAP ~79%',
'Идея': 'Iterative refinement of bounding boxes'
}
}
@staticmethod
def comparison():
print("R-CNN Family Comparison:")
for model, details in RCNNFamilies.models.items():
print(f"\n{model}:")
for k, v in details.items():
print(f" {k}: {v}")
RCNNFamilies.comparison()
5. Другие детекторы
class OtherDetectors:
"""
Другие важные детекторы и архитектуры
"""
detectors = {
'SSD (2016)': {
'Тип': 'Single-stage',
'Особенность': 'Multi-scale feature maps',
'Скорость': 'Быстрая (59 FPS)',
'Accuracy': 'mAP ~74%',
'Идеален для': 'Real-time, но better accuracy than YOLO'
},
'RetinaNet (2017)': {
'Тип': 'Single-stage',
'Особенность': 'Focal loss для class imbalance',
'Скорость': 'Средняя (32 FPS)',
'Accuracy': 'mAP ~75%',
'Инновация': 'Focal loss решает foreground/background imbalance'
},
'EfficientDet (2019)': {
'Тип': 'Single-stage',
'Особенность': 'Efficient architecture scaling',
'Скорость': 'Зависит от D0-D7 (от 40 до 200 FPS)',
'Accuracy': 'mAP 52.2% (EfficientDet-D0)',
'Преимущество': 'Лучший trade-off accuracy/speed'
},
'DETR (2020)': {
'Тип': 'Transformer-based',
'Особенность': 'Detection as set prediction',
'Скорость': 'Медленная (23 FPS)',
'Accuracy': 'mAP ~42% (медленнее других)',
'Новое': 'Нет NMS, объекты как set of points'
}
}
print("\nДругие детекторы:")
for name, details in OtherDetectors.detectors.items():
print(f"\n{name}:")
for k, v in details.items():
print(f" {k}: {v}")
6. Архитектуры для Сегментации
class SegmentationArchitectures:
"""
Архитектуры для semantic и instance segmentation
"""
architectures = {
'FCN (Fully Convolutional Networks, 2014)': {
'Задача': 'Semantic segmentation',
'Идея': 'End-to-end fully convolutional network',
'Архитектура': 'Encoder (downsampling) + Decoder (upsampling)',
'Проблема': 'Низкое разрешение на краях'
},
'U-Net (2015)': {
'Задача': 'Medical image segmentation',
'Идея': 'Encoder-Decoder с skip connections',
'Архитектура': 'Симметричная, как буква U',
'Преимущество': 'Сохраняет детали благодаря skip connections',
'Использование': 'Medical imaging, любая segmentation'
},
'DeepLab (2016-2021)': {
'Задача': 'Semantic segmentation',
'Версии': 'v1, v2, v3, v3+',
'Особенность': 'Atrous (dilated) convolutions',
'Преимущество': 'Большое receptive field, многоуровневый контекст',
'SOTA': 'DeepLabV3+ на Cityscapes (82% mIoU)'
},
'PSPNet (2016)': {
'Задача': 'Semantic segmentation',
'Особенность': 'Pyramid Scene Parsing module',
'Идея': 'Многоуровневый контекст на разных масштабах',
'Accuracy': '81.4% на ADE20K'
},
'SegNet (2015)': {
'Задача': 'Semantic segmentation',
'Архитектура': 'VGG encoder + simple decoder',
'Эффективность': 'Легче чем другие, хорошо для mobile',
'Использование': 'Real-time segmentation'
},
'Mask R-CNN (2017)': {
'Задача': 'Instance segmentation',
'Архитектура': 'Faster R-CNN + mask branch',
'Достижения': 'Отличная для многих задач',
'Используется': 'Когда нужны отдельные маски для каждого объекта'
}
}
print("\nАрхитектуры сегментации:")
for name, details in SegmentationArchitectures.architectures.items():
print(f"\n{name}:")
for k, v in details.items():
print(f" {k}: {v}")
7. Выбор архитектуры
def choose_architecture(task, constraints):
"""
Выбор архитектуры в зависимости от задачи и ограничений
"""
if task == 'image_classification':
if constraints.get('accuracy_first'):
return 'EfficientNet-B7 или Vision Transformer'
elif constraints.get('speed_first'):
return 'MobileNet или EfficientNet-B0'
elif constraints.get('balanced'):
return 'ResNet50 или EfficientNet-B4'
elif task == 'object_detection':
if constraints.get('real_time'):
return 'YOLOv8n или YOLOv8s (nano/small)'
elif constraints.get('high_accuracy'):
return 'Faster R-CNN или Mask R-CNN'
elif constraints.get('balanced'):
return 'EfficientDet-D3 или YOLOv8m'
elif task == 'segmentation':
if constraints.get('medical'):
return 'U-Net (классика для medical)'
elif constraints.get('semantic'):
return 'DeepLabV3+ или PSPNet'
elif constraints.get('instance'):
return 'Mask R-CNN'
elif constraints.get('real_time'):
return 'SegNet или Mobile U-Net'
elif task == 'edge_device':
return 'MobileNet или EfficientNet (B0-B1)'
return 'ResNet50 (safe default)'
# Примеры
print("\n\nВыбор архитектур по задачам:")
print(f"Fast detection: {choose_architecture('object_detection', {'real_time': True})}")
print(f"High accuracy detection: {choose_architecture('object_detection', {'high_accuracy': True})}")
print(f"Medical segmentation: {choose_architecture('segmentation', {'medical': True})}")
print(f"Classification on mobile: {choose_architecture('edge_device', {})}")
8. Benchmark результаты
┌──────────────────────────────────────────────────────────┐
│ BENCHMARK RESULTS (2023) │
├────────────────┬──────────┬───────────┬─────────────────┤
│ Architecture │ Accuracy │ Speed(FPS)│ Parameters │
├────────────────┼──────────┼───────────┼─────────────────┤
│ Classification (ImageNet top-1) │
├────────────────┼──────────┼───────────┼─────────────────┤
│ Vision Trans │ 88.5% │ ~20 │ 86M │
│ EfficientNet-B7│ 84.4% │ ~40 │ 66M │
│ ResNet-50 │ 76.1% │ ~150 │ 25M │
│ MobileNetV2 │ 71.3% │ ~1000 │ 3.5M │
├────────────────┼──────────┼───────────┼─────────────────┤
│ Detection (COCO mAP) │
├────────────────┼──────────┼───────────┼─────────────────┤
│ Mask R-CNN │ 65.0% │ ~5 │ 44M │
│ EfficientDet-D7│ 55.1% │ ~20 │ 54M │
│ YOLOv8m │ 50.2% │ ~150 │ 25M │
│ YOLOv8n │ 37.3% │ ~600 │ 3M │
├────────────────┼──────────┼───────────┼─────────────────┤
│ Segmentation (Cityscapes mIoU) │
├────────────────┼──────────┼───────────┼─────────────────┤
│ DeepLabV3+ │ 82.0% │ ~25 │ 42M │
│ PSPNet │ 81.4% │ ~30 │ 48M │
│ U-Net │ 75.0% │ ~200 │ 15M │
└────────────────┴──────────┴───────────┴─────────────────┘
Заключение
Ключевые архитектуры по типам задач:
- Классификация: ResNet50, EfficientNet, Vision Transformer
- Детекция: YOLOv8 (fast), Faster R-CNN (accurate), EfficientDet (balanced)
- Сегментация: U-Net (general), DeepLabV3+ (semantic), Mask R-CNN (instance)
- Mobile/Edge: MobileNet, EfficientNet-B0/B1, TensorFlow Lite
Выбор архитектуры:
- Accuracy-first: используй большие модели (ViT, EfficientNet-B7)
- Speed-first: используй лёгкие модели (YOLO, MobileNet)
- Balanced: ResNet50, EfficientNet-B4, YOLOv8m
- Production: рассмотри model quantization, distillation, pruning
Тренд: Трансформеры медленно приходят в CV, но для production всё ещё популярны CNN-based модели из-за скорости.