Inferência de detecção de objetos em tempo real em Python com YOLOv7

Introdução

A detecção de objetos é um grande campo em visão computacional e uma das aplicações mais importantes da visão computacional “na natureza”.

A detecção de objetos não é tão padronizada quanto a classificação de imagens, principalmente porque a maioria dos novos desenvolvimentos é normalmente feita por pesquisadores, mantenedores e desenvolvedores individuais, em vez de grandes bibliotecas e estruturas. É difícil empacotar os scripts utilitários necessários em uma estrutura como TensorFlow ou PyTorch e manter as diretrizes da API que orientaram o desenvolvimento até agora.

Isso torna a detecção de objetos um pouco mais complexa, geralmente mais detalhada (mas nem sempre) e menos acessível do que a classificação de imagens.

Felizmente para as massas – a Ultralytics desenvolveu uma API de detecção de objetos simples, muito poderosa e bonita em torno de seu YOLOv5, que foi estendida por outras equipes de pesquisa e desenvolvimento em versões mais recentes, como YOLOv7.

Neste pequeno guia, realizaremos a Detecção de Objetos em Python, com YOLOv7 de última geração.

YOLO Paisagem e YOLOv7

YOLO (Você só olha uma vez) é uma metodologia, bem como uma família de modelos construídos para detecção de objetos. Desde o início em 2015, YOLOv1, YOLOv2 (YOLO9000) e YOLOv3 foram propostos pelo(s) mesmo(s) autor(es) – e a comunidade de aprendizado profundo continuou com avanços de código aberto nos anos contínuos.

Ultralytics' YOLOv5 é a primeira implementação em larga escala do YOLO no PyTorch, o que o tornou mais acessível do que nunca, mas a principal razão pela qual o YOLOv5 ganhou tal posição também é a API lindamente simples e poderosa construída em torno dele. O projeto abstrai os detalhes desnecessários, permitindo customização, praticamente todos os formatos de exportação utilizáveis, e emprega práticas incríveis que tornam todo o projeto eficiente e o mais otimizado possível.

O YOLOv5 ainda é o projeto básico para construir modelos de Detecção de Objetos, e muitos repositórios que visam avançar o método YOLO começam com o YOLOv5 como linha de base e oferecem uma API semelhante (ou simplesmente bifurcam o projeto e compilam em cima dele). Tal é o caso de YOLOR (Você só aprende uma representação) e YOLOv7 que foi construído em cima de YOLOR (mesmo autor). O YOLOv7 é o mais recente avanço na metodologia YOLO e, mais notavelmente, o YOLOv7 fornece novos cabeçotes de modelo, que podem gerar pontos-chave (esqueletos) e realizar segmentação de instâncias, além de apenas regressão de caixa delimitadora, que não era padrão nos modelos YOLO anteriores.

Isso torna a segmentação de instâncias e a detecção de pontos-chave mais rápidas do que nunca!

Além disso, o YOLOv7 funciona mais rápido e com maior grau de precisão do que os modelos anteriores devido a uma contagem de parâmetros reduzida e maior eficiência computacional:

O modelo em si foi criado por meio de mudanças arquitetônicas, além de otimizar aspectos do treinamento, apelidado de “bag-of-freebies”, o que aumentou a precisão sem aumentar o custo de inferência.

Instalando o YOLOv7

Instalar e usar o YOLOv7 se resume a baixar o repositório GitHub para sua máquina local e executar os scripts que vêm com ele.

Mesmo assim, você pode realizar a detecção em tempo real em vídeos, imagens, etc. e salvar os resultados facilmente. O projeto segue as mesmas convenções do YOLOv5, que possui uma extensa documentação, portanto, é provável que você encontre respostas para mais perguntas de nicho no repositório YOLOv5, se tiver alguma.

Vamos baixar o repositório e realizar alguma inferência:

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

Isso cria um yolov7 diretório em seu diretório de trabalho atual, que abriga o projeto. Vamos entrar nesse diretório e dar uma olhada nos arquivos:

%cd yolov7
!ls
/Users/macbookpro/jup/yolov7
LICENSE.md       detect.py        models           tools
README.md        export.py        paper            train.py
cfg              figure           requirements.txt train_aux.py
data             hubconf.py       scripts          utils
deploy           inference        test.py          runs

