YOLOv7: Trainable Bag-of-Freebies

YOLOv7, выпущенный в июле 2022 года, стал значительным прорывом в области детектирования объектов в реальном времени на момент своего появления. Он достиг 56.8% AP на GPU V100, установив новые стандарты производительности. YOLOv7 превзошел современные на тот момент детекторы объектов, такие как YOLOR, YOLOX, Scaled-YOLOv4 и YOLOv5, по скорости и точности. Модель обучена на наборе данных MS COCO с нуля без использования других наборов данных или предобученных весов. Исходный код YOLOv7 доступен на GitHub. Обрати внимание, что более новые модели, такие как YOLO11 и YOLO26, с тех пор достигли более высокой точности при улучшенной эффективности.

Сравнение SOTA детекторов объектов

Исходя из результатов в таблице сравнения YOLO, мы видим, что предложенный метод обладает наилучшим балансом скорости и точности в целом. Если сравнивать YOLOv7-tiny-SiLU с YOLOv5-N (r6.1), наш метод на 127 fps быстрее и на 10.7% точнее по AP. Кроме того, YOLOv7 показывает 51.4% AP при частоте кадров 161 fps, в то время как PPYOLOE-L с таким же AP имеет частоту кадров всего 78 fps. По объему используемых параметров YOLOv7 на 41% компактнее, чем PPYOLOE-L.

Если сравнить YOLOv7-X со скоростью инференса 114 fps с YOLOv5-L (r6.1) со скоростью 99 fps, YOLOv7-X может улучшить AP на 3.9%. Если сравнивать YOLOv7-X с YOLOv5-X (r6.1) аналогичного масштаба, скорость инференса YOLOv7-X на 31 fps выше. Кроме того, по количеству параметров и вычислений YOLOv7-X сокращает количество параметров на 22% и объем вычислений на 8% по сравнению с YOLOv5-X (r6.1), при этом улучшая AP на 2.2% (Источник).

Обзор

Детекция объектов в реальном времени — важный компонент многих систем computer vision, включая мульти-object tracking, автономное вождение, robotics и medical image analysis. В последние годы разработка детекторов объектов в реальном времени сосредоточена на создании эффективных архитектур и повышении скорости вывода на различных CPU, GPU и нейронных процессорах (NPU). YOLOv7 поддерживает работу как на мобильных GPU, так и на GPU-устройствах, от периферийных вычислений до облака.

В отличие от традиционных детекторов объектов реального времени, сфокусированных на оптимизации архитектуры, YOLOv7 делает упор на оптимизации процесса обучения. Сюда входят модули и методы оптимизации, разработанные для повышения точности детекции объектов без увеличения стоимости вычислений — концепция, известная как «trainable bag-of-freebies».

Основные характеристики

YOLOv7 представляет несколько ключевых особенностей:

1. Model Re-parameterization: YOLOv7 предлагает планируемую перепараметризацию модели — стратегию, применимую к слоям в различных сетях с учетом пути распространения градиента.

2. Dynamic Label Assignment: Обучение модели с несколькими выходными слоями создает новую проблему: «Как назначать динамические цели для выходов разных ветвей?». Чтобы решить эту задачу, YOLOv7 вводит новый метод назначения меток под названием coarse-to-fine lead guided label assignment.

3. Extended and Compound Scaling: YOLOv7 предлагает методы «extend» и «compound scaling» для детекторов объектов реального времени, позволяющие эффективно использовать параметры и вычисления.

4. Efficiency: Метод, предложенный в YOLOv7, позволяет эффективно сократить количество параметров примерно на 40%, а объем вычислений — на 50% по сравнению с современными детекторами объектов реального времени, при этом обеспечивая более высокую скорость вывода и повышенную точность детекции.

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

Ultralytics не публикует предобученные веса yolov7.pt или YAML-файлы ultralytics/cfg/models/v7/, а нативное обучение и вывод в PyTorch для YOLOv7 не поддерживаются пакетом Ultralytics Python. Однако ты можешь использовать чекпоинт YOLOv7, обученный в upstream YOLOv7 repository, импортировав его в Ultralytics через экспорт в ONNX или TensorRT, как показано ниже.

Экспорт в ONNX

