Link to this sectionYOLOv7: Trainable Bag-of-Freebies#

YOLOv7, lanzado en julio de 2022, supuso un avance significativo en la detección de objetos en tiempo real en el momento de su lanzamiento. Alcanzó un 56,8% de AP en una GPU V100, estableciendo nuevos puntos de referencia cuando se presentó. YOLOv7 superó a los detectores de objetos contemporáneos como YOLOR, YOLOX, Scaled-YOLOv4 y YOLOv5 en velocidad y precisión. El modelo se entrena desde cero con el conjunto de datos MS COCO sin utilizar ningún otro conjunto de datos ni pesos preentrenados. El código fuente de YOLOv7 está disponible en GitHub. Ten en cuenta que modelos más nuevos como YOLO11 y YOLO26 han logrado desde entonces una mayor precisión con una eficiencia mejorada.

Link to this sectionComparación de detectores de objetos SOTA#

A partir de los resultados en la tabla comparativa de YOLO, sabemos que el método propuesto tiene el mejor equilibrio entre velocidad y precisión de forma integral. Si comparamos YOLOv7-tiny-SiLU con YOLOv5-N (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 a una tasa de fotogramas de 161 fps, mientras que PPYOLOE-L con el mismo AP solo tiene una tasa de 78 fps. En cuanto al uso de parámetros, YOLOv7 es un 41% menor que PPYOLOE-L.

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

Link to this sectionDescripción general#

La detección de objetos en tiempo real es un componente importante en muchos sistemas de visión artificial, incluyendo el seguimiento de objetos, 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 varias CPU, GPU y unidades de procesamiento neuronal (NPU). YOLOv7 es compatible tanto con dispositivos móviles como con GPU, desde el edge hasta la nube.

A diferencia de los detectores de objetos tradicionales en tiempo real 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".

Link to this sectionCaracterísticas clave#

YOLOv7 introduce varias características clave:

1. Reparametrización de modelos: YOLOv7 propone un modelo reparametrizado planificado, que es una estrategia aplicable a capas en diferentes redes con el concepto de ruta 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 llamado asignación de etiquetas guiada por líder de grueso a fino.

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

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

Link to this sectionEjemplos de uso#

Ultralytics no publica pesos preentrenados yolov7.pt ni archivos YAML en ultralytics/cfg/models/v7/, y el entrenamiento e inferencia nativos con PyTorch para YOLOv7 no son compatibles con el paquete de Python de Ultralytics. Sin embargo, puedes importar un punto de control de YOLOv7 entrenado en el repositorio original de YOLOv7 a Ultralytics exportándolo a ONNX o TensorRT, como se muestra a continuación.

Link to this sectionExportación a ONNX#

Para utilizar el modelo ONNX de YOLOv7 con Ultralytics:

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

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

2. Exporta el modelo YOLOv7 deseado utilizando el exportador en el 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

3. Modifica el grafo 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")

4. A continuación, puedes 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")

Link to this sectionExportación a TensorRT#

1. Sigue los pasos 1-2 en la sección Exportación a ONNX.

2. Instala el paquete de Python TensorRT:

   pip install tensorrt

3. Ejecuta el siguiente script para convertir el modelo ONNX modificado al motor TensorRT:

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

4. Carga y ejecuta el modelo en Ultralytics:

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

Link to this sectionCitas y agradecimientos#

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

@inproceedings{wang2023yolov7,
  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},
  booktitle={Proceedings of the IEEE/CVF conference on Computer Vision and Pattern Recognition (CVPR)},
  pages={7464--7475},
  year={2023}
}

El artículo oficial de YOLOv7 se publicó en el CVF 2023 Open Access, con una preimpresión en arXiv. Los autores han hecho público su trabajo y el código puede consultarse en GitHub. Agradecemos sus esfuerzos por hacer avanzar el campo y hacer que su trabajo sea accesible para la comunidad en general.

Link to this sectionFAQ#

Link to this section¿Qué es YOLOv7 y por qué se considera un avance en la detección de objetos en tiempo real?#

YOLOv7, lanzado en julio de 2022, fue un importante modelo de detección de objetos en tiempo real que logró una excelente velocidad y precisión en el momento de su lanzamiento. Superó a modelos contemporáneos como YOLOX, YOLOv5 y PPYOLOE tanto en uso de parámetros como en velocidad de inferencia. Las características distintivas de YOLOv7 incluyen su reparametrización de modelos y 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 métricas de comparación con otros detectores de objetos de última generación, consulta el artículo de YOLOv7.

Link to this section¿Cómo mejora YOLOv7 a modelos YOLO anteriores como YOLOv4 y YOLOv5?#

YOLOv7 introduce varias innovaciones, incluyendo la reparametrización de modelos y la asignación dinámica de etiquetas, que mejoran el proceso de entrenamiento y aumentan 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. Las comparaciones detalladas se pueden encontrar en la tabla de rendimiento Comparación de YOLOv7 con detectores de objetos SOTA.

Link to this section¿Puedo utilizar YOLOv7 con las herramientas y plataformas de Ultralytics?#

A día de hoy, Ultralytics solo admite la inferencia de YOLOv7 mediante ONNX y TensorRT. Para ejecutar la versión exportada de YOLOv7 en ONNX y TensorRT con Ultralytics, consulta la sección Ejemplos de uso.

Link to this section¿Cómo entreno un modelo YOLOv7 personalizado usando mi conjunto de datos?#

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

1. Clona el repositorio de YOLOv7:

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

2. Navega al directorio clonado e instala las dependencias:

   cd yolov7
   pip install -r requirements.txt

3. Prepara tu conjunto de datos y configura los parámetros del modelo siguiendo las instrucciones de uso proporcionadas en el repositorio. Para obtener más orientación, visita el repositorio de GitHub de YOLOv7 para obtener la información y las actualizaciones más recientes.

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

Link to this section¿Cuáles son las características y optimizaciones clave introducidas en YOLOv7?#

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

• Reparametrización de modelos: Mejora el rendimiento del modelo optimizando las rutas de propagación de gradiente.
• Asignación dinámica de etiquetas: Utiliza un método guiado por líder de grueso a fino para asignar objetivos dinámicos para las salidas a través de diferentes ramas, mejorando la precisión.
• Escalado extendido y compuesto: Utiliza eficazmente los parámetros y el cálculo para escalar el modelo para diversas aplicaciones en tiempo real.
• Eficiencia: Reduce el número de parámetros en un 40 % y el cálculo en un 50 % en comparación con otros modelos de última generación, al tiempo que logra velocidades de inferencia más rápidas.

Para más detalles sobre estas características, consulta la sección Descripción general de YOLOv7.