Détection d'objets RetinaNet avec PyTorch et torchvision

Introduction

La détection d'objets est un vaste domaine de la vision par ordinateur et l'une des applications les plus importantes de la vision par ordinateur "dans la nature". D'un côté, il peut être utilisé pour construire des systèmes autonomes qui guident les agents dans des environnements - qu'il s'agisse de robots effectuant des tâches ou de voitures autonomes, mais cela nécessite une intersection avec d'autres domaines. Cependant, la détection d'anomalies (telles que des produits défectueux sur une ligne), la localisation d'objets dans des images, la détection faciale et diverses autres applications de détection d'objets peuvent être effectuées sans recouper d'autres champs.

La détection d'objets n'est pas aussi standardisée que la classification d'images, principalement parce que la plupart des nouveaux développements sont généralement réalisés par des chercheurs, des mainteneurs et des développeurs individuels, plutôt que par de grandes bibliothèques et frameworks. Il est difficile de regrouper les scripts utilitaires nécessaires dans un cadre tel que TensorFlow ou PyTorch et de maintenir les directives de l'API qui ont guidé le développement jusqu'à présent.

Cela rend la détection d'objets un peu plus complexe, généralement plus détaillée (mais pas toujours) et moins accessible que la classification d'images. L'un des principaux avantages d'être dans un écosystème est qu'il vous permet de ne pas rechercher d'informations utiles sur les bonnes pratiques, les outils et les approches à utiliser. Avec la détection d'objets, la plupart doivent faire beaucoup plus de recherches sur le paysage du terrain pour avoir une bonne prise en main.

Détection d'objets avec RetinaNet de PyTorch/TorchVision

torchvision est le projet Computer Vision de PyTorch, et vise à faciliter le développement de modèles de CV basés sur PyTorch, en fournissant des scripts de transformation et d'augmentation, un zoo de modèles avec des poids, des ensembles de données et des utilitaires pré-formés qui peuvent être utiles pour un praticien.

Alors qu'il était encore en version bêta et très expérimental - torchvision propose une API de détection d'objets relativement simple avec quelques modèles parmi lesquels choisir :

• R-CNN plus rapide
• RétineNet
• FCOS (RetinaNet entièrement convolutionnel)
• SSD (backbone VGG16… beurk)
• SSDLite (dorsale MobileNetV3)

Bien que l'API ne soit pas aussi raffinée ou simple que certaines autres API tierces, c'est un point de départ très décent pour ceux qui préfèrent toujours la sécurité d'être dans un écosystème qu'ils connaissent. Avant de continuer, assurez-vous d'avoir installé PyTorch et Torchvision :

$ pip install torch torchvision

