Конфигурация YAML модели

Файл конфигурации модели YAML служит архитектурным планом нейронных сетей Ultralytics . Он определяет, как соединяются слои, какие параметры использует каждый модуль и как масштабируется вся сеть при разных размерах модели.

Структура конфигурации

Файлы YAML модели организованы в три основные секции, которые совместно определяют архитектуру.

Раздел параметров

В разделе параметров задаются глобальные характеристики модели и поведение масштабирования:

# Parameters
nc: 80 # number of classes
scales: # compound scaling constants [depth, width, max_channels]
    n: [0.50, 0.25, 1024] # nano: shallow layers, narrow channels
    s: [0.50, 0.50, 1024] # small: shallow depth, standard width
    m: [0.50, 1.00, 512] # medium: moderate depth, full width
    l: [1.00, 1.00, 512] # large: full depth and width
    x: [1.00, 1.50, 512] # extra-large: maximum performance
kpt_shape: [17, 3] # pose models only

• nc задает количество классов, которые предсказывает модель.
• scales определить составные коэффициенты масштабирования, которые регулируют глубину, ширину и максимальное количество каналов модели для получения различных вариантов размеров (от нано до сверхбольших).
• kpt_shape применяется к моделям поз. Это может быть [N, 2] для (x, y) ключевые точки или [N, 3] для (x, y, visibility).

Архитектура позвоночника и головы

Архитектура модели состоит из магистральной (извлечение признаков) и головной (конкретные задачи) частей:

backbone:
    # [from, repeats, module, args]
    - [-1, 1, Conv, [64, 3, 2]] # 0: Initial convolution
    - [-1, 1, Conv, [128, 3, 2]] # 1: Downsample
    - [-1, 3, C2f, [128, True]] # 2: Feature processing

head:
    - [-1, 1, nn.Upsample, [None, 2, nearest]] # 6: Upsample
    - [[-1, 2], 1, Concat, [1]] # 7: Skip connection
    - [-1, 3, C2f, [256]] # 8: Process features
    - [[8], 1, Detect, [nc]] # 9: Detection layer

Формат спецификации уровня

Каждый слой повторяет последовательную схему: [from, repeats, module, args]

Схемы соединения

Параметр from поле создает гибкие схемы передачи данных по всей сети:

- [-1, 1, Conv, [64, 3, 2]]    # Takes input from previous layer

- [[-1, 6], 1, Concat, [1]]    # Combines current layer with layer 6

- [[4, 6, 8], 1, Detect, [nc]] # Detection head using 3 feature scales

Повторение модуля

Параметр repeats параметр создает более глубокие участки сети:

- [-1, 3, C2f, [128, True]] # Creates 3 consecutive C2f blocks
- [-1, 1, Conv, [64, 3, 2]] # Single convolution layer

Фактическое количество повторений умножается на коэффициент масштабирования глубины, полученный при конфигурировании размера модели.

Доступные модули

Модули организованы по функциональности и определены в каталоге модулейUltralytics . В следующих таблицах представлены часто используемые модули по категориям, а многие другие доступны в исходном коде:

Основные операции

Композитные блоки

Специализированные модули

Дополнительные возможности

Интеграция с TorchVision

Модуль TorchVision обеспечивает бесшовную интеграцию любой модели TorchVision в качестве магистрали:

from ultralytics import YOLO

# Model with ConvNeXt backbone
model = YOLO("convnext_backbone.yaml")
results = model.train(data="coco8.yaml", epochs=100)

backbone:
  - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, False]]
head:
  - [-1, 1, Classify, [nc]]

Индексный модуль для выбора признаков

При использовании моделей, создающих несколько карт признаков, модуль Index выбирает конкретные результаты:

backbone:
    - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, True]] # Multi-output
head:
    - [0, 1, Index, [192, 4]] # Select 4th feature map (192 channels)
    - [0, 1, Index, [384, 6]] # Select 6th feature map (384 channels)
    - [0, 1, Index, [768, 8]] # Select 8th feature map (768 channels)
    - [[1, 2, 3], 1, Detect, [nc]] # Multi-scale detection

Система разрешения модулей

Понимание того, как Ultralytics находит и импортирует модули, очень важно для настройки:

Процесс поиска модуля

Ultralytics использует трехуровневую систему в parse_model:

# Core resolution logic
m = getattr(torch.nn, m[3:]) if "nn." in m else getattr(torchvision.ops, m[4:]) if "ops." in m else globals()[m]

1. Модули PyTorch: Имена, начинающиеся с 'nn.' → torch.nn пространство имен
2. Операции TorchVision: Имена, начинающиеся с 'ops.' → torchvision.ops пространство имен
3. МодулиUltralytics : Все остальные имена → глобальное пространство имен через импорт

