Começar

Meituan YOLOv6

Visão geral#

O YOLOv6 da Meituan, lançado em 2022, é um modelo de deteção de objetos que oferece um bom equilíbrio entre velocidade e precisão, sendo uma escolha popular para aplicações em tempo real. Este modelo introduz várias melhorias importantes na arquitetura e no esquema de treino, incluindo a implementação de um módulo de concatenação bidirecional (BiC), uma estratégia de treino assistida por âncoras (AAT) e um design melhorado da rede base e do pescoço para alcançar elevada precisão no conjunto de dados COCO.

Modelo de deteção de objetos YOLOv6 em tempo real da Meituan Diagrama da arquitetura do modelo YOLOv6 Visão geral do YOLOv6. Diagrama da arquitetura do modelo que mostra os componentes de rede redesenhados e as estratégias de treino que proporcionaram melhorias significativas no desempenho. (a) O pescoço do YOLOv6 (são apresentados N e S). Nota: para M/L, RepBlocks é substituído por CSPStackRep. (b) A estrutura de um módulo BiC. (c) Um bloco SimCSPSPPF. (fonte.)

Principais funcionalidades#

  • Módulo de concatenação bidirecional (BiC): o YOLOv6 introduz um módulo BiC no pescoço do detetor, melhorando os sinais de localização e aumentando o desempenho com uma degradação insignificante da velocidade.
  • Estratégia de treino assistido por âncoras (AAT): AAT combina as vantagens dos paradigmas baseados em âncoras e sem âncoras sem comprometer a eficiência da inferência.
  • Design melhorado da rede base e do pescoço: ao aprofundar o YOLOv6 com a inclusão de mais uma etapa na rede base e no pescoço, este modelo alcançou um desempenho sólido no conjunto de dados COCO com entrada de alta resolução na altura do lançamento.
  • Estratégia de autodestilação: É implementada uma nova estratégia de autodestilação para melhorar o desempenho dos modelos mais pequenos do YOLOv6, reforçando o ramo de regressão auxiliar durante o treino e removendo-o na inferência para evitar uma redução acentuada da velocidade.

Métricas de desempenho#

O YOLOv6 disponibiliza vários modelos pré-treinados de diferentes escalas:

  • YOLOv6-N: 37,5% de AP no COCO val2017 a 1187 FPS com uma 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: precisão de última geração em tempo real.

O YOLOv6 também disponibiliza modelos quantizados com diferentes precisões numéricas e modelos otimizados para plataformas móveis.

Exemplos de uso#

Este exemplo apresenta exemplos simples de treino e inferência com YOLOv6.

Exemplo

Os ficheiros *.yaml do YOLOv6 podem ser passados à classe YOLO() para criar o modelo correspondente em Python:

from ultralytics import YOLO

# Cria um modelo YOLOv6n do zero
model = YOLO("yolov6n.yaml")

# Exibir informações do modelo (opcional)
model.info()

# Treina o modelo no conjunto de dados de exemplo COCO8 durante 100 épocas
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

# Executa a inferência com o modelo YOLOv6n na imagem 'bus.jpg'
results = model("path/to/bus.jpg")

Tarefas e modos compatíveis#

A série YOLOv6 oferece vários modelos, cada um otimizado para a deteção de objetos, que abrangem diferentes orçamentos computacionais e requisitos de precisão.

ModeloNomes de arquivoTarefasTreinamentoValidaçãoInferênciaExportar
YOLOv6-Nyolov6n.yamlDeteção de objetos✅✅✅✅
YOLOv6-Syolov6s.yamlDeteção de objetos✅✅✅✅
YOLOv6-Myolov6m.yamlDeteção de objetos✅✅✅✅
YOLOv6-Lyolov6l.yamlDeteção de objetos✅✅✅✅
YOLOv6-Xyolov6x.yamlDeteção de objetos✅✅✅✅

Esta tabela resume as variantes do modelo YOLOv6 e o respetivo suporte para os modos de treino, validação, inferência e exportação. A Ultralytics disponibiliza apenas ficheiros YAML dos modelos YOLOv6, pelo que os modelos são treinados de raiz.

Citações e agradecimentos#

Gostaríamos de reconhecer as contribuições significativas dos autores para a área da deteção de objetos em tempo real:

Citação
@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}
}

O artigo original do YOLOv6 pode ser encontrado no arXiv. Os autores disponibilizaram publicamente o seu trabalho, e o código-fonte pode ser consultado no GitHub. Agradecemos os seus esforços para fazer avançar a área e tornar o trabalho acessível a uma comunidade mais ampla.

Perguntas frequentes#

  • O Meituan YOLOv6, lançado em 2022, é um detetor de objetos que equilibra velocidade e precisão, concebido para aplicações em tempo real. Inclui melhorias arquitetónicas notáveis, como o módulo de concatenação bidirecional (BiC) e uma estratégia de treino assistido por âncoras (AAT). Estas inovações proporcionam ganhos substanciais de desempenho com uma degradação mínima da velocidade, tornando o YOLOv6 uma opção competitiva para tarefas de deteção de objetos.

  • O módulo de concatenação bidirecional (BiC) do YOLOv6 melhora os sinais de localização no pescoço do detetor, aumentando o desempenho com um impacto insignificante na velocidade. Este módulo combina eficazmente diferentes mapas de características, aumentando a capacidade do modelo para detetar objetos com precisão. Para mais detalhes sobre as funcionalidades do YOLOv6, consulta a secção Principais funcionalidades.

  • Podes treinar um modelo YOLOv6 com a Ultralytics usando comandos simples de Python ou da CLI. Por exemplo:

    Exemplo
    from ultralytics import YOLO
    
    # Cria um modelo YOLOv6n do zero
    model = YOLO("yolov6n.yaml")
    
    # Treina o modelo no conjunto de dados de exemplo COCO8 durante 100 épocas
    results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

    Para mais informações, visita a página Treino.

  • O YOLOv6 oferece várias versões, cada uma otimizada para diferentes requisitos de desempenho:

    • 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: precisão de última geração em cenários em tempo real

    Estes modelos são avaliados no conjunto de dados COCO usando uma GPU NVIDIA T4. Para saber mais sobre as métricas de desempenho, consulta a secção Métricas de desempenho.

  • O treino assistido por âncoras (AAT) no YOLOv6 combina elementos das abordagens baseadas e sem âncoras, melhorando as capacidades de deteção do modelo sem comprometer a eficiência da inferência. Esta estratégia utiliza âncoras durante o treino para melhorar as previsões de caixas delimitadoras, tornando o YOLOv6 eficaz em diversas tarefas de deteção de objetos.

  • O YOLOv6 suporta os modos de treino, validação, inferência e exportação.

Comentários14

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

  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.

    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! 😊

  3. 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.