A detect.py são os scripts de inferência que executam as detecções e salvam os resultados em runs/detect/video_name, onde você pode especificar o video_name ao chamar o detect.py script. export.py exporta o modelo para vários formatos, como ONNX, TFLite, etc. train.py pode ser usado para treinar um detector YOLOv7 personalizado (o tópico de outro guia) e test.py pode ser usado para testar um detector (carregado de um arquivo de pesos).

Vários diretórios adicionais mantêm as configurações (cfg), dados de exemplo (inference), dados sobre a construção de modelos e configurações COCO (data, Etc.)

Tamanhos YOLOv7

Os modelos baseados em YOLO são bem dimensionados e normalmente são exportados como modelos menores e menos precisos e modelos maiores e mais precisos. Estes são então implantados em dispositivos mais fracos ou mais fortes, respectivamente.

O YOLOv7 oferece vários tamanhos e os compara com o MS COCO:

Modelo	Tamanho do teste	APteste	AP50test	AP75test	lote 1 fps	lote 32 tempo médio
YOLOv7	640	51.4%	69.7%	55.9%	161 fps	2.8 ms
YOLOv7-X	640	53.1%	71.2%	57.8%	114 fps	4.3 ms
YOLOv7-W6	1280	54.9%	72.6%	60.1%	84 fps	7.6 ms
YOLOv7-E6	1280	56.0%	73.5%	61.2%	56 fps	12.3 ms
YOLOv7-D6	1280	56.6%	74.0%	61.8%	44 fps	15.0 ms
YOLOv7-E6E	1280	56.8%	74.4%	62.1%	36 fps	18.7 ms

Dependendo do hardware subjacente em que você espera que o modelo seja executado e da precisão necessária, você pode escolher entre eles. O menor modelo atinge mais de 160FPS em imagens de tamanho 640, em um V100! Você também pode esperar um desempenho em tempo real satisfatório em GPUs de consumo mais comuns.

Inferência de vídeo com YOLOv7

Crie uma inference-data pasta para armazenar as imagens e/ou vídeos que você deseja detectar. Supondo que esteja no mesmo diretório, podemos executar um script de detecção com:

! python3 detect.py --source inference-data/busy_street.mp4 --weights yolov7.pt --name video_1 --view-img

Isso exibirá um vídeo baseado em Qt em sua área de trabalho, no qual você poderá ver o progresso e a inferência ao vivo, quadro a quadro, além de enviar o status para nosso canal de saída padrão:

Namespace(weights=['yolov7.pt'], source='inference-data/busy_street.mp4', img_size=640, conf_thres=0.25, iou_thres=0.45, device='', view_img=True, save_txt=False, save_conf=False, nosave=False, classes=None, agnostic_nms=False, augment=False, update=False, project='runs/detect', name='video_1', exist_ok=False, no_trace=False)
YOLOR 🚀 v0.1-112-g55b90e1 torch 1.12.1 CPU

Downloading https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt to yolov7.pt...
100%|██████████████████████████████████████| 72.1M/72.1M [00:18<00:00, 4.02MB/s]

Fusing layers... 
RepConv.fuse_repvgg_block
RepConv.fuse_repvgg_block
RepConv.fuse_repvgg_block
Model Summary: 306 layers, 36905341 parameters, 6652669 gradients
 Convert model to Traced-model... 
 traced_script_module saved! 
 model is traced! 
 
video 1/1 (1/402) /Users/macbookpro/jup/yolov7/inference-data/busy_street.mp4: 24 persons, 1 bicycle, 8 cars, 3 traffic lights, 2 backpacks, 2 handbags, Done. (1071.6ms) Inference, (2.4ms) NMS
video 1/1 (2/402) /Users/macbookpro/jup/yolov7/inference-data/busy_street.mp4: 24 persons, 1 bicycle, 8 cars, 3 traffic lights, 2 backpacks, 2 handbags, Done. (1070.8ms) Inference, (1.3ms) NMS

