YOLOv7: Bolsa de regalos entrenable

YOLOv7 es un detector de objetos en tiempo real de última generación que supera a todos los detectores de objetos conocidos tanto en velocidad como en precisión en el rango de 5 FPS a 160 FPS. Tiene la mayor precisión (56,8% AP) entre todos los detectores de objetos en tiempo real conocidos con 30 FPS o más en GPU V100. Además, YOLOv7 supera en velocidad y precisión a otros detectores de objetos como YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5, y muchos otros. El modelo se entrena en el conjunto de datos MS COCO desde cero, sin utilizar otros conjuntos de datos ni pesos preentrenados. El código fuente de YOLOv7 está disponible en GitHub.

Comparación de los detectores de objetos SOTA

A partir de los resultados de la tabla comparativa de YOLO , sabemos que el método propuesto presenta la mejor relación velocidad-precisión de forma global. Si comparamos YOLOv7-tiny-SiLU con YOLOv5(r6.1), nuestro método es 127 fps más rápido y un 10,7% más preciso en AP. Además, YOLOv7 tiene un 51,4% de AP con una tasa de fotogramas de 161 fps, mientras que PPYOLOE-L con el mismo AP sólo tiene una tasa de fotogramas de 78 fps. En cuanto al uso de parámetros, YOLOv7 es un 41% menos que PPYOLOE-L.

Si comparamos YOLOv7-X, con una velocidad de inferencia de 114 fps, con YOLOv5(r6.1), con una velocidad de inferencia de 99 fps, YOLOv7-X puede mejorar AP en un 3,9%. Si se compara YOLOv7-X con YOLOv5(r6.1) de escala similar, la velocidad de inferencia de YOLOv7-X es 31 fps más rápida. Además, en términos de cantidad de parámetros y de cálculo, YOLOv7-X reduce el 22% de los parámetros y el 8% del cálculo en comparación con YOLOv5(r6.1), pero mejora AP en un 2,2%(Fuente).

Visión general

La detección de objetos en tiempo real es un componente importante en muchos sistemas de visión por ordenador, comoel seguimiento multiobjeto, la conducción autónoma, la robótica y el análisis de imágenes médicas. En los últimos años, el desarrollo de la detección de objetos en tiempo real se ha centrado en diseñar arquitecturas eficientes y mejorar la velocidad de inferencia de diversas CPU, GPU y unidades de procesamiento neuronal (NPU). YOLOv7 es compatible con dispositivos móviles y GPU , desde el borde hasta la nube.

A diferencia de los detectores de objetos en tiempo real tradicionales, que se centran en la optimización de la arquitectura, YOLOv7 introduce un enfoque en la optimización del proceso de entrenamiento. Esto incluye módulos y métodos de optimización diseñados para mejorar la precisión de la detección de objetos sin aumentar el coste de inferencia, un concepto conocido como "trainable bag-of-freebies".

Características principales

YOLOv7 introduce varias características clave:

1. Re-parametrización del modelo: YOLOv7 propone un modelo re-parametrizado planificado, que es una estrategia aplicable a capas en diferentes redes con el concepto de trayectoria de propagación de gradiente.

2. Asignación dinámica de etiquetas: El entrenamiento del modelo con múltiples capas de salida presenta un nuevo problema: "¿Cómo asignar objetivos dinámicos para las salidas de diferentes ramas?". Para resolver este problema, YOLOv7 introduce un nuevo método de asignación de etiquetas denominado asignación de etiquetas guiada por pistas de grueso a fino.

3. Escalado extendido y compuesto: YOLOv7 propone métodos de "escalado extendido" y "compuesto" para el detector de objetos en tiempo real que pueden utilizar eficazmente los parámetros y el cálculo.

4. Eficacia: El método propuesto por YOLOv7 puede reducir eficazmente alrededor del 40% de los parámetros y el 50% del cálculo del detector de objetos en tiempo real más avanzado, y tiene una velocidad de inferencia más rápida y una mayor precisión de detección.

Ejemplos de uso

En el momento de redactar este documento, Ultralytics sólo admite la inferencia ONNX y TensorRT para YOLOv7.

Exportación ONNX

Para utilizar el modelo YOLOv7 ONNX con Ultralytics:

1. (Opcional) Instale Ultralytics y exporte un modelo ONNX para que se instalen automáticamente las dependencias necesarias:

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

1. Exporte el modelo YOLOv7 deseado utilizando el exportador del repositorio de 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

1. Modifique el gráfico del modelo ONNX para que sea compatible con Ultralytics utilizando el siguiente script:

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")

1. A continuación, puede cargar el modelo ONNX modificado y ejecutar la inferencia con él en Ultralytics normalmente:

from ultralytics import ASSETS, YOLO

model = YOLO("yolov7-ultralytics.onnx", task="detect")

results = model(ASSETS / "bus.jpg")

Exportación de TensorRT

1. Siga los pasos 1-2 de la sección Exportación deONNX .

2. Instale el TensorRT Paquete Python :

pip install tensorrt

1. Ejecute el siguiente script para convertir el modelo ONNX modificado al motor TensorRT :

# Based off of https://github.com/NVIDIA/TensorRT/blob/release/10.7/samples/python/introductory_parser_samples/onnx_resnet50.py

