Начать

Обучение моделей с Ultralytics YOLO

Ultralytics YOLO ecosystem and integrations

Введение#

Обучение модели глубокого обучения включает передачу ей данных и настройку параметров, чтобы она могла делать точные предсказания. Режим Train в Ultralytics YOLO26 эффективно обучает модели для обнаружения объектов и других задач компьютерного зрения на современном оборудовании. В этом руководстве собрана информация, необходимая для начала обучения собственных моделей с YOLO26. Если ты ещё не установил Ultralytics, начни с краткого руководства по быстрому старту.

См. предварительную версию YOLO27, пока не выпущенную официально, где представлены запланированные примеры обучения.



Смотри: Как обучить модель YOLO на собственном датасете в Google Colab.

Почему стоит выбрать Ultralytics YOLO для обучения?#

Причины использовать режим Train в YOLO26:

  • Эффективность: Используй оборудование по максимуму — как при работе с одним GPU, так и при масштабировании на несколько GPU.
  • Универсальность: Обучай модели на пользовательских наборах данных, а также на готовых наборах, таких как COCO, VOC и ImageNet.
  • Простота использования: Удобные интерфейсы CLI и Python обеспечивают простой процесс обучения.
  • Гибкая настройка гиперпараметров: Широкий набор настраиваемых гиперпараметров позволяет точно настроить качество модели. Для более тонкого контроля ты можешь настроить сам тренер.
  • Обучение в облаке: Обучай модели на облачных GPU через платформу Ultralytics, отслеживая метрики в реальном времени и автоматически сохраняя контрольные точки.

Ключевые возможности режима обучения#

Вот некоторые примечательные возможности режима обучения YOLO26:

  • Автоматическая загрузка датасетов: Конфигурации датасетов с источником для загрузки автоматически загружаются при первом использовании, например yolo train data=coco8.yaml. Поддерживаемые форматы и датасеты см. в обзоре датасетов.
  • Поддержка нескольких GPU: Масштабируй обучение на несколько GPU, чтобы сократить его продолжительность.
  • Настройка гиперпараметров: Гиперпараметры можно изменять с помощью конфигурационных файлов YAML или аргументов CLI.
  • Визуализация и мониторинг: Отслеживай метрики обучения в реальном времени и визуализируй процесс обучения, чтобы лучше понимать его ход.

Примеры использования#

Обучи YOLO26n на наборе данных COCO8 в течение 100 эпох с размером изображения 640. Устройство для обучения можно указать с помощью аргумента device. Если аргумент не передан, при наличии будет использоваться GPU device=0, иначе — device='cpu'.

Ошибка многопроцессорной обработки в Windows

В Windows при запуске обучения в виде скрипта может возникнуть ошибка RuntimeError. Чтобы устранить ее, добавь блок if __name__ == "__main__": перед кодом обучения.

Пример обучения на одной GPU и CPU

Устройство определяется автоматически. Если доступна GPU, она будет использоваться (по умолчанию — устройство CUDA 0); иначе обучение начнется на CPU.

from ultralytics import YOLO

# Загрузить модель
model = YOLO("yolo26n.yaml")  # создать новую модель из YAML
model = YOLO("yolo26n.pt")  # загрузить предварительно обученную модель (рекомендуется для обучения)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # создать модель из YAML и перенести веса

# Обучить модель
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Обучение на нескольких GPU#

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

Пример обучения на нескольких GPU

Чтобы обучать модель на 2 GPU (устройства CUDA 0 и 1), используй следующие команды. При необходимости добавь другие GPU.

from ultralytics import YOLO

# Загрузить модель
model = YOLO("yolo26n.pt")  # загрузить предварительно обученную модель (рекомендуется для обучения)

# Обучи модель на двух GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

# Обучи модель на двух наименее загруженных GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])
Поддержка нескольких GPU в Windows

Обучение на нескольких GPU не работает в Windows с официальными сборками PyTorch для torch>=2.4. Ultralytics запускает DDP через torch.distributed.run, шаг согласования узлов в котором создает TCPStore. Начиная с PyTorch 2.4 для него по умолчанию используется бэкенд libuv, но официальные сборки для Windows собраны без libuv. Обучение сразу завершается с ошибкой:

RuntimeError: use_libuv was requested but PyTorch was built without libuv support

Установка USE_LIBUV=0 не решит проблему, поскольку согласование узлов напрямую создает TCPStore, и этот путь выполнения не считывает переменную. Чтобы использовать несколько GPU, обучай модель в Linux или WSL2, либо обучай ее на одной GPU с device=0 в Windows.

Обучение на нескольких GPU с пользовательским кодом

Если указать несколько устройств (например, device=[0, 1]), Ultralytics внутренне запускает новый экземпляр тренера и выполняет torch.distributed.run. Это работает при стандартном использовании CLI и в неизменённых скриптах Python.

Однако если скрипт содержит пользовательские компоненты — например, собственный Trainer, валидатор, датасет или конвейер аугментации, — эти объекты нельзя автоматически сериализовать и передать подпроцессам DDP. В этом случае скрипт нужно запускать напрямую с помощью torch.distributed.run:

python -m torch.distributed.run --nproc_per_node 2 your_training_script.py

Для обучения на GPU AMD используется сборка PyTorch с ROCm и стандартный синтаксис device=0 или device=cuda:0. Инструкции по установке ROCm, обучению на нескольких GPU, AMP и инференсу MIGraphX для экспортированных моделей см. в руководстве по интеграции с AMD.

Для обучения на GPU Intel используй device=xpu:0 или несколько идентификаторов XPU со сборкой PyTorch, поддерживающей XCCL.

Обучение на NPU Huawei Ascend#

Ultralytics поддерживает обучение и валидацию на NPU Huawei Ascend с помощью torch_npu. Установи совместимые версии CANN, PyTorch и torch_npu, следуя руководству по установке Ascend Extension for PyTorch, а затем подключи среду CANN перед запуском Ultralytics:

source /usr/local/Ascend/ascend-toolkit/set_env.sh
Пример обучения на NPU Ascend
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Обучай модель на одном NPU Ascend
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")

# Обучай модель на двух NPU Ascend с помощью HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")

Стандартные возможности обучения, включая AMP, валидацию, сохранение контрольных точек и возобновление обучения, используют активный NPU. AutoBatch доступен при обучении на одном NPU, а указание нескольких идентификаторов NPU запускает распределенное обучение через HCCL. Информацию об экспорте моделей и их развертывании после обучения см. в руководстве по интеграции с Huawei Ascend.

Обучение на наименее загруженных GPU#

Функция автоматического выбора свободных GPU для обучения выбирает наименее загруженные GPU в системах с несколькими GPU, поэтому тебе не нужно выбирать устройства вручную. Она ранжирует доступные GPU по загрузке и объёму свободной видеопамяти.

