Отслеживание нескольких объектов с Ultralytics YOLO
Отслеживание нескольких объектов в видеоаналитике определяет местоположение и класс объектов в каждом кадре, а также сохраняет уникальный идентификатор каждого обнаруженного объекта по мере воспроизведения видео. Сферы применения — от видеонаблюдения и безопасности до спортивной аналитики в реальном времени.
Смотри анонс ещё не выпущенной версии YOLO27, чтобы узнать о планах по поддержке отслеживания.
Начиная с ultralytics 8.4.63, доступны OC-SORT, Deep OC-SORT, FastTracker и TrackTrack, а также BoT-SORT и ByteTrack.
Почему для отслеживания объектов стоит выбрать Ultralytics YOLO?#
Результаты работы трекеров Ultralytics соответствуют стандартному обнаружению объектов, но дополнительно содержат идентификаторы объектов. Благодаря этому удобно отслеживать объекты в видеопотоках и выполнять последующую аналитику. Основные причины использовать Ultralytics YOLO для отслеживания объектов:
- Эффективность: обрабатывай видеопотоки в реальном времени без ущерба для точности.
- Гибкость: Поддержка нескольких алгоритмов отслеживания и конфигураций.
- Простота использования: простой API Python и параметры CLI для быстрой интеграции и развертывания.
- Возможность настройки: легко используй собственные обученные модели YOLO и интегрируй их в приложения для конкретных областей.
Смотри: Как настроить трекинг нескольких объектов с Ultralytics YOLO26 | BoT-SORT и ByteTrack | VisionAI 🚀
Применение в реальных условиях#
| Транспорт | Розничная торговля | Аквакультура |
|---|---|---|
| Отслеживание транспортных средств | Отслеживание людей | Отслеживание рыб |
Быстрый старт#
Запусти отслеживание видео с трекером TrackTrack по умолчанию. Чтобы выбрать другой трекер, измени аргумент tracker.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Трекер по умолчанию (TrackTrack)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)
# Переключение на ByteTrack
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")Для запуска трекера на видеопотоках используй обученную модель Detect, Segment, Pose или OBB, например YOLO26n, YOLO26n-seg, YOLO26n-pose или YOLO26n-obb. Все они доступны в коллекции YOLO26 на Ultralytics Platform. Ты можешь обучить пользовательские модели локально или с помощью облачного обучения на Ultralytics Platform.
from ultralytics import YOLO
# Загрузка официальной или собственной модели
model = YOLO("yolo26n.pt") # Загрузка официальной модели Detect
model = YOLO("yolo26n-seg.pt") # Загрузка официальной модели Segment
model = YOLO("yolo26n-pose.pt") # Загрузка официальной модели Pose
model = YOLO("path/to/best.pt") # Загрузка собственной обученной модели
# Отслеживание с помощью модели
results = model.track("https://youtu.be/LNwODJXcvt4", show=True) # Отслеживание с трекером по умолчанию
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # с ByteTrackПоддерживаемые трекеры#
В Ultralytics YOLO встроено шесть трекеров. Чтобы включить один из них, передай его файл конфигурации YAML аргументу tracker.
| Трекер | Файл конфигурации | Модель движения | Внешний вид / ReID | Компенсация движения камеры | Обработка перекрытий |
|---|---|---|---|---|---|
| BoT-SORT | botsort.yaml | Линейная модель Калмана | Необязательно (with_reid) | Настраиваемый параметр (gmc_method) | Буфер треков + повторная привязка ReID |
| ByteTrack | bytetrack.yaml | Линейная модель Калмана | Нет | Нет | Двухэтапное восстановление при низкой уверенности |
| OC-SORT | ocsort.yaml | Модель Калмана с учётом наблюдений | Нет | Нет | Повторный расчёт ORU, OCM, OCR на основе последнего наблюдения |
| Deep OC-SORT | deepocsort.yaml | Модель Калмана с учётом наблюдений | Необязательно (with_reid) | Настраиваемый параметр (gmc_method) | OC-SORT + адаптивная EMA признаков внешнего вида (необязательно) |
| FastTracker | fasttrack.yaml | Линейная модель Калмана + откат | Нет | Нет | Откат модели Калмана + увеличение bbox при перекрытии |
| TrackTrack | tracktrack.yaml | Линейная модель Калмана (NSA) | Необязательно (with_reid) | Настраиваемый параметр (gmc_method) | Итеративное сопоставление по нескольким признакам + TAI |
Какой трекер выбрать?#
Используй эту схему, чтобы выбрать вариант для начала; tracktrack.yaml используется, если не передан tracker:
- Нужен максимально быстрый и простой базовый вариант? → ByteTrack (без ReID и компенсации движения камеры, с минимальными накладными расходами).
- Видео снято с рук, с дрона или движущейся камеры? → BoT-SORT (добавляет компенсацию движения камеры и необязательный ReID).
- Нелинейное движение (спорт, танцы, резкие повороты) и ReID не нужен? → OC-SORT (коррекция с учётом наблюдений без затрат на анализ внешнего вида).
- Переполненные сцены с движущейся камерой, где главная проблема — подмена ID? → Deep OC-SORT или TrackTrack (оба поддерживают необязательное сопоставление по внешнему виду; TrackTrack также использует сопоставление по нескольким признакам и подавляет дублирующиеся ID).
- Частые частичные перекрытия в реальном времени, а ресурсов на ReID нет? → FastTracker (вариант ByteTrack с учётом перекрытий и откатом модели Калмана).
Смена трекера#
Передай имя файла конфигурации трекера аргументу tracker=. Остальной код не меняется.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model.track(source="path/to/video.mp4", tracker="bytetrack.yaml")
results = model.track(source="path/to/video.mp4", tracker="ocsort.yaml")
results = model.track(source="path/to/video.mp4", tracker="tracktrack.yaml")Конфигурация#
Аргументы отслеживания#
Конфигурация отслеживания использует те же аргументы инференса, что и режим Predict, например conf, iou и show.
from ultralytics import YOLO
# Настрой параметры отслеживания и запусти трекер
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.5, show=True)Настройка собственного трекера#
Чтобы использовать изменённую конфигурацию трекера, скопируй файл конфигурации трекера (например, как custom_tracker.yaml) из ultralytics/cfg/trackers и измени любые настройки, кроме tracker_type.
from ultralytics import YOLO
# Загрузи модель и запусти трекер с собственным файлом конфигурации
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")Общие аргументы трекеров#
Следующие параметры используются в большинстве файлов YAML трекеров; некоторые параметры могут отсутствовать в отдельных конфигурациях:
Детекции со значением не ниже track_high_thresh попадают на первый этап сопоставления. Детекции со значениями между track_low_thresh и track_high_thresh могут восстановить существующие треки, если выбранный трекер поддерживает сопоставление детекций с низкой уверенностью, но не создают новые треки. Детекции со значением не выше track_low_thresh игнорируются.
| Параметр | Допустимые значения или диапазоны | Описание |
|---|---|---|
tracker_type | botsort, bytetrack, ocsort, deepocsort, fasttrack, tracktrack | Указывает тип трекера. |
track_high_thresh | 0.0-1.0 | Порог для первого сопоставления. Определяет, насколько уверенно детекция сопоставляется с существующим треком. |
track_low_thresh | 0.0-1.0 | Нижняя граница для детекций с низкой уверенностью, используемых при восстановлении треков. OC-SORT и Deep OC-SORT используют их только при use_byte: True; TrackTrack включает их в пул сопоставления со штрафом. |
new_track_thresh | 0.0-1.0 | Порог для инициализации нового трека, если детекция не соответствует ни одному существующему треку. |
track_buffer | >=0 | Количество кадров, в течение которых потерянные треки остаются активными до удаления. Чем выше значение, тем лучше алгоритм переносит перекрытия. |
match_thresh | 0.0-1.0 | Порог сопоставления треков. Чем выше значение, тем менее строгим становится сопоставление. |
fuse_score | True, False | Нужно ли объединять оценки уверенности с расстояниями IoU перед сопоставлением. |
gmc_method | sparseOptFlow, orb, sift, ecc, none | Метод компенсации глобального движения. Помогает учитывать движение камеры. |
proximity_thresh | 0.0-1.0 | Минимальный IoU, необходимый для корректного сопоставления ReID. Обеспечивает близость объектов в пространстве перед использованием признаков внешнего вида. |
appearance_thresh | 0.0-1.0 | Минимальное нормализованное сходство внешнего вида, необходимое для ReID. |
with_reid | True, False | Включить сопоставление по внешнему виду для повышения качества трекинга при перекрытиях. Поддерживается BoT-SORT, Deep OC-SORT и TrackTrack. |
model | Путь к auto или совместимой модели ReID | Модель ReID. auto использует признаки встроенной магистральной сети YOLO, если они доступны; в противном случае используется yolo26n-cls.pt. Пользовательский энкодер может быть чекпойнтом .pt или экспортированной моделью, например .torchscript, .onnx, .engine либо каталогом модели OpenVINO. |
Аргументы, специфичные для трекеров#
Каждый алгоритм предоставляет дополнительные параметры в дополнение к общим. Описания и советы по настройке см. в разделах ниже, посвящённых отдельным трекерам, или непосредственно в файлах конфигурации:
Включение повторной идентификации (ReID)#
ReID по умолчанию отключён для снижения накладных расходов. Включи его, задав with_reid: True в файле конфигурации трекера.
Варианты модели ReID:
model: auto— Использует встроенные признаки детектора YOLO, практически не увеличивая накладные расходы. Подходит, если тебе нужна ReID без существенного снижения производительности. Если детектор не предоставляет совместимые признаки, используетсяyolo26n-cls.pt.- Пользовательская модель ReID — Укажи для
model:чекпойнт.ptили совместимую экспортированную модель эмбеддингов, например.torchscript,.onnx,.engineлибо каталог модели OpenVINO. Экспортированные модели загружаются черезAutoBackendи должны напрямую выдавать тензор эмбеддингов.
Готовые энкодеры ONNX доступны для моделей всех размеров. Задай для model: одно из этих имён — файл загрузится автоматически при первом запуске трекера (так же, как загружаются веса YOLO). Экспортировать или скачивать файл вручную не нужно:
# In your tracker config (e.g. tracktrack.yaml)
with_reid: True
model: yolo26n-reid.onnx # downloaded on first use; swap n→s/m/l/x for a larger encoder| Модель | размер (пиксели) | параметры (млн) | FLOPs (млрд) |
|---|---|---|---|
| YOLO26n-reid.onnx | 448 | 2.8 | 2.0 |
| YOLO26s-reid.onnx | 448 | 7.5 | 6.6 |
| YOLO26m-reid.onnx | 448 | 12.4 | 20.1 |
| YOLO26l-reid.onnx | 448 | 15.3 | 25.2 |
| YOLO26x-reid.onnx | 448 | 32.7 | 55.9 |
Сейчас доступны только энкодеры ONNX ReID для ветви трекера, отвечающей за внешний вид. Режимы ReID train, val и predict, а также специальные сценарии экспорта ReID всё ещё находятся в разработке.
Чтобы повысить производительность при использовании отдельной модели классификации, экспортируй её в более быстрый формат, например TensorRT:
from torch import nn
from ultralytics import YOLO
# Загрузи модель классификации
model = YOLO("yolo26n-cls.pt")
# Добавь слой усредняющего пулинга
head = model.model.model[-1]
pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(start_dim=1))
pool.f, pool.i = head.f, head.i
model.model.model[-1] = pool
# Экспортируй в TensorRT
model.export(format="engine", quantize=16, dynamic=True, batch=32)После экспорта укажи путь к модели TensorRT в конфигурации трекера.
Подробно о трекерах#
В разделах ниже описаны архитектура каждого трекера, специфичные для него параметры и рекомендации по настройке.
Смотри: Какой трекер объектов лучше? | Скорость, FPS и стабильность ID | Ultralytics YOLO26 📊
BoT-SORT#
BoT-SORT (Aharon и др., 2022) расширяет ByteTrack компенсацией движения камеры и опциональной ReID:
- Компенсация движения камеры (CMC): перед сопоставлением по IoU к состояниям фильтра Калмана применяется аффинное преобразование, вычисляемое для каждого кадра (по умолчанию — разреженный оптический поток; также доступны ORB и ECC).
- Опциональная ReID: эмбеддинги внешнего вида можно объединить с матрицей стоимости. По умолчанию функция отключена; включи её с помощью
with_reid: True.
Лучше всего подходит для: трекинга общего назначения, особенно при движении камеры. Добавляй ReID, только если похожая внешность объектов приводит к смене ID.
Аргументы BoT-SORT:
| Параметр | Допустимые значения или диапазоны | Описание |
|---|---|---|
gmc_method | sparseOptFlow, orb, sift, ecc, none | Бэкенд компенсации движения камеры. По умолчанию используется sparseOptFlow. Значение none отключает CMC. |
with_reid | True, False | Включить сопоставление по внешнему виду. По умолчанию отключено. |
model | Путь к auto или совместимой модели ReID | auto использует встроенные признаки YOLO, если они доступны; в качестве пользовательских моделей можно указать чекпойнты .pt или совместимые экспортированные модели. |
proximity_thresh | 0.0-1.0 | Минимальный IoU, при котором учитываются признаки внешнего вида. |
appearance_thresh | 0.0-1.0 | Минимальное нормализованное сходство внешнего вида, необходимое для сопоставления ReID. Увеличь значение, чтобы сделать сопоставление строже. |
Советы по настройке:
- Статичная камера: задай
gmc_method: none, чтобы сэкономить несколько мс на кадр. - Сильное движение камеры: оставь
sparseOptFlow; вариантeccточнее, но медленнее. - Похожие объекты в толпе: включи
with_reid: Trueи увеличьappearance_thresh(например, до0.85+).
ByteTrack#
ByteTrack (Zhang и др., ECCV 2022) — лёгкий базовый алгоритм. Он сочетает линейный фильтр Калмана с IoU и использует двухэтапное сопоставление:
- Этап 1: сопоставление детекций с высокими оценками с активными треками.
- Этап 2: повторная попытка сопоставить несопоставленные треки с детекциями с низкими оценками, чтобы восстановить их после кратковременного частичного перекрытия.
Модель внешнего вида и компенсация движения камеры отсутствуют.
Лучше всего подходит для: статичных или почти статичных камер, когда основная вычислительная нагрузка приходится на детектор и важно свести накладные расходы трекера к минимуму.
Аргументы ByteTrack: отсутствуют, кроме общих аргументов трекера.
Советы по настройке:
- Шумный детектор: понизь
track_low_thresh, чтобы на втором этапе было больше кандидатов. - Детектор с высоким полнотой: повысь
track_high_thresh, чтобы уменьшить фрагментацию ID. - Частое мерцание ID: повысь
track_buffer, чтобы треки сохранялись после кратковременного пропуска детекций.
OC-SORT#
OC-SORT (Cao и др., CVPR 2023) — ориентированное на наблюдения расширение SORT. Оно сохраняет лёгкую архитектуру SORT (без признаков внешнего вида) и добавляет три коррекции:
- Повторное обновление с учётом наблюдений (ORU): восстанавливает виртуальную траекторию между последним наблюдением и текущей детекцией и повторно выполняет обновление фильтра Калмана, чтобы скорректировать отклонившуюся оценку скорости.
- Импульс с учётом наблюдений (OCM): штрафует детекции, движущиеся в неправильном направлении, с помощью члена стоимости, учитывающего согласованность скорости.
- Восстановление с учётом наблюдений (OCR): повторно проверяет несопоставленные детекции по недавно потерянным трекам, используя последнее наблюдение, а не предсказанное состояние.
Лучше всего подходит для: нелинейного движения, когда не хочется платить за модель ReID.
Аргументы OC-SORT:
| Параметр | Допустимые значения или диапазоны | Описание |
|---|---|---|
delta_t | >=1 | Временное окно (в кадрах) для вычисления направления скорости в OCM. Чем больше значение, тем сильнее сглаживание. |
inertia | 0.0-1.0 | Вес стоимости согласованности скорости. Чем выше значение, тем сильнее штраф за резкие изменения направления. |
use_byte | True, False | Включить второй этап сопоставления детекций с низкой уверенностью, как в ByteTrack. |
Советы по настройке:
- Нелинейное движение: увеличь
inertia(например, до0.3-0.4). - Редкие детекции: включи
use_byte: True. - Длительные перекрытия: увеличь
track_buffer, чтобы OCR мог восстановить больше потерянных треков.
Для моделей OBB в OCR используется предсказанный фильтром Калмана ориентированный bbox, поскольку история последних наблюдений с ориентацией не сохраняется.
Deep OC-SORT#
Deep OC-SORT дополняет OC-SORT информацией о внешнем виде и компенсацией движения камеры:
- Сопоставление по внешнему виду: расстояние между эмбеддингами по косинусному сходству ограничивается с учётом перекрытия и объединяется со стоимостью движения.
- Динамическая EMA для внешнего вида: эмбеддинги треков обновляются с помощью EMA, коэффициент сглаживания которой зависит от уверенности детекции.
- Компенсация движения камеры: состояния фильтра Калмана преобразуются от кадра к кадру с помощью разреженного оптического потока, ORB или ECC.
Лучше всего подходит для: сцен с толпой или движущейся камерой, где часто меняются ID визуально разных, но расположенных близко объектов.
Аргументы Deep OC-SORT:
| Параметр | Допустимые значения или диапазоны | Описание |
|---|---|---|
with_reid | True, False | Включить сопоставление по внешнему виду. По умолчанию отключено. |
model | Путь к auto или совместимой модели ReID | auto использует встроенные признаки YOLO, если они доступны; в качестве пользовательских моделей можно указать чекпойнты .pt или совместимые экспортированные модели. |
proximity_thresh | 0.0-1.0 | Минимальный IoU, при котором учитываются признаки внешнего вида. |
appearance_thresh | 0.0-1.0 | Минимальное нормализованное сходство внешнего вида, необходимое для сопоставления ReID. |
alpha_fixed_emb | 0.0-1.0 | Базовый коэффициент EMA для обновления эмбеддингов треков. Чем выше значение, тем дольше сохраняется старый эмбеддинг. |
gmc_method | sparseOptFlow, orb, sift, ecc, none | Метод компенсации глобального движения. |
delta_t | >=1 | Временное окно (в кадрах) для вычисления направления скорости в OCM (унаследовано от OC-SORT). |
inertia | 0.0-1.0 | Вес стоимости согласованности скорости (унаследован от OC-SORT). |
use_byte | True, False | Включить второй этап сопоставления детекций с низкой уверенностью, как в ByteTrack (унаследовано от OC-SORT). |
Советы по настройке:
- Смена ID в толпе: увеличь
appearance_thresh(например, до0.92-0.95) и увеличьalpha_fixed_emb, чтобы эмбеддинги адаптировались медленнее. - Движущаяся камера: задай
gmc_method: sparseOptFlow(Deep OC-SORT по умолчанию используетnone). - Меньшая задержка: оставь
with_reid: False(значение по умолчанию), чтобы использовать только движение и CMC; включай ReID, только если ошибки в основном связаны со сменой ID.
FastTracker#
FastTracker — вариант ByteTrack, учитывающий перекрытия и не использующий модель внешнего вида:
- Обнаружение перекрытия: помечает треки как перекрытые, если покрытие другими активными треками превышает
occ_cover_thresh. - Откат фильтра Калмана при перекрытии: возвращает состояние фильтра Калмана к кадру до перекрытия, используя историю в кольцевом буфере.
- Снижение скорости движения и расширение области поиска: скорость уменьшается, а предсказанный bbox увеличивается во время перекрытия.
- Подавление Init-IoU: предотвращает появление новых треков поверх активных.
Лучше всего подходит для: конвейеров детекции в реальном времени с частыми взаимными перекрытиями объектов (толпы, очереди, спортивные соревнования).
Аргументы FastTracker:
| Параметр | Допустимые значения или диапазоны | Описание |
|---|---|---|
reset_velocity_offset_occ | >=0 | Количество предыдущих кадров, используемых для восстановления скорости Калмана при начале окклюзии. |
reset_pos_offset_occ | >=0 | Количество предыдущих кадров, используемых для восстановления положения Калмана при начале окклюзии. |
enlarge_bbox_occ | >=1.0 | Масштабирование высоты прогнозируемого bbox во время окклюзии (ширина масштабируется в соответствии с соотношением сторон XYAH). |
dampen_motion_occ | 0.0-1.0 | Множитель скорости во время окклюзии. При меньших значениях трек «замедляется» во время окклюзии. |
active_occ_to_lost_thresh | >=1 | Максимальное количество последовательных кадров с окклюзией, после которого активный трек переводится в потерянные. |
occ_cover_thresh | 0.0-1.0 | Доля площади трека, перекрытая другим активным треком, необходимая для фиксации окклюзии. |
occ_reappear_window | >=0 | Количество кадров, в течение которых недавно окклюдированный потерянный трек остаётся приоритетным для повторного обнаружения. |
init_iou_suppress | 0.0-1.0 | Не создавать новый трек, если его IoU с любым активным треком превышает это значение. Укажи 1.0, чтобы отключить параметр. |
Советы по настройке:
- Частые частичные окклюзии: уменьши
occ_cover_thresh(например, до0.5-0.6). - Дублирующиеся ID при перекрытии: уменьши
init_iou_suppress(например, до0.5). - Длительные окклюзии: увеличь одновременно
occ_reappear_windowиtrack_buffer. - Быстро движущиеся объекты: увеличь
dampen_motion_occ(приблизив к1.0); увеличивайenlarge_bbox_occ, только если более широкая область поиска улучшает восстановление трека.
TrackTrack#
TrackTrack (Shim et al., CVPR 2025) — трекер по умолчанию. Он рассматривает каждый трек с его собственной точки зрения и выполняет итеративную ассоциацию по нескольким признакам:
- Ассоциация с учётом перспективы трека (TPA): объединяет HMIoU, необязательное косинусное расстояние ReID, расстояние проекции уверенности и расстояние по углу угла. Назначение решается итеративно с постепенным ослаблением порога.
- Инициализация с учётом треков (TAI): предотвращает появление дубликатов до создания нового ID.
Лучше всего подходит для: перегруженных сцен с частыми окклюзиями, где возникают дублирующиеся ID.
Аргументы TrackTrack:
| Параметр | Допустимые значения или диапазоны | Описание |
|---|---|---|
iou_weight | 0.0-1.0 | Вес расстояния HMIoU при включённом ReID; в противном случае HMIoU используется напрямую. |
reid_weight | 0.0-1.0 | Вес косинусного расстояния ReID при включённом ReID; в противном случае параметр игнорируется. |
conf_weight | 0.0-1.0 | Вес расстояния проекции уверенности. |
angle_weight | 0.0-1.0 | Вес расстояния по углу угла. |
penalty_p | 0.0-1.0 | Штраф к стоимости для детекций с низкой уверенностью. |
penalty_q | 0.0-1.0 | Штраф к стоимости для детекций, восстановленных с помощью вторичного NMS. |
reduce_step | 0.0-1.0 | Ослабление порога сопоставления на каждой итерации. |
tai_thr | 0.0-1.0 | Порог IoU для NMS при инициализации с учётом треков. |
min_track_len | >=0 | Минимальная длина истории, необходимая для подтверждения нового трека. |
lost_match_thr | 0.0-1.0 | Более мягкий порог стоимости для ослабленного прохода повторной привязки потерянных треков; 0 отключает его. |
with_reid | True, False | Включить сопоставление по внешнему виду на основе косинусного ReID (используются встроенные признаки YOLO). По умолчанию отключено. |
model | Путь к auto или совместимой модели ReID | auto использует встроенные признаки YOLO, если они доступны; в качестве пользовательских моделей можно указать чекпойнты .pt или совместимые экспортированные модели. |
gmc_method | sparseOptFlow, orb, sift, ecc, none | Метод компенсации глобального движения. |
Советы по настройке:
- Перегруженные сцены с пешеходами: уменьши
tai_thr(например, до0.45), чтобы подавлять больше дубликатов; увеличьtrack_bufferдля работы с более длительными окклюзиями. - Быстрое движение камеры: оставь
gmc_method: sparseOptFlowвключённым. - Мелкие/быстрые объекты: немного увеличь
angle_weightи уменьшиmin_track_len. - Включай ReID только при необходимости: он увеличивает вычислительные затраты на инференс; для кратковременных окклюзий обычно достаточно стандартной оценки стоимости по нескольким признакам.
Для моделей сегментации и позы TrackTrack пропускает восстановление детекций с ослабленным NMS, чтобы маски и ключевые точки оставались согласованными с детекциями.
Примеры на Python#
Смотри: Как создать интерактивное отслеживание объектов с Ultralytics YOLO26: сделай это за считаные минуты | Python!
Цикл с сохранением треков#
Вот скрипт на Python, который использует OpenCV (cv2) и YOLO26 для отслеживания объектов в кадрах видео. Скрипт предполагает, что необходимые пакеты (opencv-python и ultralytics) уже установлены. Аргумент persist=True сообщает трекеру, что текущее изображение или кадр — следующий в последовательности, и что в текущем изображении следует ожидать треки с предыдущего изображения.
Используй persist=True только при передаче последовательных кадров из одного видеопотока в model.track(). Это позволяет трекеру повторно использовать состояние предыдущих кадров и сохранять согласованность ID треков с течением времени. Не используй persist=True для несвязанных изображений или другого потока, поскольку состояние предыдущих треков может сохраниться.
Также можно выбрать бэкенд трекера, передав файл конфигурации трекера, например tracker="botsort.yaml", tracker="bytetrack.yaml" или tracker="tracktrack.yaml".
import cv2
from ultralytics import YOLO
# Загружаем модель YOLO26
model = YOLO("yolo26n.pt")
# Открыть видеофайл
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
# Перебрать кадры видео
while cap.isOpened():
# Считать кадр из видео
success, frame = cap.read()
if success:
# Запускаем отслеживание YOLO26 на кадре, сохраняя треки между кадрами
# и используя бэкенд трекера BoT-SORT
results = model.track(frame, persist=True, tracker="botsort.yaml")
# Визуализировать результаты на кадре
annotated_frame = results[0].plot()
# Показать кадр с аннотациями
cv2.imshow("YOLO26 Tracking", annotated_frame)
# Прервать цикл, если нажата клавиша 'q'
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Прервать цикл, если видео закончилось
break
# Освободить объект видеозахвата и закрыть окно отображения
cap.release()
cv2.destroyAllWindows()Обрати внимание на замену model(frame) на model.track(frame): это включает отслеживание объектов вместо простого обнаружения. Этот изменённый скрипт запускает трекер для каждого кадра видео, визуализирует результаты и отображает их в окне. Чтобы выйти из цикла, нажми «q».
Построение траекторий треков во времени#
Визуализация траекторий объектов в последовательных кадрах помогает лучше понять закономерности движения и поведение обнаруженных в видео объектов. Ultralytics YOLO26 позволяет легко строить такие графики.
В примере ниже отслеживание с помощью YOLO26 используется для построения траекторий обнаруженных объектов на нескольких кадрах видео. Скрипт открывает видеофайл, считывает его кадр за кадром и использует модель YOLO для обнаружения и отслеживания объектов. Сохраняя центральные точки обнаруженных ограничивающих рамок и соединяя их, скрипт рисует линии, показывающие траектории отслеживаемых объектов.
from collections import defaultdict
import cv2
import numpy as np
from ultralytics import YOLO
# Загружаем модель YOLO26
model = YOLO("yolo26n.pt")
# Открыть видеофайл
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
# Сохраняем историю треков
track_history = defaultdict(list)
# Перебрать кадры видео
while cap.isOpened():
# Считать кадр из видео
success, frame = cap.read()
if success:
# Запускаем отслеживание YOLO26 на кадре, сохраняя треки между кадрами
result = model.track(frame, persist=True)[0]
# Получаем рамки и ID треков
if result.boxes and result.boxes.is_track:
boxes = result.boxes.xywh.cpu()
track_ids = result.boxes.id.int().cpu().tolist()
# Визуализируем результат на кадре
frame = result.plot()
# Строим траектории треков
for box, track_id in zip(boxes, track_ids):
x, y, w, h = box
track = track_history[track_id]
track.append((float(x), float(y))) # Центральная точка x, y
if len(track) > 30: # Храним 30 треков на протяжении 30 кадров
track.pop(0)
# Рисуем линии треков
points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
# Показать кадр с аннотациями
cv2.imshow("YOLO26 Tracking", frame)
# Прервать цикл, если нажата клавиша 'q'
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Прервать цикл, если видео закончилось
break
# Освободить объект видеозахвата и закрыть окно отображения
cap.release()
cv2.destroyAllWindows()Многопоточное отслеживание#
Многопоточное отслеживание позволяет одновременно отслеживать объекты в нескольких видеопотоках. Это особенно полезно при работе с несколькими источниками видео, например с несколькими камерами видеонаблюдения: параллельная обработка повышает пропускную способность.
Приведённый ниже скрипт Python использует модуль threading из Python для одновременного запуска нескольких экземпляров трекера. Каждый поток запускает трекер для одного источника видео, а все потоки работают в фоновом режиме одновременно.
Чтобы каждый поток получал правильные параметры (модель для использования и источник видео), скрипт определяет функцию run_tracker_in_thread, которая принимает эти параметры и содержит основной цикл трекинга. Эта функция считывает видео покадрово, запускает трекер и сохраняет результаты с аннотациями.
В этом примере используются две разные модели — yolo26n.pt и yolo26n-seg.pt. Каждая отслеживает объекты в отдельном источнике: локальном видеофайле и веб-камере. Источники указаны в SOURCES.
Параметр daemon=True в threading.Thread означает, что эти потоки завершатся сразу после окончания основной программы. Затем мы запускаем потоки с помощью start() и используем join(), чтобы главный поток дождался завершения обоих потоков трекера.
Наконец, после завершения работы всех потоков окна с результатами закрываются с помощью cv2.destroyAllWindows().
import threading
import cv2
from ultralytics import YOLO
# Задаём имена моделей и источники видео
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"] # Локальное видео, 0 — веб-камера
def run_tracker_in_thread(model_name, filename):
"""Run YOLO tracker in its own thread for concurrent processing.
Args:
model_name (str): Model checkpoint name or path loaded inside the thread.
filename (str): The path to the video file or the identifier for the webcam/external camera source.
"""
model = YOLO(model_name)
results = model.track(filename, save=True, stream=True)
for r in results:
pass
# Создаём и запускаем потоки трекеров с помощью цикла for
tracker_threads = []
for video_file, model_name in zip(SOURCES, MODEL_NAMES):
thread = threading.Thread(target=run_tracker_in_thread, args=(model_name, video_file), daemon=True)
tracker_threads.append(thread)
thread.start()
# Ждём завершения всех потоков трекеров
for thread in tracker_threads:
thread.join()
# Выполняем очистку и закрываем окна
cv2.destroyAllWindows()Этот пример легко расширить для обработки большего количества видеофайлов и моделей: достаточно создать дополнительные потоки и применить тот же подход.
Добавление новых трекеров#
Если ты реализовал или адаптировал алгоритм трекинга нескольких объектов для Ultralytics YOLO, подумай о том, чтобы внести его в ultralytics/trackers, добавив подходящую конфигурацию в ultralytics/cfg/trackers. Вклад участников расширяет набор доступных вариантов трекинга для всего сообщества.
Часто задаваемые вопросы#
Многоквартирное отслеживание объектов в видеоаналитике включает обнаружение объектов и присвоение каждому обнаруженному объекту уникального ID, который сохраняется на протяжении кадров видео. Ultralytics YOLO поддерживает эту возможность, обеспечивая отслеживание в реальном времени вместе с ID объектов, что позволяет решать задачи видеонаблюдения и спортивной аналитики. Система использует такие трекеры, как BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker и TrackTrack, которые можно настроить с помощью YAML-файлов.
Нет. Стандартные файлы Ultralytics
.ptхранят веса модели YOLO, а трекер создаётся во время инференса с помощьюmodel.track(). ID треков зависят от состояния трекера на последовательности кадров, поэтому для отдельного изображения можно получить детекции, например рамки, классы и значения уверенности, но само по себе оно не может обеспечить осмысленные постоянные ID отслеживания.Для развёртывания включи детектор и трекер в приложение и вызывай
model.track()для каждого кадра, используяpersist=True, если кадры поступают из одного видеопотока. Для несвязанных потоков используй отдельные экземпляры модели или трекера, чтобы состояние не переносилось между видео.Чтобы настроить пользовательский трекер, скопируй существующий файл конфигурации трекера (например,
custom_tracker.yaml) из каталога конфигураций трекеров Ultralytics и измени нужные параметры, кромеtracker_type. Используй этот файл в модели отслеживания, например так:Примерfrom ultralytics import YOLO model = YOLO("yolo26n.pt") results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")Чтобы одновременно отслеживать объекты в нескольких видеопотоках, можно использовать модуль
threadingиз Python. Каждый поток будет обрабатывать отдельный видеопоток. Вот пример настройки:Многопоточное отслеживаниеimport threading import cv2 from ultralytics import YOLO # Задаём имена моделей и источники видео MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"] SOURCES = ["path/to/video.mp4", "0"] # Локальное видео, 0 — веб-камера def run_tracker_in_thread(model_name, filename): """Run YOLO tracker in its own thread for concurrent processing. Args: model_name (str): Model checkpoint name or path loaded inside the thread. filename (str): The path to the video file or the identifier for the webcam/external camera source. """ model = YOLO(model_name) results = model.track(filename, save=True, stream=True) for r in results: pass # Создаём и запускаем потоки трекеров с помощью цикла for tracker_threads = [] for video_file, model_name in zip(SOURCES, MODEL_NAMES): thread = threading.Thread(target=run_tracker_in_thread, args=(model_name, video_file), daemon=True) tracker_threads.append(thread) thread.start() # Ждём завершения всех потоков трекеров for thread in tracker_threads: thread.join() # Выполняем очистку и закрываем окна cv2.destroyAllWindows()Многоквартирное отслеживание объектов с Ultralytics YOLO имеет множество применений, в том числе:
- Транспорт: отслеживание транспортных средств для управления дорожным движением и автономного вождения.
- Розничная торговля: отслеживание посетителей для аналитики и обеспечения безопасности в магазинах.
- Аквакультура: отслеживание рыб для мониторинга водной среды.
- Спортивная аналитика: отслеживание игроков и оборудования для анализа результатов.
- Системы безопасности: мониторинг подозрительной активности и создание сигналов тревоги.
Эти приложения используют способность Ultralytics YOLO обрабатывать видео с высокой частотой кадров в реальном времени и с высокой точностью.
Чтобы визуализировать треки объектов на нескольких кадрах видео, можно использовать функции отслеживания модели YOLO и OpenCV для отрисовки траекторий обнаруженных объектов. Вот пример скрипта:
Построение траекторий треков на нескольких кадрах видеоfrom collections import defaultdict import cv2 import numpy as np from ultralytics import YOLO model = YOLO("yolo26n.pt") video_path = "path/to/video.mp4" cap = cv2.VideoCapture(video_path) track_history = defaultdict(list) while cap.isOpened(): success, frame = cap.read() if success: result = model.track(frame, persist=True)[0] annotated_frame = result.plot() if result.boxes and result.boxes.is_track: boxes = result.boxes.xywh.cpu() track_ids = result.boxes.id.int().cpu().tolist() for box, track_id in zip(boxes, track_ids): x, y, w, h = box track = track_history[track_id] track.append((float(x), float(y))) if len(track) > 30: track.pop(0) points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2)) cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10) cv2.imshow("YOLO26 Tracking", annotated_frame) if cv2.waitKey(1) & 0xFF == ord("q"): break else: break cap.release() cv2.destroyAllWindows()Этот скрипт построит линии треков, показывающие траектории движения отслеживаемых объектов с течением времени, и поможет получить ценную информацию об их поведении и закономерностях.
Комментарии679
Задай вопрос, поделись результатами или помоги кому-нибудь.
bhaskar2443053
I’m using YOLO-Pose to detect and track people throughout ~1-hour videos and need each person to keep the same ID. I already have high-quality ground-truth tracks from a SAM-based tracker.
Do you have a script that can fine-tune YOLO-Pose (and its tracker/Re-ID parameters) against this ground truth to squeeze out the best IDF1 or HOTA scores ?
1maxexplorer
Hi!
Thank you for your great work on YOLO and tracking integration. We are using YOLO with ByteTrack/BoT-SORT for object counting and tracking and want to improve ID stability.
-
We notice that sometimes, even when the object visually looks the same and the scene and motion are stable, the track_id changes. What parameters or reasons should we check to understand why the ID changes unexpectedly?
-
Is the match_thresh parameter based on IoU, and is it possible to print or visualize the IoU used during matching for debugging?
-
Is there a way to output Kalman-predicted boxes of lost tracks so we can analyze them?
-
Could increasing the video FPS improve tracking and IoU consistency, or is this mainly related to detection stability and parameter tuning?
-
Does ByteTrack or BoT-SORT use a min_hits parameter before confirming tracks, or are tracks confirmed immediately after creation?
-
If a track is lost, can a new ID only be assigned on the second frame after reappearance if conf > new_track_thresh and then conf > track_high_thresh, or can it happen immediately on the first detection?
-
Is the track_buffer parameter the number of frames a track is kept using Kalman prediction after it is lost before being deleted?
-
Do you have any tips to improve tracking stability and avoid unnecessary ID switches?
Thank you for your support!
-
Glenn JocherUltralytics@bhaskar2443053 currently there isn't a built-in script for fine-tuning YOLO-Pose tracking parameters against ground truth. You would need to implement custom evaluation using libraries like TrackEval or MOTChallenge to compute IDF1/HOTA scores and optimize tracker parameters iteratively.
@maxexplorer great questions about tracking stability! Here are the key points:
-
ID changes typically occur due to low IoU between predicted and detected boxes, occlusions, or threshold mismatches. Check
track_high_threshandmatch_threshin your tracker config. -
match_threshis indeed IoU-based. For debugging, you can add logging to the tracker code, but there's no built-in visualization. -
Kalman predictions aren't directly exposed, but you can access them by modifying the tracker implementation.
-
Higher FPS generally improves tracking by reducing inter-frame motion, making associations more reliable.
-
Both trackers use confirmation logic - tracks need to meet certain criteria before being confirmed as valid tracks.
-
New tracks can be assigned immediately if detection confidence exceeds
new_track_thresh. -
Correct -
track_buffermaintains lost tracks for that many frames using prediction. -
For stability: increase
track_buffer, adjustmatch_threshbased on your scenario, and ensure consistent detection quality with appropriateconfthresholds.
For detailed parameter tuning, refer to the tracker configuration files and our tracking documentation.
-
rohith-aiunika(изменено)
Hi YOLO Team, I've been using the following Python script to track objects with my YOLOv8 model: from ultralytics import YOLO
model = YOLO(r"/home/best_pt_files/v1.0.2.pt") results = model.track(r"/home/video.MP4", save=False, stream=False)
However, I noticed that my GPU memory usage gradually increases, leading to an "out of memory" error before the video finishes processing. Interestingly, when I use the following command from the terminal, the entire video tracks successfully without excessive GPU memory consumption: yolo track model=/home/best_pt_files/1.0.2.pt source=/home/video.MP4
Previously, the Python script worked without any issues. The memory issue has only recently started occurring. Could you please help me understand the possible reasons for this memory increase and how to address it?
i have experimented with persist= True and False,stream = true and false, show = true and false also but the issue is still there
1
Glenn JocherUltralytics@rohith-aiunika thanks for reporting this. The memory buildup in Python scripts (but not CLI) typically occurs when not using streaming mode. To match the CLI's memory behavior, modify your Python script to process frames iteratively using
stream=True:from ultralytics import YOLO model = YOLO("/home/best_pt_files/v1.0.2.pt") for result in model.track("/home/video.MP4", stream=True): # Process frames iteratively pass # Add your frame processing logic hereThis streams frames sequentially like the CLI, preventing memory accumulation. For more details, see the streaming implementation in our Tracking documentation. Let us know if this resolves the issue!
rohith-aiunika
i have used stream = True, then the code is just executing without showing error and without tracking also
Glenn JocherUltralytics@rohith-aiunika thanks for the update. Let's ensure you're properly iterating through streaming results. Try adding a processing loop like this:
for result in model.track(source=video_path, stream=True): annotated_frame = result[0].plot() cv2.imshow('Tracking', annotated_frame) if cv2.waitKey(1) == ord('q'): breakThis actively processes each frame and displays tracking annotations. If issues persist, you might need to verify your video source format using our supported inference sources documentation.
mwasela
Hello, Made a custom model that i can successfully run and with a well tweaked confidence filter, am getting good results.
Now Ive wrapped the classification and tracking functionality into a flask app, that returns the count ID's when accessed by a REST call like get, meaning it can be accessed by a separate app for processing and stuff. I want to be able to reset the counting through some other request. My camera feed is always live, i need a way to reset the track id's to zero when neccessary, they just keep counting until i exit the program.
1
Glenn JocherUltralytics@mwasela hello,
It's great to hear that your custom model is performing well. To reset the tracking IDs in your Flask app, you can implement a mechanism to reinitialize the tracker state upon receiving a specific request. This can be done by resetting the tracker object or reloading the model within your tracking function.
For more detailed guidance on configuring and using trackers, please refer to our documentation: Multi-Object Tracking with Ultralytics YOLO.
Orziqulov-Javohir
I really need help to do this programm: I wanna select region via mouse "dangerous zone" Track detected person, If person enters this zone crop and save person's photo Can you show me pls how to do it for 10 cameras, my gpu is RTX 3080TI
1Orziqulov-Javohir
It is kind a security program detecting who entered zone
1Orziqulov-Javohir
import cv2 from ultralytics import YOLO import time
Load the YOLOv8 model
model = YOLO("yolov8n.pt") # pretrained YOLOv8n model
Initialize video capture for multiple cameras
camera_ids = [
'rtsp://admin:admin12345@172.17.67.20:554',
'rtsp://admin:admin12345@172.17.67.16:554', 'rtsp://admin:admin12345@172.17.67.18:554', 'rtsp://admin:admin12345@172.17.67.19:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554',
]caps = [cv2.VideoCapture(camera_id) for camera_id in camera_ids]
Open the video file
roi_start = [(0, 0)] * len(caps) roi_end = [(0, 0)] * len(caps) drawing = [False] * len(caps)
tracked_persons = [[] for _ in range(len(caps))] # List to track persons in dangerous zones
def draw_rectangle(event, x, y, flags, param): global roi_start, roi_end, drawing idx = param # Use param to identify the camera index if event == cv2.EVENT_LBUTTONDOWN: drawing[idx] = True roi_start[idx] = (x, y) roi_end[idx] = (x, y) print(f"Camera {idx}: Started drawing rectangle at: {roi_start[idx]}") elif event == cv2.EVENT_MOUSEMOVE: if drawing[idx]: roi_end[idx] = (x, y) print(f"Camera {idx}: Updated rectangle end to: {roi_end[idx]}") elif event == cv2.EVENT_LBUTTONUP: drawing[idx] = False roi_end[idx] = (x, y) print(f"Camera {idx}: Finished drawing rectangle at: {roi_end[idx]}")
Create a window and set mouse callback for each camera
for idx in range(len(caps)): window_name = f'Video {idx}' cv2.namedWindow(window_name) cv2.setMouseCallback(window_name, draw_rectangle, idx)
def is_inside_roi(x, y, roi_start, roi_end): x1, y1 = roi_start x2, y2 = roi_end return min(x1, x2) <= x <= max(x1, x2) and min(y1, y2) <= y <= max(y1, y2)
while True: frames = [] for cap in caps: ret, frame = cap.read() if not ret: continue # frame = cv2.resize(frame, (640, 480)) frames.append(frame)
for idx, frame in enumerate(frames): window_name = f'Video {idx}' # Draw the ROI rectangle on the frame if drawing[idx] or roi_start[idx] != roi_end[idx]: cv2.rectangle(frame, roi_start[idx], roi_end[idx], (0, 255, 0), 2) cv2.putText(frame, "Dangerous Zone", (roi_start[idx][0], roi_start[idx][1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2) # Run YOLOv8 tracking on the frame, persisting tracks between frames results = model.track(frame, tracker="bytetrack.yaml", persist=True) for result in results: boxes = result.boxes for box in boxes: x1, y1, x2, y2 = box.xyxy.tolist()[0][:4] cls = box.cls.tolist()[0] if cls == 0: # Person class in COCO dataset # Check if the center of the person is inside the ROI cx, cy = int((x1 + x2) / 2), int((y1 + y2) / 2) if is_inside_roi(cx, cy, roi_start[idx], roi_end[idx]): # Check if this person is already tracked person_id = box.id.tolist()[0] if box.id is not None else None if person_id not in tracked_persons[idx]: tracked_persons[idx].append(person_id) # Crop and save the frame crop = frame[int(y1):int(y2), int(x1):int(x2)] cv2.imwrite(f"cropped_camera{idx}_person{person_id}_{int(time.time())}.jpg", crop) # Draw a label on the person cv2.putText(frame, "Person in Dangerous Zone", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2) cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2) cv2.imshow(window_name, frame) if cv2.waitKey(1) & 0xFF == ord('q'): breakRelease all video captures
for cap in caps: cap.release() cv2.destroyAllWindows()
Glenn JocherUltralyticsYour approach looks solid for setting up a security program to track and save images of individuals entering a designated "dangerous zone" across multiple cameras. To enhance your implementation, ensure you're using the latest versions of the Ultralytics package for optimal performance and bug fixes. For more detailed guidance on tracking configurations and additional features, you can refer to the Ultralytics tracking documentation. If you encounter any specific issues or need further assistance, feel free to ask!
mariem158
File "", line 91 results = model.track(frame, persist=True, tracker="botsort.yaml") ^ IndentationError: unexpected indent COMMENT CORRIGER CETTE ERREUR
Glenn JocherUltralyticsThe error you're encountering is due to an unexpected indent in your code. Ensure that the indentation is consistent throughout your script. If the issue persists, please verify it with the latest version of the Ultralytics package. For more details on tracking configurations, you can refer to the Ultralytics tracking documentation.
GKYoffice
How can I get the tracking metrics of a tracker such as MOTA, IDF1, etc.
1GKYoffice
Can I set the parameter ''save_txt'' to True in the track function, and then write code to evaluate the tracking data?
Paula DerrengerUltralyticsCurrently, the Ultralytics YOLO framework doesn't provide built-in functionality for computing tracking metrics like MOTA or IDF1 directly through the API or command line. However, you can utilize external libraries such as MOTChallenge eval for calculating these metrics.
After running your tracking with YOLOv8, you'd typically export your tracking results in a format compatible with these libraries (usually a
.txtformat with frame ID, object ID, bounding boxes, etc.). Then, use the external library to compute the desired metrics by providing it with both the ground truth and your results file.Here's a generic example on how you might save tracking results (modify based on your actual use case):
from ultralytics import YOLO # Initialize and load your model model = YOLO("path/to/your/model.pt") # Tracking results = model.track(source='path/to/video.mp4', save_txt=True, project='runs/track', name='exp') # results are saved in 'runs/track/exp' in a format that can be used with MOTChallenge eval toolsAfterwards, follow the documentation of the MOTChallenge eval toolkit to compute the metrics using the outputs stored in
'runs/track/exp'.If you encounter any specific issues while implementing this, feel free to ask!🛠️
AdadAlShabab
Can I run two models simultaneously in one video? Ex: model = YOLO('E:/Ultralytics/best.pt') model = YOLO('yolov8m-pose.pt') results = model.track(source="file.mp4", show=True, conf=0.3, save=False) results = model.track(source="file.mp4", show=True, conf=0.3, save=False)
I want that two models will works simultaneously with cumulative results? Is it possible? Please let me know. Thanks in advance!!
1
Paula DerrengerUltralytics@AdadAlShabab yes, you can run two models simultaneously on one video, but you'll need to manage the inference in a way that allows both models to process the video frames concurrently. Here's a simplified example using threading to achieve this:
import threading from ultralytics import YOLO # Load the models model1 = YOLO('E:/Ultralytics/best.pt') model2 = YOLO('yolov8m-pose.pt') # Function to run tracking def track_video(model, source, conf, show, save): results = model.track(source=source, show=show, conf=conf, save=save) # Process results here or return them # Create threads for each model thread1 = threading.Thread(target=track_video, args=(model1, "file.mp4", 0.3, True, False)) thread2 = threading.Thread(target=track_video, args=(model2, "file.mp4", 0.3, True, False)) # Start the threads thread1.start() thread2.start() # Wait for both threads to finish thread1.join() thread2.join()This script will run both models in separate threads. If you want to combine the results from both models, you'll need to implement a mechanism to synchronize and merge the results from both threads. Keep in mind that displaying the results (
show=True) from two threads might not work as expected, and you might need to handle the visualization separately.Remember to handle the GPU memory usage carefully, as running two models simultaneously will require more memory. If you encounter any issues, consider running the models sequentially or on separate GPUs if available.
4
Journey2-20
Hello I'm newer to Opencv and I'm trying to run a tracking camera for airsoft. How would i select specific bounding boxes?
Paula DerrengerUltralyticsUse
model.track(frame, persist=True)and inspectresults[0].boxes.xyxywithresults[0].boxes.id; select the box containing your OpenCV mouse-click coordinates, store its track ID, then process or draw only boxes whoseboxes.idmatches that ID. Feel free to continue posting questions here so the Ultralytics team can help.
yashpatel2010
In my jetson orin nano super developer kit with jetpack6.1 and deepstream7.1 i want to do cross camera person tracking. Is there any default way in deepstream configs to do it? Or any other lightweight thing that can be easily doable in jetson orin nano 8 gb super dev kit.
Glenn JocherUltralyticsUltralytics
trackis single-camera MOT, so cross-camera person IDs are not built in; on DeepStream 7.1 the practical Orin Nano path isNvDeepSORT/ReID per stream plus downstream association from the exported embeddings described in the DeepStreamgst-nvtrackerdocs, or NVIDIA’s separate Multi-Camera Tracking workflow for full MTMC. Please keep the details here in Discussions and share your current tracker config if you want a minimal setup suggestion. (docs.nvidia.com)
anvi97(изменено)
Hi @glenn-jocher,
I am building a road surface detection system using YOLO segmentation.
My pipeline:
Apply bird eye view using cv2.getPerspectiveTransform()
Mask only road area
Detect potholes, zebra crossings, and speed bumps
I am facing the following issues:
1️⃣ Overlapping Potholes Not Merging Properly
I want overlapping potholes to merge into one bounding box.
In many cases it works, but sometimes:
Two boxes are still shown for the same pothole
Even when they overlap visually
I am using YOLO with:
results = model(frame, conf=0.45, iou=0.4)
Is YOLO’s internal NMS preventing full merging? Should I apply custom merging after inference? Is segmentation-based merging better than bounding box merging for potholes?
2️⃣ Object Size Changing After Bird Eye View
I calculate pothole size using:
pixels_per_foot = 220
But I selected this value randomly (no real-world measurement).
Because of this:
Object size changes depending on frame position
Same pothole appears different size
Is it correct that without real-world calibration, size cannot be accurate? What is the correct method to calculate real-world size in a monocular dashcam setup?
3️⃣ Zebra Crossing vs Black–White Speed Bump Confusion
Black–white speed bumps are getting confused with zebra crossings because both have parallel white-black stripes.
Currently I am detecting only yellow speed bumps to avoid confusion.
What is the better approach to separate them?
Use segmentation instead of boxes?
Add geometry-based filtering?
Train with more hard-negative examples?
anvi97
this is my code ..... from ultralytics import YOLO import cv2 import numpy as np
model = YOLO("runs/segment/pothole_seg_model3/weights/best.pt") pixels_per_foot = 220
video_path = "sample_video.mp4" cap = cv2.VideoCapture(video_path)
if not cap.isOpened(): print(" Cannot open video") exit()
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
fourcc = cv2.VideoWriter_fourcc(*'avc1') out = cv2.VideoWriter("pothole5.mp4", fourcc, fps, (width, height))
STRETCH_AMOUNT = 50
src = np.float32([ [0, height],
[width, height],
[922, 183],
[265, 183]
])dst = np.float32([ [0, height], [width, height], [width + STRETCH_AMOUNT, 0], [0 - STRETCH_AMOUNT, 0] ])
matrix = cv2.getPerspectiveTransform(src, dst) def compute_iou(box1, box2): x1 = max(box1[0], box2[0]) y1 = max(box1[1], box2[1]) x2 = min(box1[2], box2[2]) y2 = min(box1[3], box2[3])
inter_area = max(0, x2 - x1) * max(0, y2 - y1) box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1]) box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1]) union = box1_area + box2_area - inter_area if union == 0: return 0 return inter_area / uniondef should_merge(box1, box2, iou_thresh=0.1, dist_thresh=150): # Containment check - if one box is inside the other if (box1[0] >= box2[0] and box1[1] >= box2[1] and box1[2] <= box2[2] and box1[3] <= box2[3]): return True if (box2[0] >= box1[0] and box2[1] >= box1[1] and box2[2] <= box1[2] and box2[3] <= box1[3]): return True
iou = compute_iou(box1, box2) if iou > iou_thresh: return True cx1, cy1 = (box1[0]+box1[2])/2, (box1[1]+box1[3])/2 cx2, cy2 = (box2[0]+box2[2])/2, (box2[1]+box2[3])/2 if np.sqrt((cx1-cx2)**2 + (cy1-cy2)**2) < dist_thresh: return True return Falsewhile True: ret, frame = cap.read() if not ret: break
bird_eye = cv2.warpPerspective(frame, matrix, (width, height)) results = model(bird_eye, conf=0.45, iou=0.4)[0] annotated = results.plot() if results.boxes is not None: for box in results.boxes: cls_id = int(box.cls.item()) if cls_id == 0: # pothole only x1, y1, x2, y2 = map(int, box.xyxy.cpu().numpy()[0]) w_px = x2 - x1 h_px = y2 - y1 w_ft = w_px / pixels_per_foot h_ft = h_px / pixels_per_foot label = f"{w_ft:.2f}ft x {h_ft:.2f}ft" cv2.putText( annotated, label, (x1, y1 - 15), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2 ) cv2.imshow("Bird Eye + Pothole Detection", annotated) out.write(annotated) if cv2.waitKey(1) & 0xFF == 27: breakcap.release() out.release() cv2.destroyAllWindows()
Glenn JocherUltralyticsFor (1), YOLO’s NMS will only suppress duplicate detections based on
iou=...—it won’t “merge” two overlapping detections into a larger union box, and in your snippetcompute_iou()/should_merge()aren’t actually applied toresults.boxes, so you’re still visualizing the raw post-NMS output; since you’re using a Segment model, the most robust way to merge “split” potholes is to union the pothole masks and re-extract connected components (then box/measure those) rather than trying to union boxes.import cv2 import numpy as np r = model(bird_eye, conf=0.45, iou=0.4)[0] if r.masks is not None and r.boxes is not None: cls = r.boxes.cls.int().cpu().numpy() pothole_idx = np.where(cls == 0)[0] if pothole_idx.size: m = r.masks.data[pothole_idx].cpu().numpy() # (N,H,W), 0/1 union = (m.sum(0) > 0).astype(np.uint8) * 255 n, labels = cv2.connectedComponents(union) for k in range(1, n): ys, xs = np.where(labels == k) x1, y1, x2, y2 = xs.min(), ys.min(), xs.max(), ys.max() cv2.rectangle(bird_eye, (x1, y1), (x2, y2), (0, 255, 255), 2)For (2), yes—without real-world calibration (and a valid “road plane” assumption),
pixels_per_foot=220can’t be physically meaningful, and even with a BEV warp you only get consistent scale if your homography is tied to metric coordinates; the usual monocular approach is: calibrate camera intrinsics, estimate the road plane, build a homography to a top-down plane in real units (or derive scale from at least one known road-plane measurement like lane width/stripe spacing), then measure in the BEV plane.For (3), the best fix is usually data: train both classes explicitly with lots of “hard negatives” (zebra crossings that look like bumps and vice versa) and keep labels consistent; segmentation often helps because you can then add simple shape/location constraints on the mask (zebra = large repeated pattern region, bump = single narrow band across lane) and optionally smooth decisions over time (if you’re doing video, using
model.track(..., persist=True)from the Track mode docs can help stabilize per-frame flicker, even though it won’t merge instances within a frame).If you can paste
!yolo checksoutput and one representative frame (plus what you consider the “correct” merged result), I can suggest concrete thresholds/post-processing for your exact outputs.anvi97
In the attached frame:
The large water-filled pothole on the left should be treated as a single instance.
The small region in the top-left corner (currently detected as separate) should be merged with the large region.
Essentially, all visually continuous damaged area should result in one bounding box / one connected component.
Currently:
Mask union + connected components splits them due to small segmentation gaps
Goal:
Treat visually continuous pothole surface as one instance for measurement stability.
Glenn JocherUltralyticsThat split is expected because
connectedComponents()treats any 1–2 px “mask hole” as a hard break, so add a small gap-closing step on the union mask (morphological close / dilate→erode) before components, with the kernel sized to the largest gap you still consider “visually continuous” (see Ultralytics YOLO segmentation docs for more mask/seg usage details):# union: uint8 {0,255} union = (m.sum(0) > 0).astype(np.uint8) * 255 # bridge small gaps (tune kernel size to your expected mask discontinuities) k_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (25, 25)) union_closed = cv2.morphologyEx(union, cv2.MORPH_CLOSE, k_close, iterations=1) # optional: remove tiny speckles after closing k_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7)) union_closed = cv2.morphologyEx(union_closed, cv2.MORPH_OPEN, k_open, iterations=1) n, labels = cv2.connectedComponents(union_closed)
mslabdelhak29
Reid doesn't work how can i fix it i tried to change it True in botsort.yaml but it doesn't work
mslabdelhak29
@glenn_jocher
Glenn JocherUltralytics(изменено)@mslabdelhak29 ReID is only supported by some trackers (for example BoT-SORT), not ByteTrack, and it’s enabled via the tracker YAML you pass at runtime. Copy the default config, enable ReID explicitly, and point
track()to your copy:# custom_botsort.yaml tracker_type: botsort with_reid: True model: yolo26n-cls.pt # or another YOLO classification weight you have locallyfrom ultralytics import YOLO model = YOLO("yolo26n.pt") # any YOLO detector results = model.track(source="path/to/video.mp4", tracker="custom_botsort.yaml", persist=True, show=False)If it still doesn’t work, you’re likely editing a different YAML than the one being loaded; always pass the path as above. Also share the output of
yolo checksand the exactcustom_botsort.yamlyou used so we can verify your environment and keys. See the ReID section in the tracking guide and the BoT-SORT config for details: Multi‑Object Tracking docs and botsort.yaml config.
