Empezar

Meituan YOLOv6

Descripción general#

Meituan YOLOv6, publicado en 2022, es un modelo de detección de objetos que ofrece un sólido equilibrio entre velocidad y precisión, por lo que es una opción popular para aplicaciones en tiempo real. Este modelo incorpora varias mejoras destacadas en su arquitectura y esquema de entrenamiento, como la implementación de un módulo de concatenación bidireccional (BiC), una estrategia de entrenamiento asistido por anclajes (AAT) y un diseño mejorado de la red troncal y el cuello para lograr una gran precisión en el conjunto de datos COCO.

Modelo de detección de objetos en tiempo real YOLOv6 de Meituan Diagrama de la arquitectura del modelo YOLOv6 Descripción general de YOLOv6. Diagrama de la arquitectura del modelo que muestra los componentes de red rediseñados y las estrategias de entrenamiento que han permitido mejoras significativas del rendimiento. (a) El cuello de YOLOv6 (se muestran N y S). Para M/L, RepBlocks se sustituye por CSPStackRep. (b) La estructura de un módulo BiC. (c) Un bloque SimCSPSPPF. (fuente).

Características principales#

  • Módulo de concatenación bidireccional (BiC): YOLOv6 incorpora un módulo BiC en el cuello del detector que mejora las señales de localización y aumenta el rendimiento con una degradación insignificante de la velocidad.
  • Estrategia de entrenamiento asistido por anclajes (AAT): AAT combina las ventajas de los paradigmas basados en anclajes y sin anclajes sin comprometer la eficiencia de la inferencia.
  • Diseño mejorado del backbone y el cuello: Al profundizar YOLOv6 para incluir otra etapa en el backbone y el cuello, este modelo alcanzó un rendimiento sólido en el conjunto de datos COCO con entradas de alta resolución en el momento de su lanzamiento.
  • Estrategia de autodestilación: Se implementa una nueva estrategia de autodestilación para mejorar el rendimiento de los modelos más pequeños de YOLOv6, potenciando la rama de regresión auxiliar durante el entrenamiento y eliminándola durante la inferencia para evitar una caída notable de la velocidad.

Métricas de rendimiento#

YOLOv6 ofrece varios modelos preentrenados de distintas escalas:

  • YOLOv6-N: 37,5 % de AP en COCO val2017 a 1187 FPS con una GPU NVIDIA T4.
  • YOLOv6-S: 45,0 % de AP a 484 FPS.
  • YOLOv6-M: 50,0 % de AP a 226 FPS.
  • YOLOv6-L: 52,8 % de AP a 116 FPS.
  • YOLOv6-L6: precisión de vanguardia en tiempo real.

YOLOv6 también ofrece modelos cuantizados con distintas precisiones numéricas y modelos optimizados para plataformas móviles.

Ejemplos de uso#

Este ejemplo ofrece ejemplos sencillos de entrenamiento e inferencia con YOLOv6.

Ejemplo

Los archivos *.yaml de YOLOv6 se pueden pasar a la clase YOLO() para crear el modelo correspondiente en Python:

from ultralytics import YOLO

# Construir un modelo YOLOv6n desde cero
model = YOLO("yolov6n.yaml")

# Mostrar información del modelo (opcional)
model.info()

# Entrena el modelo durante 100 épocas con el conjunto de datos de ejemplo COCO8
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

# Ejecutar inferencias con el modelo YOLOv6n en la imagen 'bus.jpg'
results = model("path/to/bus.jpg")

Tareas y modos compatibles#

La serie YOLOv6 ofrece una variedad de modelos, cada uno optimizado para la detección de objetos, que cubren distintos presupuestos computacionales y requisitos de precisión.

ModeloNombres de archivoTareasEntrenamientoValidaciónInferenciaExportar
YOLOv6-Nyolov6n.yamlDetección de objetos✅✅✅✅
YOLOv6-Syolov6s.yamlDetección de objetos✅✅✅✅
YOLOv6-Myolov6m.yamlDetección de objetos✅✅✅✅
YOLOv6-Lyolov6l.yamlDetección de objetos✅✅✅✅
YOLOv6-Xyolov6x.yamlDetección de objetos✅✅✅✅

Esta tabla resume las variantes del modelo YOLOv6 y su compatibilidad con los modos de entrenamiento, validación, inferencia y exportación. Ultralytics solo proporciona archivos YAML de modelos YOLOv6, por lo que los modelos se entrenan desde cero.

Citas y agradecimientos#

Queremos reconocer las importantes contribuciones de los autores al campo de la detección de objetos en tiempo real:

