Inferência de detecção de objetos em Python com YOLOv5 e PyTorch

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”. Por um lado, ele pode ser usado para construir sistemas autônomos que navegam agentes através de ambientes – sejam robôs executando tarefas ou carros autônomos, mas isso requer interseção com outros campos. No entanto, detecção de anomalias (como produtos defeituosos em uma linha), localização de objetos dentro de imagens, detecção facial e várias outras aplicações de detecção de objetos podem ser feitas sem cruzar outros campos.

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. Um dos principais benefícios de estar em um ecossistema é que ele oferece uma maneira de não procurar informações úteis sobre boas práticas, ferramentas e abordagens de uso. Com a detecção de objetos – a maioria das pessoas precisa pesquisar muito mais sobre a paisagem do campo para obter uma boa aderência.

Felizmente para as massas – a Ultralytics desenvolveu uma API de detecção de objetos simples, muito poderosa e bonita em torno de sua implementação YOLOv5.

Neste pequeno guia, realizaremos a detecção de objetos em Python, com o YOLOv5 criado pela Ultralytics em PyTorch, usando um conjunto de pesos pré-treinados treinados no MS COCO.

YOLOv5

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. Verdadeiramente, é um exemplo da beleza da implementação de software de código aberto e como ela fortalece o mundo em que vivemos.

O projeto fornece pesos pré-treinados no MS COCO, um conjunto de dados básico sobre objetos em contexto, que pode ser usado para comparar e construir sistemas gerais de detecção de objetos - mas o mais importante, pode ser usado para transferir conhecimento geral de objetos em contexto para conjuntos de dados.

Detecção de objetos com YOLOv5

Antes de seguir em frente, certifique-se de ter torch e torchvision instalado:

! python -m pip install torch torchvision

O YOLOv5 possui documentação detalhada e prática e uma API lindamente simples, conforme mostrado no próprio repositório e no exemplo a seguir:

import torch

model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
img = 'https://i.ytimg.com/vi/q71MCWAEfL8/maxresdefault.jpg'  
results = model(img)
fig, ax = plt.subplots(figsize=(16, 12))
ax.imshow(results.render()[0])
plt.show()

O segundo argumento do hub.load() O método especifica os pesos que gostaríamos de usar. Ao escolher qualquer lugar entre yolov5n para yolov5l6 – estamos carregando os pesos pré-treinados MS COCO. Para modelos personalizados:

model = torch.hub.load('ultralytics/yolov5', 'custom', path='path_to_weights.pt')

De qualquer forma – uma vez que você passa a entrada pelo modelo, o objeto retornado inclui métodos úteis para interpretar os resultados, e nós escolhemos render() eles, que retorna um array NumPy que podemos colocar em um imshow() ligar. Isso resulta em um formato bem formatado:

Salvando resultados como arquivos

Você pode salvar os resultados da inferência como um arquivo, usando o results.save() método:

results.save(save_dir='results')

Isso criará um novo diretório se ainda não estiver presente e salvará a mesma imagem que acabamos de plotar como um arquivo.

Recortando Objetos

Você também pode decidir cortar os objetos detectados como arquivos individuais. No nosso caso, para cada rótulo detectado, várias imagens podem ser extraídas. Isto é facilmente alcançado através do results.crop() método, que cria um runs/detect/ diretório, com expN/crops (onde N aumenta a cada execução), no qual é feito um diretório com imagens recortadas para cada rótulo:

results.crop()

Saved 1 image to runs/detect/exp2
Saved results to runs/detect/exp2

[{'box': [tensor(295.09409),
   tensor(277.03699),
   tensor(514.16113),
   tensor(494.83691)],
  'conf': tensor(0.25112),
  'cls': tensor(0.),
  'label': 'person 0.25',
  'im': array([[[167, 186, 165],
          [174, 184, 167],
          [173, 184, 164],

Você também pode verificar a estrutura do arquivo de saída com:

! ls runs/detect/exp2/crops


! ls runs/detect/exp2/crops

Contagem de Objetos

Por padrão, quando você realiza a detecção ou imprime o results object - você obterá o número de imagens em que a inferência foi realizada para isso results objeto (YOLOv5 também funciona com lotes de imagens), sua resolução e a contagem de cada rótulo detectado:

print(results)

Isto resulta em:

image 1/1: 720x1280 14 persons, 1 car, 3 buss, 6 traffic lights, 1 backpack, 1 umbrella, 1 handbag
Speed: 35.0ms pre-process, 256.2ms inference, 0.7ms NMS per image at shape (1, 3, 384, 640)

Inferência com scripts

Como alternativa, você pode executar o script de detecção, detect.py, clonando o repositório YOLOv5:

$ git clone https://github.com/ultralytics/yolov5 
$ cd yolov5
$ pip install -r requirements.txt

E então executando:

$ python detect.py --source img.jpg

Como alternativa, você pode fornecer um URL, arquivo de vídeo, caminho para um diretório com vários arquivos, um glob em um caminho para corresponder apenas a determinados arquivos, um link do YouTube ou qualquer outro fluxo HTTP. Os resultados são salvos no runs/detect diretório.

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

Conclusão

Neste pequeno guia, analisamos como você pode realizar a detecção de objetos com o YOLOv5 criado usando o PyTorch.