Пример обучения на наименее загруженных GPU

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

from ultralytics import YOLO

# Загрузить модель
model = YOLO("yolo26n.pt")  # загрузить предварительно обученную модель (рекомендуется для обучения)

# Обучай модель на одной наименее загруженной GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)

# Обучай модель на двух наименее загруженных GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

Алгоритм автоматического выбора отдает предпочтение GPU со следующими характеристиками:

  1. Более низкий текущий процент загрузки
  2. Больше доступной памяти (свободной видеопамяти)

Это особенно полезно в общих вычислительных средах или при одновременном запуске нескольких задач обучения: устройства выбираются с учётом текущей ситуации при каждом запуске.

Обучение на Apple Silicon с MPS#

Модели Ultralytics YOLO можно обучать на Apple silicon с помощью фреймворка Metal Performance Shaders (MPS), который выполняет вычисления и обработку изображений на специально разработанных GPU Apple.

Чтобы обучать модель на Apple silicon, укажи mps в качестве устройства при запуске обучения — в Python или командной строке:

Пример обучения с MPS
from ultralytics import YOLO

# Загрузить модель
model = YOLO("yolo26n.pt")  # загрузить предварительно обученную модель (рекомендуется для обучения)

# Обучи модель с помощью MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Возобновление прерванного обучения#

Возобновление обучения из сохранённой контрольной точки полезно, если запуск неожиданно прервался или если ты хочешь продолжить обучение модели на новых данных либо в течение дополнительных эпох.

При возобновлении обучения Ultralytics YOLO загружает веса последней сохранённой модели, а также восстанавливает состояние оптимизатора, планировщик скорости обучения, номер эпохи и набор данных. Затем обучение продолжается с места остановки. Передай явный data= вместе с resume, чтобы продолжить обучение на другом наборе данных, а не на наборе данных из контрольной точки.

Чтобы возобновить обучение в Ultralytics YOLO, при вызове метода train задай аргумент resume равным True и укажи путь к файлу .pt, содержащему частично обученные веса модели.

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

Пример возобновления обучения
from ultralytics import YOLO

# Загрузить модель
model = YOLO("path/to/last.pt")  # загрузи частично обученную модель

# возобнови обучение
results = model.train(resume=True)

Если задать resume=True, функция train продолжит обучение с места остановки, используя состояние, сохранённое в файле path/to/last.pt. Если аргумент resume не указан или равен False, функция train начнёт новый сеанс обучения. При возобновлении запуск, данные которого передаются в Ultralytics Platform, продолжает работу с той же моделью Platform.

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

Параметры обучения#

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

Оптимизатор MuSGD#

В YOLO26 MuSGD — это гибридный оптимизатор, сочетающий стандартные обновления SGD с ортогонализованными обновлениями в стиле Muon.

Его рекомендуется использовать для длительного обучения YOLO26 и больших наборов данных, где ортогонализованные обновления Muon помогают стабилизировать оптимизацию.

Обновление в стиле Muon вместе с SGD применяется только к двумерным линейным весам и четырёхмерным свёрточным фильтрам (преобразованным в двумерную форму). Все остальные параметры, например веса пакетной нормализации и смещения, продолжают обновляться с помощью стандартного SGD.

Если используется optimizer=auto, Ultralytics автоматически выбирает MuSGD для длительного обучения (обычно при количестве итераций > 10000). Для коротких запусков тренер переключается на AdamW. В режиме auto тренер также выбирает скорость обучения, поэтому заданное пользователем значение lr0 игнорируется. Чтобы управлять этими настройками вручную, явно выбери оптимизатор, например optimizer=AdamW lr0=0.001.

Пример использования:

yolo train model=yolo26n.pt data=coco8.yaml optimizer=MuSGD

См. реализацию в ultralytics/optim/muon.py и логику автоматического выбора оптимизатора в BaseTrainer.build_optimizer.

