RetinaNet Objekterkennung mit PyTorch und Torchvision

Einleitung

Die Objekterkennung ist ein großes Gebiet der Computer Vision und eine der wichtigeren Anwendungen der Computer Vision „in freier Wildbahn“. Auf der einen Seite kann es verwendet werden, um autonome Systeme zu bauen, die Agenten durch Umgebungen navigieren – seien es Roboter, die Aufgaben ausführen, oder selbstfahrende Autos, aber dies erfordert Schnittmengen mit anderen Feldern. Die Erkennung von Anomalien (z. B. fehlerhafte Produkte in einer Linie), die Lokalisierung von Objekten in Bildern, die Gesichtserkennung und verschiedene andere Anwendungen der Objekterkennung können jedoch durchgeführt werden, ohne andere Felder zu überschneiden.

Die Objekterkennung ist nicht so standardisiert wie die Bildklassifizierung, hauptsächlich weil die meisten neuen Entwicklungen typischerweise von einzelnen Forschern, Betreuern und Entwicklern durchgeführt werden und nicht von großen Bibliotheken und Frameworks. Es ist schwierig, die erforderlichen Hilfsskripte in ein Framework wie TensorFlow oder PyTorch zu packen und die API-Richtlinien einzuhalten, die die Entwicklung bisher geleitet haben.

Dadurch wird die Objekterkennung etwas komplexer, typischerweise ausführlicher (aber nicht immer) und weniger zugänglich als die Bildklassifizierung. Einer der Hauptvorteile eines Ökosystems besteht darin, dass Sie nicht nach nützlichen Informationen zu bewährten Verfahren, Tools und Nutzungsansätzen suchen müssen. Bei der Objekterkennung müssen die meisten viel mehr Recherchen über die Landschaft des Feldes anstellen, um einen guten Griff zu bekommen.

Objekterkennung mit RetinaNet von PyTorch/TorchVision

torchvision ist das Computer Vision-Projekt von PyTorch und zielt darauf ab, die Entwicklung von PyTorch-basierten CV-Modellen zu vereinfachen, indem Transformations- und Erweiterungsskripte, ein Modellzoo mit vortrainierten Gewichtungen, Datensätzen und Dienstprogrammen bereitgestellt werden, die für einen Praktiker nützlich sein können.

Noch in der Beta-Phase und sehr experimentell – torchvision bietet eine relativ einfache Objekterkennungs-API mit einigen Modellen zur Auswahl:

• Schnelleres R-CNN
• RetinaNet
• FCOS (Fully Convolutional RetinaNet)
• SSD (VGG16-Backbone … huch)
• SSDLite (MobileNetV3-Backbone)

Obwohl die API nicht so ausgefeilt oder einfach ist wie einige andere APIs von Drittanbietern, ist sie ein sehr anständiger Ausgangspunkt für diejenigen, die immer noch die Sicherheit bevorzugen, in einem Ökosystem zu sein, mit dem sie vertraut sind. Bevor Sie fortfahren, stellen Sie sicher, dass Sie PyTorch und Torchvision installieren:

$ pip install torch torchvision