Цепочка импорта модулей

Стандартные модули становятся доступными благодаря импорту в tasks.py:

from ultralytics.nn.modules import (  # noqa: F401, E501
    SPPF,
    C2f,
    Conv,
    Detect,
    # ... many more modules
    Index,
    TorchVision,
)

Интеграция пользовательских модулей

Модификация исходного кода

Изменение исходного кода - самый универсальный способ интеграции пользовательских модулей, но он может быть непростым. Чтобы определить и использовать пользовательский модуль, выполните следующие действия:

1. Определите свой модуль в ultralytics/nn/modules/block.py:

   class CustomBlock(nn.Module):
       def __init__(self, c1, c2):
           super().__init__()
           self.layers = nn.Sequential(nn.Conv2d(c1, c2, 3, 1, 1), nn.BatchNorm2d(c2), nn.ReLU())
   
       def forward(self, x):
           return self.layers(x)
   

2. Предложите свой модуль на уровне пакета в ultralytics/nn/modules/__init__.py:

   from .block import CustomBlock  # noqa makes CustomBlock available as ultralytics.nn.modules.CustomBlock
   

3. Добавить к импорту в ultralytics/nn/tasks.py:

   from ultralytics.nn.modules import CustomBlock  # noqa
   

4. Обработка специальных аргументов (при необходимости) внутри parse_model() в ultralytics/nn/tasks.py:

   elif m is CustomBlock:
       c1, c2 = ch[f], args[0]  # input channels, output channels
       args = [c1, c2, *args[1:]]
   

5. Используйте модуль в YAML вашей модели:

   # custom_model.yaml
   nc: 1
   backbone:
       - [-1, 1, CustomBlock, [64]]
   head:
       - [-1, 1, Classify, [nc]]
   

6. Проверьте FLOPs, чтобы убедиться, что передача вперед работает:

   from ultralytics import YOLO
   
   model = YOLO("custom_model.yaml", task="classify")
   model.info()  # should print non-zero FLOPs if working
   

Примеры конфигураций

Базовая модель обнаружения

# Simple YOLO detection model
nc: 80
scales:
    n: [0.33, 0.25, 1024]

backbone:
    - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
    - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
    - [-1, 3, C2f, [128, True]] # 2
    - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
    - [-1, 6, C2f, [256, True]] # 4
    - [-1, 1, SPPF, [256, 5]] # 5

head:
    - [-1, 1, Conv, [256, 3, 1]] # 6
    - [[6], 1, Detect, [nc]] # 7

Модель магистрали TorchVision

# ConvNeXt backbone with YOLO head
nc: 80

backbone:
    - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, True]]

head:
    - [0, 1, Index, [192, 4]] # P3 features
    - [0, 1, Index, [384, 6]] # P4 features
    - [0, 1, Index, [768, 8]] # P5 features
    - [[1, 2, 3], 1, Detect, [nc]] # Multi-scale detection

Модель классификации

# Simple classification model
nc: 1000

backbone:
    - [-1, 1, Conv, [64, 7, 2, 3]]
    - [-1, 1, nn.MaxPool2d, [3, 2, 1]]
    - [-1, 4, C2f, [64, True]]
    - [-1, 1, Conv, [128, 3, 2]]
    - [-1, 8, C2f, [128, True]]
    - [-1, 1, nn.AdaptiveAvgPool2d, [1]]

head:
    - [-1, 1, Classify, [nc]]

Лучшие практики

Советы по архитектурному дизайну

Начните с простого: Начните с проверенных архитектур, прежде чем приступать к настройке. Используйте существующие конфигурации YOLO в качестве шаблонов и изменяйте их постепенно, а не создавайте с нуля.

Тестируйте постепенно: Проверяйте каждое изменение шаг за шагом. Добавляйте по одному модулю за раз и проверяйте его работу, прежде чем переходить к следующему изменению.

Каналы мониторинга: Убедитесь, что размеры каналов между подключенными слоями совпадают. Выходные каналы (c2) одного слоя должны совпадать с входными каналами (c1) следующего слоя в последовательности.

Используйте пропускные соединения: Используйте повторное использование функций с помощью [[-1, N], 1, Concat, [1]] паттерны. Эти связи помогают в работе с градиентным потоком и позволяют модели сочетать особенности разных масштабов.

Соответствующий масштаб: Выбирайте масштабы модели, исходя из своих вычислительных ограничений. Используйте нано (n) для краевых устройств, маленькие (s) для сбалансированной производительности, и более крупные весы (m, l, x) для максимальной точности.

Соображения по производительности

Глубина и ширина: глубокие сети улавливают сложные иерархические особенности с помощью нескольких слоев преобразования, в то время как широкие сети обрабатывают больше информации параллельно на каждом слое. Сбалансируйте эти параметры в зависимости от сложности задачи.

