Pose Estimation/Keypoint Detection com YOLOv7 em Python

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 Estimativa de pose (Detecção de ponto-chave) em Python, com YOLOv7 de última geração.

Os pontos-chave podem ser vários pontos – partes de um rosto, membros de um corpo, etc. permitir o controle robótico over-the-air e alimentar uma nova era de auto-expressão humana através de AR e VR.

YOLO e estimativa de pose

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), que é o mais recente avanço na metodologia YOLO.

O YOLOv7 não é apenas uma arquitetura de detecção de objetos – 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 não é surpreendente, já que muitas arquiteturas de detecção de objetos foram reaproveitadas para tarefas de segmentação de instância e detecção de ponto-chave anteriormente, devido à arquitetura geral compartilhada, com saídas diferentes dependendo da tarefa. Mesmo que não seja surpreendente – o suporte à segmentação de instâncias e detecção de pontos-chave provavelmente se tornará o novo padrão para modelos baseados em YOLO, que começaram a superar praticamente todos os outros detectores de dois estágios há alguns anos.

Isso torna a segmentação de instâncias e a detecção de pontos-chave mais rápidas do que nunca, com uma arquitetura mais simples do que os detectores de dois estágios.

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

Vamos em frente e instalar o projeto do GitHub:

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

Isso cria um yolov7 diretório em seu diretório de trabalho atual, no qual você poderá encontrar os arquivos básicos do projeto:

%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

Observação: Os notebooks do Google Colab são redefinidos para o diretório de trabalho principal na próxima célula, mesmo após a chamada %cd dirname, portanto, você terá que continuar chamando-o em cada célula em que deseja que uma operação seja executada. Notebooks Jupyter locais lembram da alteração, portanto, não há necessidade de continuar chamando o comando.

Sempre que você executar um código com um determinado conjunto de pesos, eles serão baixados e armazenados neste diretório. Para realizar a estimativa de pose, vamos querer baixar os pesos para o modelo YOLOv7 pré-treinado para essa tarefa, que pode ser encontrado em /releases/download/ guia no GitHub:

! curl -L https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt -o yolov7-w6-pose.pt
%cd ..

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
100  153M  100  153M    0     0  3742k      0  0:00:42  0:00:42 --:--:-- 4573k

/Users/macbookpro/jup

Ótimo, baixamos o yolov7-w6-pose.pt pesos, que pode ser usado para carregar e reconstruir um modelo treinado para estimativa de pose.

Carregando o modelo de estimativa de pose YOLOv7

Vamos importar as bibliotecas que precisaremos para realizar a estimativa de pose:

import torch
from torchvision import transforms

from utils.datasets import letterbox
from utils.general import non_max_suppression_kpt
from utils.plots import output_to_keypoint, plot_skeleton_kpts

import matplotlib.pyplot as plt
import cv2
import numpy as np

torch e torchvision são bastante simples - YOLOv7 é implementado com PyTorch. o utils.datasets, utils.general e utils.plots módulos vêm do projeto YOLOv7 e nos fornecem métodos que ajudam no pré-processamento e preparação de entrada para o modelo executar a inferência. Entre esses estão letterbox() para preencher a imagem, non_max_supression_keypoint() executar o algoritmo Non-Max Supression na saída inicial do modelo e produzir uma saída limpa para nossa interpretação, bem como a output_to_keypoint() e plot_skeleton_kpts() métodos para realmente adicionar pontos-chave a uma determinada imagem, uma vez que eles são previstos.

Podemos carregar o modelo do arquivo de peso com torch.load(). Vamos criar uma função para verificar se uma GPU está disponível, carregar o modelo, colocá-lo em modo de inferência e movê-lo para a GPU se disponível:

def load_model():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model = torch.load('yolov7/yolov7-w6-pose.pt', map_location=device)['model']
    
    model.float().eval()

    if torch.cuda.is_available():
        
        
        model.half().to(device)
    return model

model = load_model()

Com o modelo carregado, vamos criar um run_inference() método que aceita uma string apontando para um arquivo em nosso sistema. O método lerá a imagem usando OpenCV (cv2), preenchê-lo com letterbox(), aplique transformações a ele e transforme-o em um lote (o modelo é treinado e espera lotes, como de costume):

def run_inference(url):
    image = cv2.imread(url) 
    
    image = letterbox(image, 960, stride=64, auto=True)[0] 
    
    image = transforms.ToTensor()(image) 
    
    image = image.unsqueeze(0) 
    output, _ = model(image) 
    return output, image

Aqui, retornamos a imagem transformada (porque queremos extrair a original e plotar nela) e as saídas do modelo. Essas saídas contêm 45900 previsões de pontos-chave, a maioria das quais se sobrepõe. Desejaremos aplicar a supressão não máxima a essas previsões brutas, assim como com as previsões de detecção de objetos (onde muitas caixas delimitadoras são previstas e, em seguida, são "recolhidas" com alguma confiança e limite de IoU). Após a supressão, podemos plotar cada ponto-chave na imagem original e exibi-lo:

def visualize_output(output, image):
    output = non_max_suppression_kpt(output, 
                                     0.25, 
                                     0.65, 
                                     nc=model.yaml['nc'], 
                                     nkpt=model.yaml['nkpt'], 
                                     kpt_label=True)
    with torch.no_grad():
        output = output_to_keypoint(output)
    nimg = image[0].permute(1, 2, 0) * 255
    nimg = nimg.cpu().numpy().astype(np.uint8)
    nimg = cv2.cvtColor(nimg, cv2.COLOR_RGB2BGR)
    for idx in range(output.shape[0]):
        plot_skeleton_kpts(nimg, output[idx, 7:].T, 3)
    plt.figure(figsize=(12, 12))
    plt.axis('off')
    plt.imshow(nimg)
    plt.show()

Agora, para alguma imagem de entrada, como karate.jpg no diretório de trabalho principal, podemos executar a inferência, executar a supressão não máxima e plotar os resultados com:

output, image = run_inference('./karate.jpg')
visualize_output(output, image)

Isto resulta em:

Esta é uma imagem bastante difícil de inferir! A maior parte do braço direito do praticante à direita está escondido, e podemos ver que o modelo inferiu que ele está escondido e à direita do corpo, faltando que o cotovelo esteja dobrado e que uma porção do braço esteja na frente . O praticante à esquerda, que é visto muito mais claramente, é inferido corretamente, mesmo com uma perna escondida.

Na verdade - uma pessoa sentada no fundo, quase totalmente invisível para a câmera teve sua pose aparentemente estimada corretamente, apenas com base na posição dos quadris enquanto está sentado. Ótimo trabalho em nome da rede!

Conclusão

Neste guia – demos uma breve olhada no YOLOv7, o mais recente avanço na família YOLO, que se baseia no YOLOR e fornece ainda recursos de segmentação de instância e detecção de pontos-chave além dos recursos padrão de detecção de objetos da maioria dos modelos baseados em YOLO .

Em seguida, demos uma olhada em como podemos baixar arquivos de peso liberados, carregá-los para construir um modelo e realizar inferência de estimativa de pose para humanos, produzindo resultados impressionantes.

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