АргументТипПо умолчаниюОписание
modelstrNoneЗадаёт файл модели для обучения. Принимает путь к предварительно обученной модели .pt или файлу конфигурации .yaml. Этот параметр необходим для определения структуры модели или инициализации весов.
datastrNoneПуть к YAML-файлу набора данных (например, coco8.yaml), в котором указаны пути к обучающим и валидационным данным, имена классов и их количество. Для классификации вместо этого укажи каталог набора данных или имя встроенного набора данных (например, imagenet10).
epochsint100Общее количество эпох обучения. Каждая эпоха — это полный проход по всему набору данных. Изменение этого значения может повлиять на длительность обучения и производительность модели.
timefloatNoneМаксимальная длительность обучения в часах. Если задано, это значение переопределяет аргумент epochs и позволяет автоматически остановить обучение по истечении указанного времени. Полезно, когда время обучения ограничено.
patienceint100Количество эпох без улучшения метрик на валидации, после которого обучение останавливается досрочно. Помогает предотвратить переобучение: обучение прекращается, когда качество перестаёт расти.
batchint или float16Размер пакета, три режима: задать целое число (например, batch=16), автоматический режим, использующий 60% доступной памяти GPU (batch=-1), или автоматический режим с заданной долей доступной памяти GPU (batch=0.70).
imgszint640Целевой размер изображений для обучения. Изображения преобразуются в квадраты с длиной стороны, равной заданному значению (если rect=False); модели YOLO сохраняют соотношение сторон, а RT-DETR — нет. Параметр влияет на точность модели и вычислительную сложность.
saveboolTrueВключает сохранение контрольных точек обучения и итоговых весов модели. Полезно для возобновления обучения или развёртывания модели.
save_periodint-1Частота сохранения контрольных точек модели, заданная в эпохах. Значение -1 отключает эту функцию. Полезно для сохранения промежуточных моделей при длительном обучении.
cachebool или strFalseВключает кэширование изображений набора данных в памяти (True/ram), на диске (disk) или отключает кэширование (False). Ускоряет обучение за счёт сокращения операций ввода-вывода с диском, но увеличивает потребление памяти.
tilebool или intFalseРазбивает каждое исходное изображение на фиксированные обучающие тайлы, обрезая аннотации и сохраняя пустые окна. True использует imgsz; положительное целое число задаёт размер тайла. Подробнее: Тайлинг изображений высокого разрешения.
deviceint, str или listNoneЗадаёт вычислительное устройство или устройства для обучения: один GPU (device=0), несколько GPU (device=[0,1]), CPU (device=cpu), MPS для Apple silicon (device=mps), NPU Huawei Ascend (device=npu:0 или device=npu:0,1), Intel XPU (device=xpu:0), автоматический выбор свободного GPU (device=-1) или нескольких свободных GPU (device=[-1,-1]).
workersint8Количество рабочих потоков для загрузки данных (на каждый RANK при обучении на нескольких GPU). Влияет на скорость предварительной обработки данных и их передачи в модель; особенно полезно при работе с несколькими GPU.
projectstrNoneНазвание каталога проекта, в котором сохраняются результаты обучения. Относительный путь указывается относительно runs_dir/<task>, а абсолютный используется без изменений.
namestrNoneИмя запуска обучения. Используется для создания подкаталога в папке проекта, где хранятся журналы и результаты обучения.
exist_okboolFalseЕсли задано значение True, разрешает перезаписать существующий каталог с именем проекта/запуска. Полезно для повторных экспериментов, когда не нужно вручную удалять предыдущие результаты.
save_dirstrNoneЗадаёт точный каталог для сохранения результатов запуска, переопределяя сочетание project/name. Путь используется без изменений и автоматической нумерации, поэтому последующие запуски используют тот же каталог.
pretrainedbool или strTrueОпределяет, начинать ли обучение с предварительно обученных весов. Можно указать логическое значение или строковый путь к загружаемым весам. pretrained=False запускает обучение со случайно инициализированными весами, сохраняя архитектуру модели.
cls_remapboolTrueПри дообучении на разных наборах данных копирует строки предварительно обученной классификационной головы в новую модель для совпадающих имён классов. Благодаря этому общие классы сохраняют выученные смещения, а также веса, если ширина головы не изменилась. Работает как при разном количестве классов, так и при одинаковом количестве классов в другом порядке.
optimizerstr'auto'Выбор оптимизатора для обучения. Доступны варианты SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp и auto, чтобы выбрать AdamW или MuSGD в зависимости от количества итераций обучения. Влияет на скорость и стабильность сходимости.
seedint0Задаёт случайное начальное значение для обучения, обеспечивая воспроизводимость результатов при одинаковых настройках запусков.
deterministicboolTrueПринудительно использует детерминированные алгоритмы, обеспечивая воспроизводимость результатов. Ограничение недетерминированных алгоритмов может повлиять на производительность и скорость.
verboseboolTrueВключает подробный вывод во время обучения: индикаторы выполнения, метрики для каждой эпохи и дополнительные сведения об обучении в консоли.
single_clsboolFalseПри обучении на многоклассовых наборах данных рассматривает все классы как один. Полезно для задач бинарной классификации или когда важно определить наличие объекта, а не его класс.
classeslist[int]NoneЗадаёт список идентификаторов классов для обучения. Полезно, чтобы отфильтровать классы и сосредоточиться только на выбранных.
rectboolFalseВключает стратегию минимального дополнения: изображения в батче дополняются по минимуму, чтобы достичь общего размера, при этом длинная сторона равна imgsz. Это может повысить эффективность и скорость, но повлиять на точность модели. Стандартный тренер YOLO использует rect=True для валидации задач обнаружения, сегментации, оценки позы и OBB независимо от этой настройки.
multi_scalefloat0.0Случайным образом изменяет imgsz для каждого пакета на +/- multi_scale (например, 0.25 -> 0.75x to 1.25x), округляя значения до кратных шагу модели; 0.0 отключает обучение с несколькими масштабами.
cos_lrboolFalseИспользует косинусный планировщик скорости обучения, изменяя скорость обучения по косинусной кривой на протяжении эпох. Помогает подобрать скорость обучения для лучшей сходимости.
close_mosaicint10Отключает мозаичную аугментацию данных за последние N эпох, чтобы стабилизировать обучение перед его завершением. Значение 0 отключает эту функцию.
resumeboolFalseВозобновляет обучение с последней сохранённой контрольной точки. Автоматически загружает веса модели, состояние оптимизатора и номер эпохи, продолжая обучение с того места, где оно было остановлено.
ampbool или strTrueЗадаёт точность вычислений при обучении: True или "fp16" используют FP16, "bf16" — BF16 на поддерживаемых устройствах CUDA, а False или "fp32" — FP32.
quantizeint или strNoneЗадай 8 (или "int8"), чтобы включить обучение с учётом квантования INT8 (QAT). При дообучении применяется имитация квантования, чтобы веса подходили для экспорта в INT8. См. обучение с учётом квантования.
fractionfloat, int или list1.0Подмножество набора данных в виде доли/количества или списка [train, val, test]. 1 означает полное разбиение; целые числа больше 1 задают количество изображений. Только необязательный параметр test принимает 0/0.0 в значении «нет». В списках из двух элементов тестовый набор остаётся полным.
profileboolFalseВключает профилирование скорости ONNX и TensorRT во время обучения; полезно для оптимизации развёртывания модели.
freezeint или listNoneЗамораживает первые N слоёв модели или определённые слои по индексу или имени модуля (23.cv2, без начального model.), уменьшая количество обучаемых параметров. Полезно для дообучения или переноса обучения.
lr0float0.01Начальная скорость обучения (например, SGD=1E-2, Adam=1E-3). При использовании оптимизатора по умолчанию optimizer='auto' игнорируется; чтобы использовать это значение, укажи оптимизатор явно.
lrffloat0.01Итоговая скорость обучения как доля от начальной скорости = (lr0 * lrf); используется совместно с планировщиками для изменения скорости обучения со временем.
momentumfloat0.937Импульс SGD/MuSGD или beta1 для оптимизаторов Adam. При использовании optimizer=auto AdamW применяет 0.9; MuSGD начинает с 0.9, затем при прогреве интерполирует от warmup_momentum до momentum. Без прогрева автоматический MuSGD остаётся на 0.9.
weight_decayfloat0.0005Параметр L2-регуляризации, который штрафует большие веса и помогает предотвратить переобучение.
warmup_epochsfloat3.0Эпохи разогрева (допускаются дробные значения), ограниченные так, чтобы последняя эпоха прошла без разогрева. Скорость обучения линейно увеличивается от 0 (смещение из warmup_bias_lr) до запланированного значения, моментум — от warmup_momentum до momentum, а накопление градиентов — от 1 пакета до номинального значения (см. nbs); все целевые значения достигаются к окончанию разогрева.
warmup_momentumfloat0.8Начальный моментум для оптимизаторов с параметром моментума (SGD, MuSGD, RMSprop), линейно увеличивающийся до momentum к окончанию разогрева. Значение beta1 для семейства Adam не разогревается.
warmup_bias_lrfloat0.1Скорость обучения для параметров смещения на этапе разогрева, помогающая стабилизировать модель в первых эпохах. При использовании оптимизатора optimizer='auto' по умолчанию автоматически задаётся значение 0.0; чтобы применить этот параметр, укажи оптимизатор явно.
distill_modelstrNoneПуть к контрольной точке модели-учителя (например, yolo26x.pt) для дистилляции знаний. Если задан, модель-ученик обучается с дополнительной функцией потерь дистилляции, направляемой замороженной моделью-учителем.
disfloat6.0Вес функции потерь дистилляции, добавляемой к стандартным потерям обнаружения. Чем выше значение, тем сильнее влияние признаков, предоставляемых моделью-учителем.
boxfloat7.5Вес компонента потерь для рамок в функции потерь, определяющий, насколько важна точность предсказания координат ограничивающих рамок.
clsfloat0.5Вес потерь классификации в общей функции потерь, определяющий важность правильного предсказания класса относительно других компонентов.
cls_pwfloat0.0Степень взвешивания классов для устранения дисбаланса с помощью обратной частоты классов. 0.0 отключает взвешивание классов, 1.0 включает полное взвешивание по обратной частоте. Значения от 0 до 1 обеспечивают частичное взвешивание.
dflfloat1.5Вес компонента регрессии расстояний до рамки: распределённая фокальная функция потерь (DFL), если голова обнаружения использует reg_max > 1; потери L1 для нормализованных расстояний до рамки в YOLO26 без DFL (reg_max: 1).
posefloat12.0Вес потерь позы в моделях, обученных для оценки позы; определяет важность точного предсказания ключевых точек позы.
kobjfloat1.0Вес потерь уверенности в наличии объекта в ключевой точке для моделей оценки позы; задаёт баланс между уверенностью обнаружения и точностью оценки позы.
rlefloat1.0Вес потерь оценки остаточного логарифмического правдоподобия в моделях оценки позы; влияет на точность локализации ключевых точек.
anglefloat1.0Вес потерь угла в моделях OBB; влияет на точность предсказания угла ориентированных ограничивающих рамок.
dlogfloat1.0Вес потерь масштабно-инвариантного логарифмического критерия (SILog) в моделях оценки глубины; это основной компонент, определяющий точность оценки глубины.
dgradfloat0.5Вес градиентных потерь в моделях оценки глубины: штрафует ошибки на границах глубины и помогает чётче выделять границы поверхностей.
dlamfloat1.0Коэффициент фокусировки дисперсии в функции потерь SILog для моделей оценки глубины. Значение 1.0 делает функцию потерь полностью масштабно-инвариантной, а 0.0 сводит её к обычной логарифмической RMSE.
nbsint64Номинальный размер пакета. Градиенты накапливаются за round(nbs / batch) пакетов на один шаг оптимизатора (не менее 1 и, вне режима time, не больше общего числа пакетов за запуск), а weight_decay масштабируется на batch * accumulate / nbs для соответствия.
overlap_maskboolTrueОпределяет, объединять ли маски объектов в одну маску для обучения или хранить их раздельно для каждого объекта. При объединении перекрывающиеся меньшие маски накладываются поверх больших.
mask_ratioint4Коэффициент уменьшения разрешения масок сегментации, влияющий на разрешение масок, используемых при обучении. Не изменяет разрешение предсказанных масок.
dropoutfloat0.0Уровень Dropout для регуляризации задач классификации. Помогает предотвратить переобучение, случайным образом отключая нейроны во время обучения.
valboolTrueВключает валидацию во время обучения и периодическую оценку производительности модели на отдельном наборе данных.
splitstr'val'Набор данных, используемый для валидации во время обучения: val, test или train. Его метрики выбирают best.pt и управляют ранней остановкой.
nmsbool, необязательноNoneВыбирает голову инференса для валидации эпох, выбора контрольной точки и ранней остановки. None или True использует схему one-to-many с NMS; False использует голову без NMS, если она доступна. Обе головы сохраняют потери обучения.
plotsboolTrueСоздаёт и сохраняет графики метрик обучения и валидации, а также примеры предсказаний, наглядно показывая производительность модели и ход обучения.
compilebool или strFalseВключает компиляцию графа torch.compile в PyTorch 2.x с помощью backend='inductor'. Принимает значения True → "default", False → отключение или строковый режим, например "default", "reduce-overhead", "max-autotune-no-cudagraphs". Если режим не поддерживается, выполняется откат к eager-режиму с предупреждением.
channels_lastboolNoneИспользует формат памяти channels_last (NHWC) для свёрток во время обучения. None автоматически включает его при использовании CUDA с PyTorch 1.11 или новее, кроме Windows и AMD ROCm, где он показал более низкую скорость. False отключает его, а True явно включает. При обучении на CPU или MPS всегда используется NCHW (True игнорируется с предупреждением).
max_detint300Максимальное количество обнаружений на изображение при валидации во время обучения. Для detect, segment, pose и OBB значение по умолчанию 300 увеличивается до наибольшего количества размеченных объектов в train/val только в том случае, если это количество превышает 300. Другие значения остаются неизменными; при превышении лимита выводится предупреждение.
Примечание о настройках размера пакета