Пропускать соединения: Улучшают градиентный поток во время обучения и позволяют повторно использовать функции во всей сети. Они особенно важны в более глубоких архитектурах для предотвращения исчезновения градиентов.

Блоки с узким местом: Снижение вычислительных затрат при сохранении выразительности модели. Такие модули, как C2f используют меньше параметров, чем стандартные свертки, сохраняя при этом способность к обучению признаков.

Многомасштабные функции: Необходимы для обнаружения объектов разных размеров на одном и том же изображении. Используйте шаблоны Feature Pyramid Network (FPN) с несколькими головками обнаружения в разных масштабах.

Устранение неполадок

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

Советы по отладке

При разработке пользовательских архитектур систематическая отладка помогает выявить проблемы на ранней стадии:

Используйте Identity Head для тестирования

Замените сложные головки на nn.Identity чтобы изолировать проблемы с магистралью:

nc: 1
backbone:
    - [-1, 1, CustomBlock, [64]]
head:
    - [-1, 1, nn.Identity, []] # Pass-through for debugging

Это позволяет напрямую контролировать выходы магистрали:

import torch

from ultralytics import YOLO

model = YOLO("debug_model.yaml")
output = model.model(torch.randn(1, 3, 640, 640))
print(f"Output shape: {output.shape}")  # Should match expected dimensions

Проверка архитектуры модели

Проверка количества FLOPs и распечатка каждого слоя также может помочь отладить проблемы с конфигурацией вашей пользовательской модели. Для корректной модели счетчик FLOPs должен быть ненулевым. Если он равен нулю, то, скорее всего, проблема в прямом проходе. Запуск простого прямого прохода должен показать, с какой именно ошибкой вы столкнулись.

from ultralytics import YOLO

# Build model with verbose output to see layer details
model = YOLO("debug_model.yaml", verbose=True)

# Check model FLOPs. Failed forward pass causes 0 FLOPs.
model.info()

# Inspect individual layers
for i, layer in enumerate(model.model.model):
    print(f"Layer {i}: {layer}")

Пошаговая проверка

1. Начните с минимума: Сначала протестируйте самую простую архитектуру
2. Добавляйте постепенно: Наращивайте сложность слой за слоем
3. Проверьте размеры: Проверьте совместимость каналов и пространственных размеров
4. Убедитесь в масштабировании: Тест с различными масштабами модели (n, s, m)

Часто задаваемые вопросы

Как изменить количество классов в моей модели?

Установите nc параметр в верхней части вашего YAML-файла, чтобы соответствовать количеству классов в вашем наборе данных.

nc: 5 # 5 classes

Могу ли я использовать пользовательскую основу в моей модели YAML?

Да. Вы можете использовать любой поддерживаемый модуль, включая магистрали TorchVision, или определить свой собственный модуль и импортировать его, как описано в разделе Интеграция пользовательских модулей.

Как масштабировать модель для разных размеров (нано, маленький, средний и т.д.)?

Используйте scales разделе в YAML, чтобы определить коэффициенты масштабирования для каналов глубины, ширины и max. Модель автоматически применит их, когда вы загрузите базовый YAML-файл с масштабом, добавленным к имени файла (например, yolo11n.yaml).

Что делает [from, repeats, module, args] формат имеется в виду?

Этот формат определяет, как строится каждый слой:

• from: источник(и) входного сигнала
• repeats: количество повторений модуля
• module: тип слоя
• args: аргументы для модуля

Как устранить ошибки несоответствия каналов?

Проверьте, что выходные каналы одного слоя соответствуют ожидаемым входным каналам следующего. Используйте print(model.model.model) чтобы проверить архитектуру вашей модели.

Где я могу найти список доступных модулей и их аргументы?

Проверьте исходный код в ultralytics/nn/modules directory для всех доступных модулей и их аргументов.

Как добавить пользовательский модуль в конфигурацию YAML?

Определите свой модуль в исходном коде, импортируйте его, как показано в разделе "Модификация исходного кода", и ссылайтесь на него по имени в своем YAML-файле.

Можно ли использовать предварительно обученные веса с помощью пользовательского YAML?

Да, вы можете использовать model.load("path/to/weights") для загрузки весов из предварительно обученной контрольной точки. Однако успешно загрузятся только веса для слоев, которые совпадают.

Как проверить конфигурацию модели?

Используйте model.info() чтобы проверить, является ли количество FLOPs ненулевым. Правильная модель должна показывать ненулевое количество FLOPs. Если он равен нулю, следуйте рекомендациям в разделе Советы по отладке чтобы найти проблему.

📅 Создано 0 дней назад ✏️ Обновлено 0 дней назад