Chargeons certaines des fonctions utilitaires, telles que read_image(), draw_bounding_boxes() ainsi que to_pil_image() pour faciliter la lecture, le dessin et la sortie d'images, suivi de l'importation de RetinaNet et de ses poids pré-formés (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 utilise une dorsale ResNet50 et un réseau pyramidal de fonctionnalités (FPN) au-dessus. Bien que le nom de la classe soit verbeux, il est indicatif de l'architecture. Récupérons une image en utilisant le requests bibliothèque et enregistrez-le sous forme de fichier sur notre disque 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")

Avec une image en place, nous pouvons instancier notre modèle et nos pondérations :

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

model.eval()

preprocess = weights.transforms()

Les score_thresh L'argument définit le seuil auquel un objet est détecté en tant qu'objet d'une classe. Intuitivement, c'est le seuil de confiance, et nous ne classerons pas un objet comme appartenant à une classe si le modèle est sûr à moins de 35 % qu'il appartient à une classe.

Prétraitons l'image en utilisant les transformations de nos poids, créons un lot et exécutons l'inférence :

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

Ça y est, notre prediction dictionnaire contient les classes d'objets et les emplacements inférés ! Maintenant, les résultats ne nous sont pas très utiles sous cette forme - nous voudrons extraire les étiquettes en ce qui concerne les métadonnées des poids et dessiner des cadres de délimitation, ce qui peut être fait 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()

Cela se traduit par:

RetinaNet a en fait classé la personne qui regardait derrière la voiture ! C'est une classification assez difficile.

Vous pouvez passer de RetinaNet à un FCOS (RetinaNet entièrement convolutionnel) en remplaçant retinanet_resnet50_fpn_v2 comprenant fcos_resnet50_fpn, et utilisez le FCOS_ResNet50_FPN_Weights poids :

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

Aller plus loin - Apprentissage profond pratique pour la vision par ordinateur

Votre nature curieuse vous donne envie d'aller plus loin ? Nous vous recommandons de consulter notre Cours: "Apprentissage profond pratique pour la vision par ordinateur avec Python".

Un autre cours de vision par ordinateur ?

Nous ne ferons pas de classification des chiffres MNIST ou de la mode MNIST. Ils ont fait leur part il y a longtemps. Trop de ressources d'apprentissage se concentrent sur les ensembles de données de base et les architectures de base avant de laisser les architectures de boîte noire avancées assumer le fardeau des performances.

Nous voulons nous concentrer sur démystification, pratique, compréhension, intuition ainsi que de vrais projets. Vouloir apprendre how tu peux faire la différence? Nous vous emmènerons dans un voyage de la façon dont notre cerveau traite les images à l'écriture d'un classificateur d'apprentissage en profondeur de qualité recherche pour le cancer du sein aux réseaux d'apprentissage en profondeur qui "hallucinent", vous enseignant les principes et la théorie par le biais de travaux pratiques, vous équipant du savoir-faire et outils pour devenir un expert dans l'application de l'apprentissage profond pour résoudre la vision par ordinateur.

Qu'est-ce qu'il y a à l'intérieur?

• Les premiers principes de la vision et comment apprendre aux ordinateurs à « voir »
• Différentes tâches et applications de la vision par ordinateur
• Les outils du métier qui faciliteront votre travail
• Trouver, créer et utiliser des ensembles de données pour la vision par ordinateur
• La théorie et l'application des réseaux de neurones convolutifs
• Gestion du changement de domaine, de la cooccurrence et d'autres biais dans les ensembles de données
• Transférer Apprendre et utiliser le temps de formation et les ressources informatiques des autres à votre avantage
• Construire et former un classificateur de pointe du cancer du sein
• Comment appliquer une bonne dose de scepticisme aux idées dominantes et comprendre les implications des techniques largement adoptées
• Visualiser « l'espace conceptuel » d'un ConvNet à l'aide de t-SNE et PCA
• Études de cas sur la façon dont les entreprises utilisent les techniques de vision par ordinateur pour obtenir de meilleurs résultats
• Évaluation appropriée du modèle, visualisation de l'espace latent et identification de l'attention du modèle
• Effectuer des recherches de domaine, traiter vos propres ensembles de données et établir des tests de modèles
• Les architectures de pointe, la progression des idées, ce qui les rend uniques et comment les mettre en œuvre
• KerasCV - une bibliothèque WIP pour créer des pipelines et des modèles de pointe
• Comment analyser et lire des articles et les mettre en œuvre vous-même
• Sélection de modèles en fonction de votre application
• Création d'un pipeline d'apprentissage automatique de bout en bout
• Paysage et intuition sur la détection d'objets avec Faster R-CNN, RetinaNets, SSD et YOLO
• Instance et segmentation sémantique
• Reconnaissance d'objets en temps réel avec YOLOv5
• Formation aux détecteurs d'objets YOLOv5
• Travailler avec des transformateurs à l'aide de KerasNLP (bibliothèque WIP de pointe)
• Intégration de Transformers avec ConvNets pour générer des légendes d'images
• Rêve profond

Conclusion

La détection d'objets est un domaine important de la vision par ordinateur, et malheureusement moins accessible qu'il ne devrait l'être.

Dans ce petit guide, nous avons vu comment torchvision, le package Computer Vision de PyTorch, facilite la détection d'objets sur les images à l'aide de RetinaNet.