Перейти к содержанию

YOLOv7: Trainable Bag-of-Freebies

YOLOv7 — это современный детектор объектов реального времени, который превосходит все известные детекторы объектов как по скорости, так и по точности в диапазоне от 5 FPS до 160 FPS. Он имеет самую высокую точность (56,8% AP) среди всех известных детекторов объектов реального времени с 30 FPS или выше на GPU V100. Более того, YOLOv7 превосходит другие детекторы объектов, такие как YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 и многие другие, по скорости и точности. Модель обучена на наборе данных MS COCO с нуля без использования каких-либо других наборов данных или предварительно обученных весов. Исходный код для YOLOv7 доступен на GitHub.

Сравнение YOLOv7 с современными детекторами объектов (SOTA)

Сравнение современных детекторов объектов (SOTA)

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

Если сравнить YOLOv7-X со скоростью инференса 114 кадров в секунду с YOLOv5-L (r6.1) со скоростью инференса 99 кадров в секунду, YOLOv7-X может улучшить AP на 3,9%. Если YOLOv7-X сравнивается с YOLOv5-X (r6.1) аналогичного масштаба, скорость инференса YOLOv7-X на 31 кадр в секунду выше. Кроме того, с точки зрения количества параметров и вычислений, YOLOv7-X уменьшает 22% параметров и 8% вычислений по сравнению с YOLOv5-X (r6.1), но улучшает AP на 2,2% (Source).

Производительность

Модель Параметры
(M)
FLOPs
(G)
Размер
(пиксели)
FPS APtest / val
50-95
APtest
50
APtest
75
APtest
S
APtest
M
APtest
L
YOLOX-S 9.0 26.8 640 102 40.5% / 40.5% - - - - -
YOLOX-M 25.3 73.8 640 81 47.2% / 46.9% - - - - -
YOLOX-L 54.2 155.6 640 69 50.1% / 49.7% - - - - -
YOLOX-X 99.1 281.9 640 58 51.5% / 51.1% - - - - -
PPYOLOE-S 7.9 17.4 640 208 43.1% / 42.7% 60.5% 46.6% 23.2% 46.4% 56.9%
PPYOLOE-M 23.4 49.9 640 123 48.9% / 48.6% 66.5% 53.0% 28.6% 52.9% 63.8%
PPYOLOE-L 52.2 110.1 640 78 51.4% / 50.9% 68.9% 55.6% 31.4% 55.3% 66.1%
PPYOLOE-X 98.4 206.6 640 45 52.2% / 51.9% 69.9% 56.5% 33.3% 56.3% 66.4%
YOLOv5-N (r6.1) 1.9 4.5 640 159 - / 28.0% - - - - -
YOLOv5-S (r6.1) 7.2 16.5 640 156 - / 37.4% - - - - -
YOLOv5-M (r6.1) 21.2 49.0 640 122 - \/ 45.4% - - - - -
YOLOv5-L (r6.1) 46.5 109.1 640 99 - \/ 49.0% - - - - -
YOLOv5-X (r6.1) 86.7 205.7 640 83 - \/ 50.7% - - - - -
YOLOR-CSP 52.9 120.4 640 106 51.1% \/ 50.8% 69.6% 55.7% 31.7% 55.3% 64.7%
YOLOR-CSP-X 96.9 226.8 640 87 53.0% \/ 52.7% 71.4% 57.9% 33.7% 57.1% 66.8%
YOLOv7-tiny-SiLU 6.2 13.8 640 286 38.7% \/ 38.7% 56.7% 41.7% 18.8% 42.4% 51.9%
YOLOv7 36.9 104.7 640 161 51.4% \/ 51.2% 69.7% 55.9% 31.8% 55.5% 65.0%
YOLOv7-X 71.3 189.9 640 114 53.1% \/ 52.9% 71.2% 57.8% 33.8% 57.1% 67.4%
YOLOv5-N6 (r6.1) 3.2 18.4 1280 123 - \/ 36.0% - - - - -
YOLOv5-S6 (r6.1) 12.6 67.2 1280 122 - \/ 44.8% - - - - -
YOLOv5-M6 (r6.1) 35.7 200.0 1280 90 - \/ 51.3% - - - - -
YOLOv5-L6 (r6.1) 76.8 445.6 1280 63 - \/ 53.7% - - - - -
YOLOv5-X6 (r6.1) 140.7 839.2 1280 38 - \/ 55.0% - - - - -
YOLOR-P6 37.2 325.6 1280 76 53.9% / 53.5% 71.4% 58.9% 36.1% 57.7% 65.6%
YOLOR-W6 79.8 453.2 1280 66 55.2% / 54.8% 72.7% 60.5% 37.7% 59.1% 67.1%
YOLOR-E6 115.8 683.2 1280 45 55.8% / 55.7% 73.4% 61.1% 38.4% 59.7% 67.7%
YOLOR-D6 151.7 935.6 1280 34 56.5% / 56.1% 74.1% 61.9% 38.9% 60.4% 68.7%
YOLOv7-W6 70.4 360.0 1280 84 54.9% / 54.6% 72.6% 60.1% 37.3% 58.7% 67.1%
YOLOv7-E6 97.2 515.2 1280 56 56.0% / 55.9% 73.5% 61.2% 38.0% 59.9% 68.4%
YOLOv7-D6 154.7 806.8 1280 44 56.6% / 56.3% 74.0% 61.8% 38.8% 60.1% 69.5%
YOLOv7-E6E 151.7 843.2 1280 36 56.8% / 56.8% 74.4% 62.1% 39.3% 60.5% 69.0%