Lassen Sie uns einige der Hilfsfunktionen laden, wie z read_image(), draw_bounding_boxes() und to_pil_image() um das Lesen, Zeichnen und Ausgeben von Bildern zu erleichtern, gefolgt vom Importieren von RetinaNet und seinen vortrainierten Gewichten (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 verwendet ein ResNet50-Backbone und darauf ein Feature Pyramid Network (FPN). Während der Name der Klasse ausführlich ist, weist er auf die Architektur hin. Lassen Sie uns ein Bild mit dem abrufen requests Bibliothek und speichern Sie sie als Datei auf unserem lokalen Laufwerk:

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

Wenn ein Bild vorhanden ist, können wir unser Modell und unsere Gewichte instanziieren:

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

model.eval()

preprocess = weights.transforms()

Das score_thresh Argument definiert die Schwelle, bei der ein Objekt als Objekt einer Klasse erkannt wird. Intuitiv ist dies der Konfidenzschwellenwert, und wir klassifizieren ein Objekt nicht als zu einer Klasse gehörend, wenn das Modell zu weniger als 35 % sicher ist, dass es zu einer Klasse gehört.

Lassen Sie uns das Bild mit den Transformationen unserer Gewichtungen vorverarbeiten, einen Stapel erstellen und die Inferenz ausführen:

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

Das ist es, unser prediction Das Wörterbuch enthält die abgeleiteten Objektklassen und -orte! Jetzt sind die Ergebnisse in dieser Form für uns nicht sehr nützlich – wir wollen die Beschriftungen in Bezug auf die Metadaten aus den Gewichtungen extrahieren und Begrenzungsrahmen zeichnen, was über erfolgen kann 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()

Das führt zu:

RetinaNet klassifizierte tatsächlich die Person, die hinter das Auto spähte! Das ist eine ziemlich schwierige Einordnung.

Sie können RetinaNet durch Ersetzen auf ein FCOS (Fully Convolutional RetinaNet) umstellen retinanet_resnet50_fpn_v2 mit fcos_resnet50_fpnund benutze die FCOS_ResNet50_FPN_Weights Gewichte:

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

Weiter gehen – Praktisches Deep Learning für Computer Vision

Ihre neugierige Natur macht Lust auf mehr? Wir empfehlen Ihnen, sich unsere anzuschauen Kurs: „Praxisnahes Deep Learning für Computer Vision mit Python“.

Ein weiterer Computer Vision-Kurs?

Wir werden keine Klassifizierung von MNIST-Ziffern oder MNIST-Mode durchführen. Sie haben ihren Teil vor langer Zeit erfüllt. Zu viele Lernressourcen konzentrieren sich auf grundlegende Datensätze und grundlegende Architekturen, bevor fortgeschrittene Blackbox-Architekturen die Last der Leistung schultern.

Wir wollen uns konzentrieren Entmystifizierung, Praktikabilität, Verständnis, Intuition und echte Projekte. Möchte lernen wie du kannst einen Unterschied machen? Wir nehmen Sie mit auf eine Reise von der Art und Weise, wie unser Gehirn Bilder verarbeitet, über das Schreiben eines forschungstauglichen Deep-Learning-Klassifikators für Brustkrebs bis hin zu Deep-Learning-Netzwerken, die „halluzinieren“, Ihnen die Prinzipien und die Theorie durch praktische Arbeit beibringen und Sie mit dem ausstatten Know-how und Tools, um ein Experte für die Anwendung von Deep Learning zur Lösung von Computer Vision zu werden.

Was ist da drin?

• Die ersten Prinzipien des Sehens und wie Computern das „Sehen“ beigebracht werden kann
• Verschiedene Aufgaben und Anwendungen von Computer Vision
• Das Handwerkszeug, das Ihnen die Arbeit erleichtert
• Suchen, Erstellen und Verwenden von Datensätzen für Computer Vision
• Die Theorie und Anwendung von Convolutional Neural Networks
• Umgang mit Domänenverschiebung, Kookkurrenz und anderen Verzerrungen in Datensätzen
• Übertragen Sie Lernen und nutzen Sie die Trainingszeit und Rechenressourcen anderer zu Ihrem Vorteil
• Aufbau und Schulung eines hochmodernen Brustkrebsklassifikators
• Wie man Mainstream-Ideen mit einer gesunden Portion Skepsis begegnet und die Auswirkungen weit verbreiteter Techniken versteht
• Visualisierung des „Konzeptraums“ eines ConvNet mit t-SNE und PCA
• Fallstudien darüber, wie Unternehmen Computer-Vision-Techniken einsetzen, um bessere Ergebnisse zu erzielen
• Richtige Modellbewertung, Visualisierung des latenten Raums und Identifizierung der Aufmerksamkeit des Modells
• Durchführen von Domänenrecherchen, Bearbeiten eigener Datensätze und Etablieren von Modelltests
• Modernste Architekturen, die Weiterentwicklung von Ideen, was sie einzigartig macht und wie man sie umsetzt
• KerasCV – eine WIP-Bibliothek zum Erstellen hochmoderner Pipelines und Modelle
• Wie man Papiere parst, liest und selbst umsetzt
• Modellauswahl je nach Anwendung
• Erstellen einer End-to-End-Pipeline für maschinelles Lernen
• Landschaft und Intuition zur Objekterkennung mit Faster R-CNNs, RetinaNets, SSDs und YOLO
• Instanz- und semantische Segmentierung
• Objekterkennung in Echtzeit mit YOLOv5
• Training von YOLOv5-Objektdetektoren
• Arbeiten mit Transformers unter Verwendung von KerasNLP (industriestarke WIP-Bibliothek)
• Integrieren von Transformers in ConvNets zum Generieren von Bildunterschriften
• DeepDream

Zusammenfassung

Die Objekterkennung ist ein wichtiges Gebiet der Computer Vision und eines, das leider weniger zugänglich ist, als es sein sollte.

In dieser kurzen Anleitung haben wir uns angesehen, wie torchvision, das Computer Vision-Paket von PyTorch, erleichtert die Objekterkennung auf Bildern mithilfe von RetinaNet.