Чтобы использовать модель YOLOv7 ONNX с Ultralytics:

1. (Опционально) Установи Ultralytics и экспортируй модель ONNX, чтобы необходимые зависимости установились автоматически:

   pip install ultralytics
   yolo export model=yolo26n.pt format=onnx

2. Экспортируй нужную модель YOLOv7, используя экспортер из YOLOv7 repo:

   git clone https://github.com/WongKinYiu/yolov7
   cd yolov7
   python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640

3. Измени граф модели ONNX для совместимости с Ultralytics, используя следующий скрипт:

   import numpy as np
   import onnx
   from onnx import helper, numpy_helper
   
   # Load the ONNX model
   model_path = "yolov7/yolov7-tiny.onnx"  # Replace with your model path
   model = onnx.load(model_path)
   graph = model.graph
   
   # Fix input shape to batch size 1
   input_shape = graph.input[0].type.tensor_type.shape
   input_shape.dim[0].dim_value = 1
   
   # Define the output of the original model
   original_output_name = graph.output[0].name
   
   # Create slicing nodes
   sliced_output_name = f"{original_output_name}_sliced"
   
   # Define initializers for slicing (remove the first value)
   start = numpy_helper.from_array(np.array([1], dtype=np.int64), name="slice_start")
   end = numpy_helper.from_array(np.array([7], dtype=np.int64), name="slice_end")
   axes = numpy_helper.from_array(np.array([1], dtype=np.int64), name="slice_axes")
   steps = numpy_helper.from_array(np.array([1], dtype=np.int64), name="slice_steps")
   
   graph.initializer.extend([start, end, axes, steps])
   
   slice_node = helper.make_node(
       "Slice",
       inputs=[original_output_name, "slice_start", "slice_end", "slice_axes", "slice_steps"],
       outputs=[sliced_output_name],
       name="SliceNode",
   )
   graph.node.append(slice_node)
   
   # Define segment slicing
   seg1_start = numpy_helper.from_array(np.array([0], dtype=np.int64), name="seg1_start")
   seg1_end = numpy_helper.from_array(np.array([4], dtype=np.int64), name="seg1_end")
   seg2_start = numpy_helper.from_array(np.array([4], dtype=np.int64), name="seg2_start")
   seg2_end = numpy_helper.from_array(np.array([5], dtype=np.int64), name="seg2_end")
   seg3_start = numpy_helper.from_array(np.array([5], dtype=np.int64), name="seg3_start")
   seg3_end = numpy_helper.from_array(np.array([6], dtype=np.int64), name="seg3_end")
   
   graph.initializer.extend([seg1_start, seg1_end, seg2_start, seg2_end, seg3_start, seg3_end])
   
   # Create intermediate tensors for segments
   segment_1_name = f"{sliced_output_name}_segment1"
   segment_2_name = f"{sliced_output_name}_segment2"
   segment_3_name = f"{sliced_output_name}_segment3"
   
   # Add segment slicing nodes
   graph.node.extend(
       [
           helper.make_node(
               "Slice",
               inputs=[sliced_output_name, "seg1_start", "seg1_end", "slice_axes", "slice_steps"],
               outputs=[segment_1_name],
               name="SliceSegment1",
           ),
           helper.make_node(
               "Slice",
               inputs=[sliced_output_name, "seg2_start", "seg2_end", "slice_axes", "slice_steps"],
               outputs=[segment_2_name],
               name="SliceSegment2",
           ),
           helper.make_node(
               "Slice",
               inputs=[sliced_output_name, "seg3_start", "seg3_end", "slice_axes", "slice_steps"],
               outputs=[segment_3_name],
               name="SliceSegment3",
           ),
       ]
   )
   
   # Concatenate the segments
   concat_output_name = f"{sliced_output_name}_concat"
   concat_node = helper.make_node(
       "Concat",
       inputs=[segment_1_name, segment_3_name, segment_2_name],
       outputs=[concat_output_name],
       axis=1,
       name="ConcatSwapped",
   )
   graph.node.append(concat_node)
   
   # Reshape to [1, -1, 6]
   reshape_shape = numpy_helper.from_array(np.array([1, -1, 6], dtype=np.int64), name="reshape_shape")
   graph.initializer.append(reshape_shape)
   
   final_output_name = f"{concat_output_name}_batched"
   reshape_node = helper.make_node(
       "Reshape",
       inputs=[concat_output_name, "reshape_shape"],
       outputs=[final_output_name],
       name="AddBatchDimension",
   )
   graph.node.append(reshape_node)
   
   # Get the shape of the reshaped tensor
   shape_node_name = f"{final_output_name}_shape"
   shape_node = helper.make_node(
       "Shape",
       inputs=[final_output_name],
       outputs=[shape_node_name],
       name="GetShapeDim",
   )
   graph.node.append(shape_node)
   
   # Extract the second dimension
   dim_1_index = numpy_helper.from_array(np.array([1], dtype=np.int64), name="dim_1_index")
   graph.initializer.append(dim_1_index)
   
   second_dim_name = f"{final_output_name}_dim1"
   gather_node = helper.make_node(
       "Gather",
       inputs=[shape_node_name, "dim_1_index"],
       outputs=[second_dim_name],
       name="GatherSecondDim",
   )
   graph.node.append(gather_node)
   
   # Subtract from 100 to determine how many values to pad
   target_size = numpy_helper.from_array(np.array([100], dtype=np.int64), name="target_size")
   graph.initializer.append(target_size)
   
   pad_size_name = f"{second_dim_name}_padsize"
   sub_node = helper.make_node(
       "Sub",
       inputs=["target_size", second_dim_name],
       outputs=[pad_size_name],
       name="CalculatePadSize",
   )
   graph.node.append(sub_node)
   
   # Build the [2, 3] pad array:
   # 1st row -> [0, 0, 0] (no padding at the start of any dim)
   # 2nd row -> [0, pad_size, 0] (pad only at the end of the second dim)
   pad_starts = numpy_helper.from_array(np.array([0, 0, 0], dtype=np.int64), name="pad_starts")
   graph.initializer.append(pad_starts)
   
   zero_scalar = numpy_helper.from_array(np.array([0], dtype=np.int64), name="zero_scalar")
   graph.initializer.append(zero_scalar)
   
   pad_ends_name = "pad_ends"
   concat_pad_ends_node = helper.make_node(
       "Concat",
       inputs=["zero_scalar", pad_size_name, "zero_scalar"],
       outputs=[pad_ends_name],
       axis=0,
       name="ConcatPadEnds",
   )
   graph.node.append(concat_pad_ends_node)
   
   pad_values_name = "pad_values"
   concat_pad_node = helper.make_node(
       "Concat",
       inputs=["pad_starts", pad_ends_name],
       outputs=[pad_values_name],
       axis=0,
       name="ConcatPadStartsEnds",
   )
   graph.node.append(concat_pad_node)
   
   # Create Pad operator to pad with zeros
   pad_output_name = f"{final_output_name}_padded"
   pad_constant_value = numpy_helper.from_array(
       np.array([0.0], dtype=np.float32),
       name="pad_constant_value",
   )
   graph.initializer.append(pad_constant_value)
   
   pad_node = helper.make_node(
       "Pad",
       inputs=[final_output_name, pad_values_name, "pad_constant_value"],
       outputs=[pad_output_name],
       mode="constant",
       name="PadToFixedSize",
   )
   graph.node.append(pad_node)
   
   # Update the graph's final output to [1, 100, 6]
   new_output_type = onnx.helper.make_tensor_type_proto(
       elem_type=graph.output[0].type.tensor_type.elem_type, shape=[1, 100, 6]
   )
   new_output = onnx.helper.make_value_info(name=pad_output_name, type_proto=new_output_type)
   
   # Replace the old output with the new one
   graph.output.pop()
   graph.output.extend([new_output])
   
   # Save the modified model
   onnx.save(model, "yolov7-ultralytics.onnx")