Обзор

Обнаружение объектов в реальном времени является важным компонентом во многих системах компьютерного зрения, включая много-объектное отслеживание, автономное вождение, робототехнику и анализ медицинских изображений. В последние годы разработка систем обнаружения объектов в реальном времени была сосредоточена на проектировании эффективных архитектур и повышении скорости инференса различных CPU, GPU и нейронных процессоров (NPU). YOLOv7 поддерживает как мобильные GPU, так и GPU устройства, от периферии до облака.

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

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

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

  1. Репараметризация модели: YOLOv7 предлагает запланированную репараметризованную модель, которая представляет собой стратегию, применимую к слоям в различных сетях с концепцией пути распространения градиента.

  2. Динамическое назначение меток: Обучение модели с несколькими выходными слоями представляет новую проблему: «Как назначать динамические цели для выходов различных ветвей?» Чтобы решить эту проблему, YOLOv7 представляет новый метод назначения меток, называемый методом назначения меток с грубой и точной ведущей направляющей.

  3. Расширенное и составное масштабирование: YOLOv7 предлагает методы «расширения» и «составного масштабирования» для детектора объектов реального времени, которые могут эффективно использовать параметры и вычисления.

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

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

На момент написания Ultralytics поддерживает только вывод ONNX и TensorRT для YOLOv7.

Экспорт в ONNX

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

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

    pip install ultralytics
    yolo export model=yolo11n.pt format=onnx
    
  2. Экспортируйте желаемую модель YOLOv7, используя экспортер в репозитории YOLOv7:

    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.

  2. Установите TensorRT Пакет python:

    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. Мы ценим их усилия по продвижению этой области и предоставлению доступа к своей работе для широкого сообщества.

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

Что такое YOLOv7 и почему она считается прорывом в обнаружении объектов в реальном времени?

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

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

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

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

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

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

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

  1. Клонируйте репозиторий YOLOv7:
    git clone https://github.com/WongKinYiu/yolov7
    
  2. Перейдите в клонированный каталог и установите зависимости:
    cd yolov7
    pip install -r requirements.txt
    
  3. Подготовьте свой набор данных и настройте параметры модели в соответствии с инструкциями по использованию, представленными в репозитории. Для получения дополнительной информации посетите репозиторий YOLOv7 GitHub для получения последней информации и обновлений.

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

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

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

  • Репараметризация модели: Повышает производительность модели за счет оптимизации путей распространения градиента.
  • Динамическое назначение меток: Использует метод «от грубого к точному», управляемый лидами, для назначения динамических целей для выходов по различным ветвям, повышая точность.
  • Расширенное и составное масштабирование: Эффективно использует параметры и вычисления для масштабирования модели для различных приложений реального времени.
  • Эффективность: Сокращает количество параметров на 40% и вычисления на 50% по сравнению с другими современными моделями, обеспечивая при этом более высокую скорость inference.

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



📅 Создано 1 год назад ✏️ Обновлено 2 месяца назад

Комментарии