Аргумент batch принимает три типа значений, а тренер добавляет две дополнительные меры защиты:

  • Фиксированный размер батча: укажи целое значение (например, batch=16), чтобы задать количество изображений в батче напрямую. При обучении на нескольких GPU общий размер батча равномерно распределяется между GPU, поэтому он должен быть не меньше количества GPU; остаток отбрасывается (например, при значении batch=15 на 2 GPU на каждом GPU обучаются 7 изображений).
  • Автоматический режим (60% памяти GPU): используй batch=-1, чтобы автоматически настроить размер пакета примерно на 60% памяти CUDA, доступной для обучения.
  • Автоматический режим с заданной долей использования: укажи значение доли (например, batch=0.70), чтобы настроить размер пакета с учетом заданной доли доступной памяти GPU.
  • Автоматический повтор при нехватке памяти: если в течение первой эпохи возникает ошибка нехватки памяти CUDA, тренер автоматически уменьшает размер пакета вдвое и повторяет попытку (до 3 раз). Это применимо только при обучении на одном GPU; при обучении на нескольких GPU (DDP) ошибка возникнет сразу.
  • Подходящий вариант не найден: если ни один из предложенных размеров пакета не позволяет получить пригодный профиль, AutoBatch выдаёт понятную ошибку RuntimeError, а не молча использует неподходящее значение по умолчанию.

Настройки аугментации и гиперпараметры#

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

