Estimación de poses/Detección de puntos clave con YOLOv7 en Python

Introducción

La detección de objetos es un campo amplio en la visión por computadora y una de las aplicaciones más importantes de la visión por computadora "en la naturaleza".

La detección de objetos no está tan estandarizada como la clasificación de imágenes, principalmente porque la mayoría de los nuevos desarrollos generalmente los realizan investigadores, mantenedores y desarrolladores individuales, en lugar de grandes bibliotecas y marcos. Es difícil empaquetar los scripts de utilidades necesarios en un marco como TensorFlow o PyTorch y mantener las pautas de la API que guiaron el desarrollo hasta el momento.

Esto hace que la detección de objetos sea algo más compleja, normalmente más detallada (pero no siempre) y menos accesible que la clasificación de imágenes.

Afortunadamente para las masas, Ultralytics ha desarrollado una API de detección de objetos simple, muy poderosa y hermosa en torno a su YOLOv5 que otros equipos de investigación y desarrollo han ampliado a versiones más nuevas, como YOLOv7.

En esta breve guía, realizaremos la estimación de poses (detección de puntos clave) en Python, con YOLOv7 de última generación.

Los puntos clave pueden ser varios puntos: partes de una cara, extremidades de un cuerpo, etc. La estimación de pose es un caso especial de detección de puntos clave, en el que los puntos son partes de un cuerpo humano y se pueden usar para reemplazar el costoso hardware de seguimiento de posición, habilite el control de la robótica por aire e impulse una nueva era de autoexpresión humana a través de AR y VR.

Estimación de YOLO y Pose

YOLO (Solo se mira una vez) es una metodología, así como una familia de modelos construidos para la detección de objetos. Desde el inicio en 2015, YOLOv1, YOLOv2 (YOLO9000) y YOLOv3 han sido propuestos por los mismos autores, y la comunidad de aprendizaje profundo continuó con avances de código abierto en los años siguientes.

YOLOv5 de ultralíticos es la primera implementación a gran escala de YOLO en PyTorch, lo que lo hizo más accesible que nunca, pero la razón principal por la que YOLOv5 se ha afianzado tanto es también la API maravillosamente simple y poderosa construida a su alrededor. El proyecto abstrae los detalles innecesarios, al tiempo que permite la personalización, prácticamente todos los formatos de exportación utilizables, y emplea prácticas sorprendentes que hacen que todo el proyecto sea eficiente y óptimo.

YOLOv5 sigue siendo el proyecto básico para construir modelos de detección de objetos, y muchos repositorios que apuntan a avanzar en el método YOLO comienzan con YOLOv5 como línea de base y ofrecen una API similar (o simplemente bifurcan el proyecto y construyen sobre él). Tal es el caso de YOLOR (Solo Aprendes Una Representación) y YOLOv7, que se basó en YOLOR (mismo autor), que es el último avance en la metodología YOLO.

YOLOv7 no es solo una arquitectura de detección de objetos: proporciona nuevos cabezales de modelo, que pueden generar puntos clave (esqueletos) y realizar segmentación de instancias además de solo regresión de cuadro delimitador, que no era estándar con los modelos anteriores de YOLO. Esto no es sorprendente, ya que muchas arquitecturas de detección de objetos también se reutilizaron anteriormente para tareas de detección de puntos clave y segmentación de instancias, debido a la arquitectura general compartida, con diferentes salidas según la tarea. Aunque no es sorprendente, es probable que admitir la segmentación de instancias y la detección de puntos clave se conviertan en el nuevo estándar para los modelos basados ​​en YOLO, que comenzaron a superar prácticamente a todos los demás detectores de dos etapas hace un par de años.

Esto hace que la segmentación de instancias y la detección de puntos clave sean más rápidas que nunca, con una arquitectura más simple que los detectores de dos etapas.

El modelo en sí se creó a través de cambios arquitectónicos, además de optimizar aspectos de la capacitación, denominados "bolsa de regalos", que aumentaron la precisión sin aumentar el costo de la inferencia.

Instalando YOLOv7

Sigamos adelante e instalemos el proyecto desde GitHub:

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

Esto crea un yolov7 directorio bajo su directorio de trabajo actual, en el que podrá encontrar los archivos básicos del proyecto:

%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

Nota: Los cuadernos de Google Colab se restablecen al directorio de trabajo principal en la siguiente celda, incluso después de llamar %cd dirname, por lo que tendrá que seguir llamándolo en cada celda en la que desee que se realice una operación. Los cuadernos Jupyter Notebook locales recuerdan el cambio, por lo que no es necesario seguir llamando al comando.

Siempre que ejecute código con un conjunto determinado de pesos, se descargarán y almacenarán en este directorio. Para realizar la estimación de pose, querremos descargar los pesos para el modelo YOLOv7 preentrenado para esa tarea, que se pueden encontrar en el /releases/download/ pestaña en 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

Genial, hemos descargado el yolov7-w6-pose.pt archivo de pesos, que se puede utilizar para cargar y reconstruir un modelo entrenado para la estimación de la pose.

Cargando el modelo de estimación de poses YOLOv7

Importemos las bibliotecas que necesitaremos para realizar la estimación 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 y torchvision son bastante sencillos: YOLOv7 se implementa con PyTorch. los utils.datasets, utils.general y utils.plots Los módulos provienen del proyecto YOLOv7 y nos brindan métodos que ayudan con el preprocesamiento y la preparación de la entrada para que el modelo ejecute la inferencia. Entre esos están letterbox() para rellenar la imagen, non_max_supression_keypoint() para ejecutar el algoritmo de supresión no máxima en la salida inicial del modelo y producir una salida limpia para nuestra interpretación, así como la output_to_keypoint() y plot_skeleton_kpts() métodos para agregar puntos clave a una imagen dada, una vez que se predijeron.