Observe que o projeto será executado lentamente em máquinas baseadas em CPU (como 1000ms por etapa de inferência na saída acima, executado em um MacBook Pro 2017 baseado em Intel) e significativamente mais rápido em máquinas baseadas em GPU (mais próximo de ~ 5ms/frame em um V100). Mesmo em sistemas baseados em CPU como este, yolov7-tiny.pt corre em 172ms/frame, que embora longe de ser em tempo real, ainda é muito decente para lidar com essas operações em uma CPU.

Quando a execução estiver concluída, você poderá encontrar o vídeo resultante em runs/video_1 (o nome que fornecemos no detect.py chamada), salvo como .mp4:

Inferência em Imagens

A inferência em imagens se resume ao mesmo processo – fornecer a URL para uma imagem no sistema de arquivos e chamar detect.py:

! python3 detect.py --source inference-data/desk.jpg --weights yolov7.pt

Conclusão

Neste pequeno guia, demos uma breve olhada no YOLOv7, o mais recente avanço na família YOLO, que se baseia no YOLOR. Demos uma olhada em como instalar o repositório em sua máquina local e executar scripts de inferência de detecção de objetos com uma rede pré-treinada em vídeos e imagens.

Em outros guias, abordaremos a detecção de pontos-chave e a segmentação de instâncias.

Indo além - Aprendizado profundo prático para visão computacional

Sua natureza curiosa faz você querer ir mais longe? Recomendamos verificar nosso Para: “Aprendizado Profundo Prático para Visão Computacional com Python”.

Outro curso de visão computacional?

Não faremos classificação de dígitos MNIST ou moda MNIST. Eles cumpriram sua parte há muito tempo. Muitos recursos de aprendizado estão se concentrando em conjuntos de dados básicos e arquiteturas básicas antes de permitir que arquiteturas de caixa preta avançadas carreguem o fardo do desempenho.

Queremos focar em desmistificação, praticidade, compreensão, intuição e projetos reais. Quero aprender como você pode fazer a diferença? Vamos levá-lo em um passeio desde a maneira como nossos cérebros processam imagens para escrever um classificador de aprendizado profundo de nível de pesquisa para câncer de mama até redes de aprendizado profundo que “alucinam”, ensinando os princípios e a teoria por meio de trabalho prático, equipando você com o know-how e ferramentas para se tornar um especialista na aplicação de aprendizado profundo para resolver a visão computacional.

O que tem dentro?

• Os primeiros princípios da visão e como os computadores podem ser ensinados a “ver”
• Diferentes tarefas e aplicações de visão computacional
• As ferramentas do comércio que facilitarão seu trabalho
• Encontrar, criar e utilizar conjuntos de dados para visão computacional
• A teoria e aplicação das Redes Neurais Convolucionais
• Lidar com mudança de domínio, coocorrência e outros vieses em conjuntos de dados
• Transferir Aprendizagem e utilizar o tempo de treinamento e recursos computacionais de outros para seu benefício
• Construindo e treinando um classificador de câncer de mama de última geração
• Como aplicar uma dose saudável de ceticismo às ideias dominantes e entender as implicações de técnicas amplamente adotadas
• Visualizando o “espaço conceitual” de um ConvNet usando t-SNE e PCA
• Estudos de caso de como as empresas usam técnicas de visão computacional para obter melhores resultados
• Avaliação adequada do modelo, visualização do espaço latente e identificação da atenção do modelo
• Realizando pesquisas de domínio, processando seus próprios conjuntos de dados e estabelecendo testes de modelo
• Arquiteturas de ponta, a progressão das ideias, o que as torna únicas e como implementá-las
• KerasCV – uma biblioteca WIP para criar pipelines e modelos de última geração
• Como analisar e ler artigos e implementá-los você mesmo
• Selecionando modelos dependendo da sua aplicação
• Criando um pipeline de aprendizado de máquina de ponta a ponta
• Paisagem e intuição na detecção de objetos com R-CNNs, RetinaNets, SSDs e YOLO mais rápidos
• Segmentação de instância e semântica
• Reconhecimento de objetos em tempo real com YOLOv5
• Treinamento de detectores de objetos YOLOv5
• Trabalhando com Transformers usando KerasNLP (biblioteca WIP de força da indústria)
• Integrando Transformers com ConvNets para gerar legendas de imagens
• Deepdream
• Otimização de modelo de Deep Learning para visão computacional