Cita
@misc{li2023yolov6,
      title={YOLOv6 v3.0: A Full-Scale Reloading},
      author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu},
      year={2023},
      eprint={2301.05586},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}

El artículo original de YOLOv6 está disponible en arXiv. Los autores han hecho público su trabajo y el código está disponible en GitHub. Agradecemos sus esfuerzos por impulsar este campo y hacer que su trabajo esté al alcance de una comunidad más amplia.

Preguntas frecuentes#

  • Meituan YOLOv6, publicado en 2022, es un detector de objetos que equilibra velocidad y precisión, diseñado para aplicaciones en tiempo real. Incluye mejoras arquitectónicas destacadas, como el módulo de concatenación bidireccional (BiC) y una estrategia de entrenamiento asistido por anclajes (AAT). Estas innovaciones ofrecen mejoras de rendimiento considerables con una degradación mínima de la velocidad, lo que convierte a YOLOv6 en una opción competitiva para tareas de detección de objetos.

  • El módulo de concatenación bidireccional (BiC) de YOLOv6 mejora las señales de localización en el cuello del detector y ofrece mejoras de rendimiento con un impacto insignificante en la velocidad. Este módulo combina eficazmente distintos mapas de características, lo que aumenta la capacidad del modelo para detectar objetos con precisión. Para obtener más información sobre las características de YOLOv6, consulta la sección Características clave.

  • Puedes entrenar un modelo YOLOv6 con Ultralytics mediante sencillos comandos de Python o CLI. Por ejemplo:

    Ejemplo
    from ultralytics import YOLO
    
    # Construir un modelo YOLOv6n desde cero
    model = YOLO("yolov6n.yaml")
    
    # Entrena el modelo durante 100 épocas con el conjunto de datos de ejemplo COCO8
    results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

    Para obtener más información, visita la página de Entrenamiento.

  • YOLOv6 ofrece varias versiones, cada una optimizada para distintos requisitos de rendimiento:

    • YOLOv6-N: 37,5 % de AP a 1187 FPS
    • YOLOv6-S: 45,0 % de AP a 484 FPS
    • YOLOv6-M: 50,0 % de AP a 226 FPS
    • YOLOv6-L: 52,8 % de AP a 116 FPS
    • YOLOv6-L6: precisión de vanguardia en situaciones en tiempo real

    Estos modelos se evalúan en el conjunto de datos COCO con una GPU NVIDIA T4. Para obtener más información sobre las métricas de rendimiento, consulta la sección Métricas de rendimiento.

  • El entrenamiento asistido por anclajes (AAT) de YOLOv6 combina elementos de los enfoques basados en anclajes y sin anclajes, lo que mejora la capacidad de detección del modelo sin comprometer la eficiencia de inferencia. Esta estrategia aprovecha los anclajes durante el entrenamiento para mejorar las predicciones de la caja delimitadora, lo que hace que YOLOv6 sea eficaz en diversas tareas de detección de objetos.

  • YOLOv6 admite los modos de entrenamiento, validación, inferencia y exportación.