Podemos cargar el modelo desde el archivo de peso con torch.load(). Vamos a crear una función para verificar si hay una GPU disponible, cargar el modelo, ponerlo en modo de inferencia y moverlo a la GPU si está disponible:

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()

Con el modelo cargado, vamos a crear un run_inference() método que acepta una cadena que apunta a un archivo en nuestro sistema. El método leerá la imagen usando OpenCV (cv2), rellénelo con letterbox(), aplique transformaciones y conviértalo en un lote (el modelo está entrenado y espera lotes, como de costumbre):

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

Aquí, hemos devuelto la imagen transformada (porque queremos extraer el original y trazar sobre él) y los resultados del modelo. Estos resultados contienen 45900 predicciones de puntos clave, la mayoría de las cuales se superponen. Querremos aplicar la supresión no máxima a estas predicciones sin procesar, al igual que con las predicciones de detección de objetos (donde se predicen muchos cuadros delimitadores y luego se "colapsan" dada cierta confianza y umbral de IoU). Después de la supresión, podemos trazar cada punto clave en la imagen original y mostrarlo:

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()

Ahora, para alguna imagen de entrada, como karate.jpg en el directorio de trabajo principal, podemos ejecutar la inferencia, realizar la supresión no máxima y trazar los resultados con:

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

Esto resulta en:

¡Esta es una imagen bastante difícil de inferir! La mayor parte del brazo derecho del practicante de la derecha está oculto, y podemos ver que el modelo infirió que está oculto y a la derecha del cuerpo, faltando que el codo esté doblado y que una parte del brazo esté al frente. . El practicante de la izquierda, que se ve mucho más claramente, se infiere correctamente, incluso con una pierna oculta.

De hecho, una persona sentada en la parte de atrás, casi completamente invisible para la cámara ha tenido su pose aparentemente correctamente estimada, solo en función de la posición de las caderas mientras está sentado. Gran trabajo en nombre de la red!

Conclusión

En esta guía, echamos un breve vistazo a YOLOv7, el último avance en la familia YOLO, que se basa en YOLOR y además proporciona segmentación de instancias y capacidades de detección de puntos clave más allá de las capacidades estándar de detección de objetos de la mayoría de los modelos basados ​​en YOLO. .

Luego, analizamos cómo podemos descargar archivos de peso publicados, cargarlos para construir un modelo y realizar inferencias de estimación de postura para humanos, lo que arroja resultados impresionantes.

Yendo más lejos: aprendizaje profundo práctico para la visión por computadora

¿Tu naturaleza inquisitiva te hace querer ir más allá? Recomendamos revisar nuestro Curso: “Aprendizaje Profundo Práctico para Visión por Computador con Python”.

¿Otro curso de visión artificial?

No haremos clasificación de dígitos MNIST o moda MNIST. Cumplieron su parte hace mucho tiempo. Demasiados recursos de aprendizaje se centran en conjuntos de datos básicos y arquitecturas básicas antes de permitir que las arquitecturas avanzadas de caja negra carguen con la carga del rendimiento.

queremos centrarnos en desmitificación, sentido práctico, comprensión, intuición y proyectos reales. Querer aprender cómo ¿Tu puedes hacer la diferencia? Lo llevaremos en un viaje desde la forma en que nuestros cerebros procesan imágenes hasta escribir un clasificador de aprendizaje profundo de grado de investigación para el cáncer de mama y redes de aprendizaje profundo que "alucinan", enseñándole los principios y la teoría a través del trabajo práctico, equipándolo con el conocimientos y herramientas para convertirse en un experto en la aplicación del aprendizaje profundo para resolver la visión artificial.

¿Qué hay adentro?

• Los primeros principios de la visión y cómo se puede enseñar a las computadoras a “ver”
• Diferentes tareas y aplicaciones de la visión artificial
• Las herramientas del oficio que facilitarán tu trabajo
• Encontrar, crear y utilizar conjuntos de datos para la visión por computadora
• La teoría y aplicación de las Redes Neuronales Convolucionales
• Manejo de cambio de dominio, co-ocurrencia y otros sesgos en conjuntos de datos
• Transfiera el aprendizaje y utilice el tiempo de capacitación y los recursos computacionales de otros para su beneficio
• Construyendo y entrenando un clasificador de cáncer de mama de última generación
• Cómo aplicar una buena dosis de escepticismo a las ideas principales y comprender las implicaciones de las técnicas ampliamente adoptadas
• Visualización del "espacio conceptual" de ConvNet usando t-SNE y PCA
• Casos prácticos de cómo las empresas utilizan técnicas de visión artificial para lograr mejores resultados
• Evaluación adecuada del modelo, visualización del espacio latente e identificación de la atención del modelo.
• Realizar investigaciones de dominio, procesar sus propios conjuntos de datos y establecer pruebas modelo
• Arquitecturas de vanguardia, la progresión de las ideas, qué las hace únicas y cómo implementarlas
• KerasCV: una biblioteca WIP para crear canalizaciones y modelos de última generación
• Cómo analizar y leer documentos e implementarlos usted mismo
• Selección de modelos en función de su aplicación
• Creación de una canalización de aprendizaje automático de extremo a extremo
• Panorama e intuición sobre la detección de objetos con Faster R-CNN, RetinaNets, SSD y YOLO
• Instancia y segmentación semántica
• Reconocimiento de objetos en tiempo real con YOLOv5
• Capacitación de detectores de objetos YOLOv5
• Trabajando con Transformers usando KerasNLP (biblioteca WIP de fuerza industrial)
• Integrando Transformers con ConvNets para generar subtítulos de imágenes
• sueño profundo
• Optimización del modelo de Deep Learning para visión artificial