АргументТипПо умолчаниюПоддерживаемые задачиДиапазонОписание
hsv_hfloat0.015detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Изменяет оттенок изображения на долю цветового круга, внося разнообразие цветов. Помогает модели обобщать результаты при разных условиях освещения. Для classify применяется только при auto_augment=None.
hsv_sfloat0.7detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Изменяет насыщенность изображения на заданную долю, влияя на интенсивность цветов. Полезно для имитации различных условий окружающей среды. Для classify применяется только при auto_augment=None.
hsv_vfloat0.4detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Изменяет значение (яркость) изображения на заданную долю, помогая модели хорошо работать при различных условиях освещения. Для classify применяется только при auto_augment=None.
degreesfloat0detect, segment, semantic, depth, pose, obb0.0 - 180Случайным образом поворачивает изображение в заданном диапазоне углов, помогая модели распознавать объекты при различной ориентации.
translatefloat0.1detect, segment, semantic, depth, pose, obb0.0 - 1.0Сдвигает изображение по горизонтали и вертикали на долю его размера, помогая модели учиться обнаруживать частично видимые объекты.
scalefloat | tuple0.5detect, segment, semantic, depth, classify, pose, obb0 - 1 или явно заданный кортеж (min, max) (не для classify)Масштабирует изображение с заданным коэффициентом, имитируя объекты на разных расстояниях от камеры.
shearfloat0detect, segment, semantic, depth, pose, obb-180 - +180Сдвигает изображение под заданным углом, имитируя вид объектов с разных ракурсов.
perspectivefloat0detect, segment, semantic, depth, pose, obb0.0 - 0.001Применяет к изображению случайное перспективное преобразование, улучшая способность модели понимать объекты в 3D-пространстве.
flipudfloat0detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Переворачивает изображение вверх ногами с заданной вероятностью, увеличивая разнообразие данных без изменения характеристик объекта.
fliplrfloat0.5detect, segment, semantic, depth, classify, pose, obb0.0 - 1.0Отражает изображение по горизонтали с заданной вероятностью. Это полезно для обучения распознаванию симметричных объектов и увеличения разнообразия набора данных.
bgrfloat0detect, segment, semantic, depth, pose, obb0.0 - 1.0Меняет порядок каналов изображения с RGB на BGR с заданной вероятностью, повышая устойчивость к неправильному порядку каналов.
mosaicfloat1detect, segment, semantic, pose, obb0.0 - 1.0Объединяет четыре обучающих изображения в одно, имитируя различные композиции сцен и взаимодействия объектов. Эффективно для понимания сложных сцен.
mixupfloat0detect, segment, semantic, pose, obb0.0 - 1.0Смешивает два изображения и их метки, создавая составное изображение. Помогает модели лучше обобщать за счёт внесения шума в метки и визуального разнообразия.
cutmixfloat0detect, segment, semantic, pose, obb0.0 - 1.0Объединяет фрагменты двух изображений, создавая частичное смешение при сохранении отдельных областей. Повышает устойчивость модели за счёт создания сценариев с перекрытием объектов.
copy_pastefloat0segment, semantic, obb0.0 - 1.0Доля подходящих объектов, которые вставляются; flip зеркально отражает их внутри изображения, а mixup также использует это значение как вероятность применения между изображениями.
copy_paste_modestrflipsegment, semantic, obb-Задаёт используемую стратегию copy-paste. Доступны варианты 'flip' и 'mixup'.
auto_augmentstrrandaugmentclassify-Применяет заранее заданную политику аугментации ('randaugment', 'autoaugment' или 'augmix'), чтобы повысить производительность модели за счёт визуального разнообразия.
erasingfloat0.4classify0.0 - 1.0Во время обучения случайным образом стирает области изображения, побуждая модель обращать внимание на менее очевидные признаки.
augmentationslistNonedetect, segment, semantic, depth, pose, obb-Пользовательские преобразования Albumentations для расширенной аугментации данных (только Python API). Принимает список объектов преобразования для специализированной аугментации.

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

Информация

Подробнее об операциях аугментации при обучении см. в справочном разделе.

Журналирование#

Метрики обучения, графики и контрольные точки всегда сохраняются в каталоге запуска. Кроме того, Ultralytics передаёт их в любой трекер экспериментов, который ты установил и включил: Comet, ClearML, TensorBoard, MLflow, Weights & Biases и DVCLive. Каждый логгер включается или отключается в настройках Ultralytics, например с помощью yolo settings tensorboard=True. Ниже показаны три наиболее распространённые конфигурации.

Comet#

Comet — платформа, позволяющая специалистам по данным и разработчикам отслеживать, сравнивать, объяснять и оптимизировать эксперименты и модели. Она предоставляет метрики в реальном времени, различия в коде и данные об отслеживании гиперпараметров.

Чтобы использовать Comet:

Пример
# pip install comet_ml
import comet_ml

comet_ml.login()

Не забудь войти в свою учётную запись Comet на сайте и получить API-ключ. Чтобы журналировать эксперименты, добавь этот ключ в переменные окружения или в скрипт.

ClearML#

ClearML — это платформа с открытым исходным кодом, которая автоматизирует отслеживание экспериментов и помогает эффективно совместно использовать ресурсы. Она помогает командам эффективнее управлять работой в области машинного обучения, выполнять её и воспроизводить результаты.

Чтобы использовать ClearML:

Пример
# pip install clearml
import clearml

clearml.browser_login()

После запуска этого скрипта войди в свою учётную запись ClearML в браузере и авторизуй сеанс.

TensorBoard#

TensorBoard — это набор инструментов визуализации для TensorFlow. Он позволяет визуализировать граф вычислений TensorFlow, строить графики количественных метрик его выполнения и отображать дополнительные данные, например изображения, проходящие через граф.

Чтобы использовать TensorBoard в Google Colab:

Пример
%load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directory

Чтобы использовать TensorBoard локально, выполни приведённую ниже команду и просматривай результаты по адресу localhost:6006.

Пример
tensorboard --logdir ultralytics/runs # replace with 'runs' directory

TensorBoard запустится и откроет каталог, в котором сохранены журналы обучения.

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

Что дальше#

