Detección de objetos RetinaNet con PyTorch y torchvision

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". Por un lado, se puede usar para construir sistemas autónomos que guíen a los agentes a través de los entornos, ya sean robots que realizan tareas o automóviles autónomos, pero esto requiere la intersección con otros campos. Sin embargo, la detección de anomalías (como productos defectuosos en una línea), la ubicación de objetos dentro de las imágenes, la detección facial y varias otras aplicaciones de detección de objetos se pueden realizar sin cruzar otros campos.

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. Uno de los principales beneficios de estar en un ecosistema es que le brinda una forma de no buscar información útil sobre buenas prácticas, herramientas y enfoques para usar. Con la detección de objetos, la mayoría tiene que investigar mucho más en el paisaje del campo para obtener un buen agarre.

Detección de objetos con RetinaNet de PyTorch/TorchVision

torchvision es el proyecto Computer Vision de PyTorch y tiene como objetivo facilitar el desarrollo de modelos CV basados ​​en PyTorch, al proporcionar scripts de transformación y aumento, un zoológico modelo con pesos, conjuntos de datos y utilidades preentrenados que pueden ser útiles para un profesional.

Mientras todavía está en beta y es muy experimental: torchvision ofrece una API de detección de objetos relativamente simple con algunos modelos para elegir:

• R-CNN más rápido
• RetinaNet
• FCOS (RetinaNet totalmente convolucional)
• SSD (red troncal VGG16... ¡vaya!)
• SSDLite (red troncal MobileNetV3)

Si bien la API no es tan pulida o simple como otras API de terceros, es un punto de partida muy decente para aquellos que aún prefieren la seguridad de estar en un ecosistema con el que están familiarizados. Antes de continuar, asegúrese de instalar PyTorch y Torchvision:

$ pip install torch torchvision

Carguemos algunas de las funciones de utilidad, como read_image(), draw_bounding_boxes() y to_pil_image() para facilitar la lectura, el dibujo y la salida de imágenes, seguido de la importación de RetinaNet y sus pesos preentrenados (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

RetinaNet utiliza una red troncal ResNet50 y una red piramidal de funciones (FPN) encima. Si bien el nombre de la clase es detallado, es indicativo de la arquitectura. Vamos a buscar una imagen usando el requests biblioteca y guárdelo como un archivo en nuestra unidad 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")

Con una imagen en su lugar, podemos instanciar nuestro modelo y pesos:

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

model.eval()

preprocess = weights.transforms()

El score_thresh El argumento define el umbral en el que se detecta un objeto como objeto de una clase. Intuitivamente, es el umbral de confianza, y no clasificaremos un objeto para que pertenezca a una clase si el modelo tiene menos del 35 % de confianza en que pertenece a una clase.

Preprocesemos la imagen usando las transformaciones de nuestros pesos, creemos un lote y ejecutemos la inferencia:

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

Eso es todo, nuestro prediction ¡El diccionario contiene las clases y ubicaciones de objetos inferidas! Ahora, los resultados no son muy útiles para nosotros en este formulario: querremos extraer las etiquetas con respecto a los metadatos de los pesos y dibujar cuadros delimitadores, lo que se puede hacer a través de 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()

Esto resulta en:

¡RetinaNet en realidad clasificó a la persona que se asomaba detrás del auto! Esa es una clasificación bastante difícil.

Puede cambiar RetinaNet a un FCOS (RetinaNet totalmente convolucional) reemplazando retinanet_resnet50_fpn_v2 fcos_resnet50_fpn, Y utilizar el 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()

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

Conclusión

La detección de objetos es un campo importante de la visión artificial y, lamentablemente, es menos accesible de lo que debería ser.

En esta breve guía, hemos echado un vistazo a cómo torchvision, el paquete Computer Vision de PyTorch, facilita la detección de objetos en las imágenes mediante RetinaNet.