Comentarios14

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  1. AkaashSamsonGitHub

    Hey, So I have actually trained my YOLOv6 model with the original repo, now I have a .pt file. using this file is there any way of getting my model in ultralytics format. mainly I want to run the ultralytics validation on my model as the original repo eval.py doesn't provide sufficient metrics.

    1. Glenn JocherUltralytics

      Direct conversion of Meituan YOLOv6 .pt checkpoints to Ultralytics format isn’t supported; to use Ultralytics metrics, either train/fine-tune the matching yolov6*.yaml in Ultralytics and run validation, or export your Meituan model’s detections to COCO JSON and compute P/R via the COCO API; the metrics Ultralytics reports are outlined in the Val mode docs at Ultralytics validation.

  2. tino926GitHub(editado)

    I want to replicate your training accuracy of the YOLOv6-N model. Is this the correct command: yolo train model=yolov6n.yaml data=coco.yaml epochs=400 optimizer=SGD cos_lr=True lr0=0.02? According to YOLOv6's repo https://github.com/meituan/YOLOv6/blob/main/docs/Train_coco_data.md, they have to use anchor-aid and distilling techniques to achieve this accuracy. But I can't find the corresponding parameters in ultralytics'.

    1. Glenn JocherUltralytics

      @tino926 to achieve the training accuracy of the YOLOv6-N model as described in the YOLOv6 repository, you would indeed use the anchor-aided training (AAT) and self-distillation strategies, which are not explicitly parameterized in the Ultralytics YOLO interface. Ensure you are using the latest version and check the YOLOv6 documentation for any updates on incorporating these strategies. For precise replication, consider following the original YOLOv6 GitHub instructions alongside Ultralytics for any additional settings or configurations.

    2. tino926GitHub

      @glenn-jocher, thanks for your response.

      I apologize if I misunderstood your explanation, as I am not a native English speaker. Could you please clarify if the phrase "which are not explicitly parameterized in the Ultralytics YOLO interface" means that AAT and self-distillation cannot currently be implemented solely through the Ultralytics YOLO interface? Therefore I should manually add anchor branches and implement distillation with additional code?

    3. Glenn JocherUltralytics

      Thank you for your question. Yes, that's correct. The current Ultralytics YOLO interface does not explicitly support anchor-aided training (AAT) and self-distillation, so you would need to implement these strategies manually by modifying the code to include anchor branches and self-distillation techniques. If you need further guidance on implementing these, referring to the original YOLOv6 repository might be helpful.

  3. kadirnarGitHub

    Does ultralytics library support yolov6 model?

    ModuleNotFoundError: No module named 'yolov6'

    1. Paula DerrengerUltralytics(editado)

      @kadirnar hi there!

      Yes, the Ultralytics library does support YOLOv6 models. It seems like you might be encountering a ModuleNotFoundError because the YOLOv6 model isn't being recognized. Let's ensure you're using the latest versions of torch and ultralytics. Please update your packages and try again:

      pip install --upgrade torch ultralytics

      Here's a quick example to get you started with YOLOv6 using the Ultralytics library:

      Python
      from ultralytics import YOLO
      
      # Load a YOLOv6n model
      model = YOLO("yolov6n.yaml")
      
      # Train the model on the COCO8 example dataset for 100 epochs
      results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
      
      # Run inference with the trained model on an image
      results = model("path/to/bus.jpg")
      CLI
      # Train YOLOv6n model
      yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
      
      # Run inference with your trained weights
      yolo predict model=path/to/best.pt source=path/to/bus.jpg

      If you continue to face issues, please provide a minimum reproducible example so we can better assist you. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.

      Feel free to reach out if you have any more questions! 😊

  4. akhilesh99sharmaGitHub

    There are AP and AR values for results but not precision and recall. I need to compare precision and recall values for different YOLO versions (v5,v6,v7 etc.) on my custom dataset. How to get precision and recall values for YOLOv6 evaluation?

    1. Paula DerrengerUltralytics(editado)

      Hey there! 👋

      You don't need to compute precision and recall by hand: validation already reports them. After model.val(), the results object holds them directly:

      from ultralytics import YOLO
      
      # Load your trained model
      model = YOLO("path/to/your/custom-yolov6-model.pt")
      
      # Run validation
      results = model.val(data="path/to/your/dataset.yaml")
      
      print(f"Precision: {results.box.mp}, Recall: {results.box.mr}")  # mean over all classes
      print(results.box.p, results.box.r)  # per-class precision and recall

      Hope this helps, and happy comparing across YOLO versions! 🚀

    2. Paula DerrengerUltralytics(editado)

      Hey there! 😊

      Precision and recall are reported by Ultralytics validation, so you don't need to count TP/FP/FN yourself. After results = model.val(data="path/to/dataset.yaml"), use results.box.mp (mean precision), results.box.mr (mean recall), and results.box.p / results.box.r for per-class values.

      If you need them computed from raw counts, precision = TP / (TP + FP) and recall = TP / (TP + FN), where the counts come from matching predictions to ground-truth boxes at an IoU threshold.

      Hope this helps! Let me know if there's anything else I can do for you. Happy modeling! 🚀

    3. akhilesh99sharmaGitHub

      Hello, I tried doing it but was not able to do so. I get the predictions json file in the val folder but don't know how to compare it with the labels to get TP, FP etc. Can you please help me with that? I need to compare results of YOLOv6 with v8, v9 but I am not getting precision and recall values in v6 , I get average precision and average recall

    4. Paula DerrengerUltralytics(editado)

      @akhilesh99sharma hey there! 🌞

      You can get precision and recall directly from validation without processing the predictions JSON yourself. After results = model.val(data="path/to/dataset.yaml"), use results.box.mp (mean precision), results.box.mr (mean recall), and results.box.p / results.box.r for per-class values.

      If you still need TP, FP and FN counts from the saved predictions JSON, you will have to match predicted boxes to ground-truth boxes per image using an IoU threshold. The confusion matrix saved in the run folder (confusion_matrix.png, or model.val(plots=True)) also shows these counts per class.

      For comparing across YOLO versions, run each model with consistent settings on your custom dataset and read the same metrics from each.

      I hope this simplifies the process for you! 🚀 Let me know if you need further assistance.