Проверь обученную модель на отложенных данных, чтобы оценить её точность в реальных условиях, а затем экспортируй её в ONNX, TensorRT или другой формат для развёртывания. Обучаешь модель на собственных данных, а не на COCO8? Сначала подготовь их, воспользовавшись руководством по наборам данных.

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

  • Да. Облачное обучение на платформе Ultralytics включает бесплатные кредиты для начала работы. Загрузи набор данных, выбери модель и GPU и обучай её прямо в браузере.

  • Для обучения модели обнаружения объектов с помощью Ultralytics YOLO26 можно использовать Python API или CLI. Ниже приведены примеры обоих способов:

    Пример обучения на одной GPU и CPU
    from ultralytics import YOLO
    
    # Загрузить модель
    model = YOLO("yolo26n.pt")  # загрузить предварительно обученную модель (рекомендуется для обучения)
    
    # Обучить модель
    results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

    Подробнее см. в разделе Настройки обучения.

  • К ключевым возможностям режима Train в Ultralytics YOLO26 относятся:

    • Автоматическая загрузка наборов данных: автоматическая загрузка стандартных наборов данных, таких как COCO, VOC и ImageNet.
    • Поддержка нескольких GPU: масштабирование обучения на несколько GPU для ускорения обработки.
    • Настройка гиперпараметров: настройка гиперпараметров с помощью файлов YAML или аргументов CLI.
    • Визуализация и мониторинг: отслеживание метрик обучения в реальном времени для более глубокого анализа.

    Эти возможности позволяют эффективно настраивать обучение под свои задачи. Подробнее см. в разделе Ключевые возможности режима Train.

  • Чтобы возобновить обучение после прерывания сеанса, задай для аргумента resume значение True и укажи путь к последней сохранённой контрольной точке.

    Пример возобновления обучения
    from ultralytics import YOLO
    
    # Загрузи частично обученную модель
    model = YOLO("path/to/last.pt")
    
    # возобнови обучение
    results = model.train(resume=True)

    Дополнительную информацию см. в разделе Возобновление прерванного обучения.

  • Дисбаланс классов возникает, когда в обучающих данных примеров одних классов значительно меньше, чем других. Из-за этого модель может плохо работать с редкими классами. Ultralytics YOLO поддерживает взвешивание классов с помощью аргумента cls_pw, чтобы решить эту проблему. Взвешивание функции потерь лучше всего применять на последнем этапе — после сбора и увеличения числа примеров редких классов, как описано в статье Работа с дисбалансом классов.

    Аргумент cls_pw задаёт силу взвешивания классов на основе обратной частоты классов:

    • cls_pw=0.0 (по умолчанию): взвешивание классов отключено
    • cls_pw=1.0: применяется полное взвешивание по обратной частоте
    • Значения от 0.0 до 1.0: обеспечивают частичное взвешивание при умеренном дисбалансе

    Веса классов вычисляются как (1.0 / class_counts) ^ cls_pw и нормализуются так, чтобы их среднее значение равнялось 1.0. class_counts — это количество размеченных объектов для каждого класса или количество обучающих изображений для каждого класса в задаче классификации; классы без обучающих меток, например исключённые с помощью classes=, получают вес 1.0. В семантической сегментации веса вычисляются на основе частоты пикселей, а именно как (1.0 / ln(1.02 + p)) ^ cls_pw, где p — доля размеченных обучающих пикселей для каждого класса, поэтому класс без размеченных пикселей получает наибольший вес.

    Обучение на несбалансированном наборе данных
    from ultralytics import YOLO
    
    # Загрузи предварительно обученную модель
    model = YOLO("yolo26n.pt")
    
    # Обучай с полным взвешиванием классов при сильном дисбалансе данных
    results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=1.0)
    
    # Или используй частичное взвешивание (0.25) при умеренном дисбалансе
    results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=0.25)
    Совет

    Для наборов данных с умеренным дисбалансом начни со значения cls_pw=0.25 и увеличь его до 1.0, если качество на редких классах останется низким. Чтобы проверить распределение весов, посмотри вычисленные веса классов в журналах обучения.

  • Да, Ultralytics YOLO26 поддерживает обучение на чипах Apple silicon с использованием фреймворка Metal Performance Shaders (MPS). Укажи mps в качестве устройства для обучения.

    Пример обучения с MPS
    from ultralytics import YOLO
    
    # Загрузи предварительно обученную модель
    model = YOLO("yolo26n.pt")
    
    # Обучи модель на чипе Apple silicon (M1/M2/M3/M4)
    results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

    Подробнее см. в разделе Обучение на Apple silicon с MPS.

  • Ultralytics YOLO26 позволяет с помощью аргументов настраивать различные параметры обучения, например размер пакета, скорость обучения, число эпох и другие. Краткий обзор:

    АргументПо умолчаниюОписание
    modelNoneПуть к файлу модели для обучения.
    dataNoneПуть к YAML-файлу набора данных (например, coco8.yaml) либо к каталогу или названию набора данных (например, imagenet10) для классификации.
    epochs100Общее число эпох обучения.
    batch16Размер пакета; можно задать целое число или выбрать автоматический режим.
    imgsz640Целевой размер изображения для обучения.
    deviceNoneВычислительное устройство или устройства для обучения, например cpu, 0, 0,1 или mps.
    saveTrueВключает сохранение контрольных точек обучения и итоговых весов модели.

    Подробное руководство по настройкам обучения см. в разделе Настройки обучения.

Комментарии1 074

