Detecção de objetos RetinaNet com PyTorch e torchvision

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 precisa fazer muito mais pesquisas sobre a paisagem do campo para obter uma boa aderência.

Detecção de objetos com PyTorch/TorchVision's RetinaNet

torchvision é o projeto de Visão Computacional da PyTorch, e visa facilitar o desenvolvimento de modelos de CV baseados em PyTorch, fornecendo scripts de transformação e aumento, um zoológico de modelo com pesos pré-treinados, conjuntos de dados e utilitários que podem ser úteis para um profissional.

Enquanto ainda em beta e muito experimental – torchvision oferece uma API de detecção de objetos relativamente simples com alguns modelos para escolher:

• R-CNN mais rápida
• RetinaNet
• FCOS (RetinaNet totalmente convolucional)
• SSD (backbone VGG16… caramba)
• SSDLite (backbone MobileNetV3)

Embora a API não seja tão polida ou simples quanto algumas outras APIs de terceiros, é um ponto de partida muito decente para aqueles que ainda preferem a segurança de estar em um ecossistema com o qual estão familiarizados. Antes de prosseguir, certifique-se de instalar o PyTorch e o Torchvision:

$ pip install torch torchvision

Vamos carregar algumas das funções utilitárias, como read_image(), draw_bounding_boxes() e to_pil_image() para facilitar a leitura, desenho e saída de imagens, seguido pela importação do RetinaNet e seus pesos pré-treinados (MS COCO):

from torchvision.io.image import read_image
from torchvision.utils import draw_bounding_boxes
from torchvision.transforms.functional import to_pil_image
from torchvision.models.detection import retinanet_resnet50_fpn_v2, RetinaNet_ResNet50_FPN_V2_Weights

import matplotlib.pyplot as plt

O RetinaNet usa um backbone ResNet50 e uma Feature Pyramid Network (FPN) em cima dele. Embora o nome da classe seja detalhado, é indicativo da arquitetura. Vamos buscar uma imagem usando o requests library e salve-o como um arquivo em nossa unidade local:

import requests
response = requests.get('https://i.ytimg.com/vi/q71MCWAEfL8/maxresdefault.jpg')
open("obj_det.jpeg", "wb").write(response.content)

img = read_image("obj_det.jpeg")

Com uma imagem no lugar – podemos instanciar nosso modelo e pesos:

weights = RetinaNet_ResNet50_FPN_V2_Weights.DEFAULT
model = retinanet_resnet50_fpn_v2(weights=weights, score_thresh=0.35)

model.eval()

preprocess = weights.transforms()

A score_thresh O argumento define o limite no qual um objeto é detectado como um objeto de uma classe. Intuitivamente, é o limite de confiança e não classificaremos um objeto como pertencente a uma classe se o modelo tiver menos de 35% de confiança de que pertence a uma classe.

Vamos pré-processar a imagem usando as transformações de nossos pesos, criar um lote e executar a inferência:

batch = [preprocess(img)]
prediction = model(batch)[0]

É isso, nosso prediction dicionário contém as classes e localizações de objetos inferidos! Agora, os resultados não são muito úteis para nós neste formulário - queremos extrair os rótulos em relação aos metadados dos pesos e desenhar caixas delimitadoras, o que pode ser feito via draw_bounding_boxes():

labels = [weights.meta["categories"][i] for i in prediction["labels"]]

box = draw_bounding_boxes(img, boxes=prediction["boxes"],
                          labels=labels,
                          colors="cyan",
                          width=2, 
                          font_size=30,
                          font='Arial')

im = to_pil_image(box.detach())

fig, ax = plt.subplots(figsize=(16, 12))
ax.imshow(im)
plt.show()

Isto resulta em:

A RetinaNet realmente classificou a pessoa que espiava atrás do carro! Essa é uma classificação bem difícil.

Você pode mudar o RetinaNet para um FCOS (totalmente convolucional RetinaNet) substituindo retinanet_resnet50_fpn_v2 de fcos_resnet50_fpn, E usar o FCOS_ResNet50_FPN_Weights pesos:

from torchvision.io.image import read_image
from torchvision.utils import draw_bounding_boxes
from torchvision.transforms.functional import to_pil_image
from torchvision.models.detection import fcos_resnet50_fpn, FCOS_ResNet50_FPN_Weights

import matplotlib.pyplot as plt
import requests
response = requests.get('https://i.ytimg.com/vi/q71MCWAEfL8/maxresdefault.jpg')
open("obj_det.jpeg", "wb").write(response.content)

img = read_image("obj_det.jpeg")
weights = FCOS_ResNet50_FPN_Weights.DEFAULT
model = fcos_resnet50_fpn(weights=weights, score_thresh=0.35)
model.eval()

preprocess = weights.transforms()
batch = [preprocess(img)]
prediction = model(batch)[0]

labels = [weights.meta["categories"][i] for i in prediction["labels"]]

box = draw_bounding_boxes(img, boxes=prediction["boxes"],
                          labels=labels,
                          colors="cyan",
                          width=2, 
                          font_size=30,
                          font='Arial')

im = to_pil_image(box.detach())

fig, ax = plt.subplots(figsize=(16, 12))
ax.imshow(im)
plt.show()

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

A Detecção de Objetos é um campo importante da Visão Computacional e, infelizmente, menos acessível do que deveria.

Neste pequeno guia, vimos como torchvision, o pacote Computer Vision do PyTorch, facilita a detecção de objetos em imagens, usando o RetinaNet.