import tensorrt as trt

TRT_LOGGER = trt.Logger(trt.Logger.WARNING)


def GiB(val):
    return val * 1 << 30


def build_engine_onnx(model_file):
    builder = trt.Builder(TRT_LOGGER)
    network = builder.create_network(0)
    config = builder.create_builder_config()
    parser = trt.OnnxParser(network, TRT_LOGGER)

    config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, GiB(4))
    with open(model_file, "rb") as model:
        if not parser.parse(model.read()):
            print("ERROR: Failed to parse the ONNX file.")
            for error in range(parser.num_errors):
                print(parser.get_error(error))
            return None
    config.set_flag(trt.BuilderFlag.FP16)
    engine_bytes = builder.build_serialized_network(network, config)
    with open(model_file.replace("onnx", "engine"), "wb") as f:
        f.write(engine_bytes)


build_engine_onnx("yolov7-ultralytics.onnx")  # path to the modified ONNX file

1. Cargue y ejecute el modelo en Ultralytics:

from ultralytics import ASSETS, YOLO

model = YOLO("yolov7-ultralytics.engine", task="detect")

results = model(ASSETS / "bus.jpg")

Citas y agradecimientos

Queremos agradecer a los autores de YOLOv7 sus importantes contribuciones en el campo de la detección de objetos en tiempo real:

@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}
}

El artículo original sobre YOLOv7 puede consultarse en arXiv. Los autores han puesto su trabajo a disposición del público y se puede acceder al código base en GitHub. Agradecemos sus esfuerzos por hacer avanzar este campo y poner su trabajo a disposición de la comunidad en general.

PREGUNTAS FRECUENTES

¿Qué es YOLOv7 y por qué se considera un gran avance en la detección de objetos en tiempo real?

YOLOv7 es un modelo puntero de detección de objetos en tiempo real que alcanza una velocidad y una precisión inigualables. Supera a otros modelos, como YOLOX, YOLOv5 y PPYOLOE, tanto en el uso de parámetros como en la velocidad de inferencia. Entre las características distintivas de YOLOv7 se encuentran la reparametrización del modelo y la asignación dinámica de etiquetas, que optimizan su rendimiento sin aumentar los costes de inferencia. Para obtener más detalles técnicos sobre su arquitectura y comparaciones métricas con otros detectores de objetos de última generación, consulte el artículo YOLOv7.

¿En qué mejora YOLOv7 a modelos anteriores de YOLO como YOLOv4 y YOLOv5?

YOLOv7 introduce varias innovaciones, como la reparametrización del modelo y la asignación dinámica de etiquetas, que mejoran el proceso de formación y la precisión de la inferencia. En comparación con YOLOv5, YOLOv7 aumenta significativamente la velocidad y la precisión. Por ejemplo, YOLOv7-X mejora la precisión en un 2,2% y reduce los parámetros en un 22% en comparación con YOLOv5-X. Encontrará comparaciones detalladas en la tabla de rendimiento Comparación de YOLOv7 con los detectores de objetos SOTA.

¿Puedo utilizar YOLOv7 con las herramientas y plataformas de Ultralytics ?

Por ahora, Ultralytics sólo soporta la inferencia ONNX y TensorRT de YOLOv7. Para ejecutar la versión exportada ONNX y TensorRT de YOLOv7 con Ultralytics, consulte la sección Ejemplos de uso.

¿Cómo entreno un modelo YOLOv7 personalizado utilizando mi conjunto de datos?

Para instalar y entrenar un modelo YOLOv7 personalizado, siga estos pasos:

1. Clonar el repositorio YOLOv7:

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

2. Navegue hasta el directorio clonado e instale las dependencias:

   cd yolov7
   pip install -r requirements.txt
   

3. Prepare su conjunto de datos y configure los parámetros del modelo de acuerdo con las instrucciones de uso proporcionadas en el repositorio. Para obtener más orientación, visite el repositorio GitHub de YOLOv7 para consultar la información y las actualizaciones más recientes.

4. Después del entrenamiento, puede exportar el modelo a ONNX o TensorRT para su uso en Ultralytics como se muestra en Ejemplos de uso.

¿Cuáles son las principales características y optimizaciones introducidas en YOLOv7?

YOLOv7 ofrece varias funciones clave que revolucionan la detección de objetos en tiempo real:

• Reparametrización del modelo: Mejora el rendimiento del modelo optimizando las rutas de propagación del gradiente.
• Asignación dinámica de etiquetas: Utiliza un método guiado por pistas de grueso a fino para asignar objetivos dinámicos para salidas a través de diferentes ramas, mejorando la precisión.
• Escalado ampliado y compuesto: Utiliza eficientemente los parámetros y el cálculo para escalar el modelo para diversas aplicaciones en tiempo real.
• Eficacia: Reduce el recuento de parámetros en un 40% y el cómputo en un 50% en comparación con otros modelos del estado de la técnica, al tiempo que logra velocidades de inferencia más rápidas.

Para más detalles sobre estas funciones, consulte la sección Visión general de YOLOv7.

Creado hace 1 año ✏️ Actualizado hace 3 días

Comentarios