Задай вопрос, поделись результатами или помоги кому-нибудь.

  1. drcosimoGitHub

    Hi there, I' m new to this field and I'm trying to train a YOLO model for detection and tracking of video streams for security.

    Until now I have managed to create my pipeline for training and I want to understand if it's a correct/possible approach:

    1. Load a pretrained model from yolo

    2. transfer learning with my custom dataset that possibly can focus on just some classes(person,car,truck,bus,bycicle)

    3. Validate model to see how it performs

    4. Operate a tuning with the custom best model and using my custom dataset

    5. Retrain the initial pretrained model with my custom dataset and the best hyperparameters found in the tuning process.

    6. Validate final model

    The questions are several:

    • The above approach is logically correct or it has flaws?
    • Is it correct to narrow the detected classes? Or it isn't crucial to the precision of the model?
    • When tuning(if its a correct approach) should i use my dataset or try the coco dataset to keep generalization?
    • When tuning should i specify the classes to detect?
    • When retraining should I use the first pretrained model or it is better to use my custom trained model?
    • In the final training am I using the correct parameters?

    Here the code of the pipeline:

    from ultralytics import YOLO import yaml

    load pretrained model from coco dataset

    model:YOLO = YOLO('yolov8n.yaml').load('yolov8n.pt')

    train_classes = []

    NOTE if you're using COCO format, the new dataset should also be in COCO format.

    operate transfer learning with my custom dataset, narrowing the classes to the ones I want to detect

    model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,optimizer='AdamW',device=[0,1],augment=True,name='custom_model')

    load custom model

    custom_model = YOLO('path/to/best.pt')

    validate custom model

    custom_model.val()

    try tuning to find the best hyperparameters for my custom model

    custom_model.tune(data='custom_data.yaml', epochs=50, iterations=100,optimizer="AdamW", plots=True,save=True,val=True)

    load best hyperparameters

    cfg = yaml.load(open('path/to/best_hyperparameters.yaml'))

    retrain custom model from pretrained on coco with best hyperparameters

    model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,device=[0,1],name='custom_model',exist_ok=True,optimizer='AdamW',**cfg)

    load and validate

    tuned_custom_model = YOLO('path/to/best.pt')

    tuned_custom_model.val()


    Thank you for your effort and time in this project!

    3
    1. Paula DerrengerUltralytics(изменено)

      Hello,

      Your approach to training a YOLO model for detection and tracking is well-thought-out and mostly aligns with best practices. Here are some insights and answers to your questions:

      1. Approach Validity: Your steps are logically sound. Starting with a pretrained model and applying transfer learning to your specific classes is a recommended strategy. Validating and tuning based on the performance helps refine the model further.

      2. Narrowing Detected Classes: It's perfectly fine to focus on specific classes if those are the only ones relevant to your use case. This can help improve the model's performance by reducing the complexity of the problem it needs to solve.

      3. Dataset for Tuning: Use your custom dataset for tuning. This ensures that the hyperparameters are optimized for the specific characteristics of your data rather than the general characteristics of the COCO dataset.

      4. Specifying Classes During Tuning: When tuning, you should specify the classes if your dataset is a subset of the original classes used in the pretrained model. This helps in focusing the model’s learning and evaluation on relevant classes.

      5. Model for Retraining: Tuning only finds hyperparameters, so the usual practice is to train again from the original pretrained model with the best hyperparameters, as in your step 5. Continuing from the already fine-tuned model is also possible, but then it effectively trains for longer, which makes the result harder to compare with the tuning runs.

      6. Parameters for Final Training: The parameters should be chosen based on the results of your tuning. Ensure that they are the ones that gave the best validation performance during the tuning phase.

      Keep up the great work, and don't hesitate to reach out if you have more questions!

    2. drcosimoGitHub

      Thank you very much for you response. I adjusted my script to follow your insights. I have another question regarding transfer learning. The normal approach in transfer learning is to freeze the first n layers to preserve the more generic feature extraction properties of an already trained model and then it is retrained letting only the remaining layers update. I found the callback function to achieve this. My question is, applying the fine-tuning as specified by ultralytics documentation has the same effect? What I mean is: executing the train method again on a pretrained model changing the dataset causes the underlying library to execute the freeze automatically? If it isn't the case it is not clear to me why the fine-tuning is said to have the same effect as applying transfer learning.

      Another question is: it is useful to take a pretrained model from ultralytics and train it with the coco dataset? Because from what I know the pretrained model is already trained using coco dataset. Doing such a thing following the logic you provide for fine-tuning would be essentially the same as resuming a training / do the same train with more epochs?

      Thank you again for your time.

    3. Paula DerrengerUltralytics

      Hello,

      Thank you for your follow-up questions. Let's address each of them:

      1. Freezing Layers in Transfer Learning: The Ultralytics YOLO framework does not automatically freeze any layers when you initiate training, even if you're using a pretrained model. If you want to freeze the first N layers (common in transfer learning to preserve learned features), you must explicitly specify this in your training script. This is different from some other frameworks that might automate this aspect of transfer learning.

      2. Training on COCO Dataset with a Pretrained Model: If the pretrained model you are using was already trained on the COCO dataset, retraining it on the same dataset without significant changes or additional data might not yield substantial improvements. It could be beneficial for fine-tuning if you've made modifications to the model architecture or if you're using a significantly altered version of the dataset. However, generally, this approach would indeed be akin to simply extending the training duration.

      For fine-tuning and transfer learning, it's crucial to tailor the approach based on what changes you've made to the dataset or model and your specific goals (e.g., improving accuracy, adapting to new classes, etc.).

      I hope this clarifies your queries! If you have more questions or need further assistance, feel free to ask.

    1. Paula DerrengerUltralytics

      哈哈,确实,“train”翻译成“火车”听起来很有趣 😄。这里的“train”应该翻译为“训练”,指的是在机器学习中对模型进行训练,以提高其准确性和效率。感谢您指出这个问题,我们会尽快修正翻译错误。如果您有任何其他建议或问题,欢迎随时告诉我们!🚀

      2
  2. Syedshajib55GitHub

    Hi, does platform.ultralytics currently support using custom PyTorch modules directly via a YAML configuration without modifying tasks.py or the core source code? We are attempting to train a custom architecture (e.g., YOLO26) and want to know if there is an existing feature for dynamic module registration.

    1
    1. Muh-7GitHub

      Hi, As far as I know, not at the moment. Ultralytics doesn't seem to have a built-in dynamic registration system where you can define a custom PyTorch module outside the repo and then use it directly in the YAML.

      Usually, the custom module still needs to be imported/registered in tasks.py so that parse_model() can resolve it from the YAML.

      It would be really useful if Ultralytics added something like a register_module() API for this, though.

    2. Murat Raimbekov

      @Syedshajib55 @Muh-7 Platform can train any model that the ultralytics Python package can build, including custom architectures from a modified package or fork. The custom code runs on your own hardware; Platform receives real-time metrics, console and system logs, plots, and the final weights.

      There is no dynamic registration API. parse_model() resolves layer names from the ultralytics.nn.tasks namespace, so a name in your YAML must exist there. You don't need to edit tasks.py for that — expose the class from your own package before building the model:

      import ultralytics.nn.tasks as tasks
      from my_custom_package import MyBlock
      
      tasks.MyBlock = MyBlock  # now `[-1, 1, MyBlock, [...]]` resolves in the YAML

      Full local training with metric streaming to Platform:

      pip install "ultralytics>=8.4.120"
      export ULTRALYTICS_API_KEY="YOUR_API_KEY"
      import ultralytics.nn.tasks as tasks
      from my_custom_package import MyBlock
      from ultralytics import YOLO
      
      tasks.MyBlock = MyBlock
      
      model = YOLO("custom-model.yaml")  # YAML referencing MyBlock
      model.train(
          data="ul://username/datasets/my-dataset",
          epochs=100,
          project="username/my-project",
          name="custom-architecture",
      )

      project and name enable the Platform integration automatically; nothing else is required. Verified on 8.4.157 with a custom nn.Module inserted into a YOLO26n YAML: the model builds, trains, and appears on Platform as a completed run with weights and train args.

      One caveat: the saved .pt pickles the class by import path (my_custom_package.MyBlock), so any environment that loads it needs that package importable — otherwise loading fails with ModuleNotFoundError. That includes Platform-side features that load the uploaded weights with the stock package (Predict, Export, Deploy); local training and streaming are unaffected. Setup details: https://docs.ultralytics.com/platform/train/cloud-training/#remote-training

    1. Glenn JocherUltralytics

      @RussellLee12345 to rotate your training images randomly up to 360 degrees, set the degrees parameter to 180 in your training configuration. This allows for rotations within the range of -180 to +180 degrees. For more details, see the augmentation settings in the Train Settings documentation.

  3. GKYofficeGitHub

    Please tell me how to set imgsz when I use the yolo11 model for training. Can it only be an integer (this means that the final input is a square)? After I modify this parameter, will the input interface of the network change the input of data? There are corresponding transformations, such as imgsz=1280, does it mean that my input data will be resized to 1280*1280 and input into the network for training?

    Thanks!

    1
    1. Glenn JocherUltralytics

      @GKYoffice when using the YOLO11 model, imgsz can be set as an integer, which resizes the input data to a square of that size (e.g., 1280x1280). This parameter adjusts the input dimensions for training. For more details, please visit the training documentation.

  4. IruhDegSetGitHub

    hi, I'm just wondering if yolov8 accepts class weights, in the data.yaml file:

    names: ['class 1', 'class 2', 'class 3']
    classes_weights: [c1_weight, c2_weight, c3_weight]

    if no how to incorpoorate wighted loss in yolov8 THX

    1
    1. Glenn JocherUltralytics

      @IruhDegSet yOLOv8 does not directly support class weights in the data.yaml file. To incorporate weighted loss, you can modify the loss function in the training script to apply different weights to each class. For more details, you might explore custom loss implementations in PyTorch.

    2. Glenn JocherUltralytics(изменено)

      Yes, YOLO11 supports similar features, including training and hyperparameter customization. For specific details on YOLO11, please refer to the documentation or the relevant sections in the repository.

  5. User

    Dear author, how are the weights of these three losses set: box: 7.5, cls: 0.5, dfl: 1.5? Are they adjusted on the COCO validation, manually adjusted, or obtained through hyperparameter search? For the model I trained, the output confidence scores are very low. I directly increased the weight of cls by 10 times, but the effect did not improve. What other methods can I take?

    1
    1. Glenn JocherUltralytics

      @Stephen-Hao the weights for the box, cls, and dfl losses in YOLOv8 are typically set based on empirical results and fine-tuning on standard datasets like COCO. These values are chosen to balance the contributions of each loss component to the overall training process. If increasing the cls weight did not improve your model's performance, consider the following approaches:

      1. Hyperparameter Tuning: Experiment with other hyperparameters such as learning rate, batch size, and augmentation settings.
      2. Data Quality: Ensure your dataset is well-labeled and balanced. Poor quality data can significantly affect model performance.
      3. Training Duration: Increase the number of epochs to allow the model more time to learn.
      4. Validation: Regularly validate your model to monitor overfitting and adjust training strategies accordingly.

      For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.

    2. Glenn JocherUltralytics

      @Stephen-Hao thank you for your question! The weights for box, cls, and dfl losses are typically set based on empirical results and fine-tuning on standard datasets like COCO. If increasing the cls weight didn't improve your model's performance, consider experimenting with other hyperparameters such as learning rate, batch size, and augmentation settings. Additionally, ensure your dataset is well-labeled and balanced. For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.

    1. Glenn JocherUltralytics(изменено)

      Hey there! 🙌 It's awesome that you're looking to further improve your model with new data. To re-train a pre-trained model on a new dataset, you can simply follow these steps:

      1. Make sure your new dataset is prepared in the same YOLO format as your initial training (a dataset YAML plus one .txt label file per image).

      2. Load your pre-trained model using the YOLO loading method, then specify your new dataset in the train method. Here's a quick code snippet for clarity:

        from ultralytics import YOLO
        
        # Load your pre-trained model
        model = YOLO('path/to/your/pretrained/model.pt') 
        
        # Start training on the new dataset
        results = model.train(data='path/to/your/new/dataset.yaml', epochs=50, imgsz=640)

      Just replace 'path/to/your/pretrained/model.pt' and 'path/to/your/new/dataset.yaml' with the actual paths to your model and new dataset config file, respectively. Adjust the epochs and imgsz (image size) to suit your needs. 🛠️

      That's it! Your model will now continue training on the new dataset. If you have any further questions or run into issues, feel free to ask. Happy training! 🚀

  6. songziang182GitHub

    谢谢你们开发了这么完善的 yolov8🙏, 我想问一下,这两种训练方式的区别 model = YOLO('yolov8n.pt') model = YOLO('yolov8n.yaml').load('yolov8n.pt') model.train(.........)

    1
    1. Paula DerrengerUltralytics

      Hello there! 😊

      The main difference between the two training methods you've mentioned:

      1. model = YOLO('yolov8n.pt'): This directly loads a pretrained YOLOv8n model. It's the simplest way to load a model that has already been trained, making it ready for further training, evaluation, or inference right away.

      2. model = YOLO('yolov8n.yaml').load('yolov8n.pt'): This approach builds a new model from the YAML configuration file and then transfers the weights from the pretrained .pt model. It's a two-step process, where the model is first constructed based on the architecture defined in the YAML file, and then the weights from a pretrained model are loaded. This method is useful when you want to customize the model architecture before loading the weights.

      Both methods ultimately get you to a similar starting point for continuing training or making predictions. The choice depends on whether you need to customize the model architecture as defined in the YAML file before applying the pretrained weights.

      Let me know if this helps or if you have more questions!

    2. songziang182GitHub

      Thank you for answering me. I find it very useful. I have another question, which is the configuration file yolov8n.yaml. I didn’t find where it is. Can I adjust the scale of the model, for example, n, s, m, l, etc., is this the case?

    3. Paula DerrengerUltralytics(изменено)

      Hey! 😊 Thank you for your kind words, and I'm glad the information was helpful to you!

      Regarding the yolov8n.yaml configuration file, it defines the architecture for YOLOv8 models. All scales share one model file (yolov8.yaml) that contains a scales section mapping each letter to [depth, width, max_channels]; the letter in the name you load (yolov8n.yaml, yolov8s.yaml, ...) selects the scale:

      scales:
        n: [0.33, 0.25, 1024]
        s: [0.33, 0.50, 1024]

      To create or modify a model, copy the YAML from the Ultralytics GitHub repository, edit the layers or scales, then load it together with the pretrained weights as you mentioned:

      model = YOLO('path/to/custom_yolov8.yaml').load('yolov8n.pt')
      model.train(.........)

      Model changes can require a solid understanding of the network architecture to be effective.

      I hope this clarifies your question! Feel free to reach out if you have further queries or need more examples. 😊

  7. vonzoGitHub

    So, imgsz works different when training than when predicting?

    For train: if it's an int the ratio will be kept and the train function will take care of that (can't be a tuple). For predict: if it's an int the image will be resized as a square of size imgsz x imgsz, if it's a tuple the image will be resized using HxW and the user has to take care of the ratio and stride.

    Is this right? I would add a comment in the doc to avoid confusions

    1
    1. Paula DerrengerUltralytics(изменено)

      You've got it mostly right! 👍 For training (train), imgsz is an int, the aspect ratio is maintained and resizing is handled internally. It can't be a tuple. For prediction (predict), an int imgsz resizes the longest side to imgsz while keeping the aspect ratio, with padding only up to a multiple of the model stride (so the image is not forced into a square), and a [h, w] list sets the size explicitly.

      Great suggestion on the documentation comment – clarity is key! If you have any more questions or need further examples, feel free to ask. 😊