4. Затем ты сможешь загрузить измененную модель ONNX и выполнять с ней инференс в Ultralytics в обычном режиме:

   from ultralytics import ASSETS, YOLO
   
   model = YOLO("yolov7-ultralytics.onnx", task="detect")
   
   results = model(ASSETS / "bus.jpg")

Экспорт в TensorRT

1. Выполни шаги 1-2 в разделе ONNX Export.

2. Установи Python-пакет TensorRT:

   pip install tensorrt

3. Запусти следующий скрипт для конвертации измененной модели ONNX в движок TensorRT:

   from ultralytics.utils.export import export_engine
   
   export_engine("yolov7-ultralytics.onnx", half=True)

4. Загрузи и запусти модель в Ultralytics:

   from ultralytics import ASSETS, YOLO
   
   model = YOLO("yolov7-ultralytics.engine", task="detect")
   
   results = model(ASSETS / "bus.jpg")

Цитирование и благодарности

Мы хотели бы поблагодарить авторов YOLOv7 за их значительный вклад в область детекции объектов в реальном времени:

@article{wang2022yolov7,
  title={YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
  author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
  journal={arXiv preprint arXiv:2207.02696},
  year={2022}
}

Оригинальную статью по YOLOv7 можно найти на arXiv. Авторы сделали свою работу общедоступной, а кодовую базу можно найти на GitHub. Мы ценим их усилия по продвижению этой области и предоставлению своей работы широкому сообществу.

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

Что такое YOLOv7 и почему это считается прорывом в object detection в реальном времени?

YOLOv7, выпущенная в июле 2022 года, стала важной моделью детекции объектов в реальном времени, обеспечившей отличную скорость и точность на момент выхода. Она превзошла современные ей модели, такие как YOLOX, YOLOv5 и PPYOLOE, как по использованию параметров, так и по скорости инференса. Отличительные черты YOLOv7 включают перепараметризацию модели и динамическое назначение меток, которые оптимизируют производительность без увеличения затрат на инференс. Дополнительные технические детали архитектуры и метрики сравнения с другими современными детекторами объектов см. в YOLOv7 paper.

Чем YOLOv7 лучше предыдущих моделей YOLO, таких как YOLOv4 и YOLOv5?

YOLOv7 внедряет несколько инноваций, включая перепараметризацию модели и динамическое назначение меток, которые улучшают процесс обучения и повышают точность инференса. По сравнению с YOLOv5, YOLOv7 значительно повышает скорость и точность. Например, YOLOv7-X улучшает точность на 2.2% и снижает количество параметров на 22% по сравнению с YOLOv5-X. Подробные сравнения можно найти в таблице производительности YOLOv7 comparison with SOTA object detectors.

Могу ли я использовать YOLOv7 с инструментами и платформами Ultralytics?

На данный момент Ultralytics поддерживает только инференс YOLOv7 в форматах ONNX и TensorRT. Чтобы запустить экспортированную в ONNX и TensorRT версию YOLOv7 с помощью Ultralytics, ознакомься с разделом Usage Examples.

Как обучить собственную модель YOLOv7 на своем наборе данных?

Чтобы установить и обучить свою модель YOLOv7, выполни следующие действия:

1. Клонируй репозиторий YOLOv7:

   git clone https://github.com/WongKinYiu/yolov7

2. Перейди в клонированную директорию и установи зависимости:

   cd yolov7
   pip install -r requirements.txt

3. Подготовь свой набор данных и настрой параметры модели в соответствии с usage instructions, приведенными в репозитории. Для получения дополнительных рекомендаций посещай репозиторий YOLOv7 на GitHub для получения актуальной информации и обновлений.

4. После обучения ты можешь экспортировать модель в ONNX или TensorRT для использования в Ultralytics, как показано в Usage Examples.

Какие ключевые функции и оптимизации были внедрены в YOLOv7?

YOLOv7 предлагает несколько ключевых функций, совершивших революцию в детекции объектов в реальном времени:

• Model Re-parameterization: Улучшает производительность модели путем оптимизации путей распространения градиента.
• Dynamic Label Assignment: Использует метод coarse-to-fine lead guided для динамического назначения целей для выходов по различным ветвям, что повышает точность.
• Extended and Compound Scaling: Эффективно использует параметры и вычисления для масштабирования модели под различные задачи реального времени.
• Efficiency: Снижает количество параметров на 40% и объем вычислений на 50% по сравнению с другими современными моделями, обеспечивая при этом более высокую скорость инференса.

Для получения подробной информации об этих функциях см. раздел YOLOv7 Overview.