Objectdetectie-inferentie in Python met YOLOv5 en PyTorch

Introductie

Objectdetectie is een groot gebied in computervisie en een van de belangrijkste toepassingen van computervisie "in het wild". Aan de ene kant kan het worden gebruikt om autonome systemen te bouwen die agenten door omgevingen navigeren - of het nu robots zijn die taken uitvoeren of zelfrijdende auto's, maar dit vereist kruising met andere velden. Anomaliedetectie (zoals defecte producten op een lijn), het lokaliseren van objecten in afbeeldingen, gezichtsdetectie en verschillende andere toepassingen van objectdetectie kunnen echter worden uitgevoerd zonder andere velden te kruisen.

Objectdetectie is niet zo gestandaardiseerd als beeldclassificatie, vooral omdat de meeste nieuwe ontwikkelingen doorgaans worden gedaan door individuele onderzoekers, beheerders en ontwikkelaars, in plaats van door grote bibliotheken en frameworks. Het is moeilijk om de benodigde hulpprogrammascripts in een framework als TensorFlow of PyTorch te verpakken en de API-richtlijnen te handhaven die de ontwikkeling tot dusver hebben geleid.

Dit maakt objectdetectie iets complexer, doorgaans uitgebreider (maar niet altijd) en minder benaderbaar dan beeldclassificatie. Een van de belangrijkste voordelen van deel uitmaken van een ecosysteem is dat het je een manier biedt om niet te zoeken naar nuttige informatie over goede praktijken, tools en benaderingen om te gebruiken. Met objectdetectie moeten de meeste mensen veel meer onderzoek doen naar het landschap van het veld om een ​​goede grip te krijgen.

Gelukkig voor de massa - Ultralytics heeft een eenvoudige, zeer krachtige en mooie objectdetectie-API ontwikkeld rond hun YOLOv5-implementatie.

In deze korte handleiding voeren we objectdetectie uit in Python, met YOLOv5 gebouwd door Ultralytics in PyTorch, met behulp van een set vooraf getrainde gewichten die zijn getraind op MS COCO.

YOLOv5

YOLO (je kijkt maar één keer) is een methodologie, evenals een familie van modellen die zijn gebouwd voor objectdetectie. Sinds de oprichting in 2015 zijn YOLOv1, YOLOv2 (YOLO9000) en YOLOv3 voorgesteld door dezelfde auteur(s) - en de deep learning-gemeenschap ging door met open source-ontwikkelingen in de daaropvolgende jaren.

YOLov5 . van ultralytica is de eerste grootschalige implementatie van YOLO in PyTorch, waardoor het toegankelijker is dan ooit tevoren, maar de belangrijkste reden waarom YOLOv5 zo'n voet aan de grond heeft gekregen, is ook de prachtig eenvoudige en krachtige API die eromheen is gebouwd. Het project abstraheert de onnodige details, terwijl het aanpasbaarheid mogelijk maakt, praktisch alle bruikbare exportformaten, en maakt gebruik van verbazingwekkende praktijken die het hele project zowel efficiënt als optimaal maken. Echt, het is een voorbeeld van de schoonheid van open source software-implementatie en hoe het de wereld waarin we leven aandrijft.

Het project biedt vooraf getrainde gewichten op MS COCO, een nietje dataset over objecten in context, die kan worden gebruikt om zowel algemene objectdetectiesystemen te benchmarken als te bouwen - maar vooral, kan worden gebruikt om algemene kennis van objecten in context over te dragen naar aangepaste gegevenssets.

Objectdetectie met YOLOv5

Zorg ervoor dat u, voordat u verder gaat, torch en torchvision geïnstalleerd:

! python -m pip install torch torchvision

YOLOv5 heeft gedetailleerde, no-nonsense documentatie en een prachtig eenvoudige API, zoals getoond op de repo zelf, en in het volgende voorbeeld:

import torch

model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
img = 'https://i.ytimg.com/vi/q71MCWAEfL8/maxresdefault.jpg'  
results = model(img)
fig, ax = plt.subplots(figsize=(16, 12))
ax.imshow(results.render()[0])
plt.show()

Het tweede argument van de hub.load() methode specificeert de gewichten die we willen gebruiken. Door ergens tussen te kiezen: yolov5n naar yolov5l6 – we laden de voorgetrainde gewichten van MS COCO in. Voor aangepaste modellen:

model = torch.hub.load('ultralytics/yolov5', 'custom', path='path_to_weights.pt')

In ieder geval - zodra u de invoer door het model hebt geleid, bevat het geretourneerde object handige methoden om de resultaten te interpreteren, en we hebben ervoor gekozen om render() hen, wat een NumPy-array retourneert die we in een kunnen stoppen imshow() telefoongesprek. Dit resulteert in een mooi opgemaakt:

Resultaten opslaan als bestanden

U kunt de resultaten van de gevolgtrekking opslaan als een bestand, met behulp van de results.save() methode:

results.save(save_dir='results')

Hiermee wordt een nieuwe map gemaakt als deze nog niet aanwezig is, en wordt dezelfde afbeelding die we zojuist hebben geplot als een bestand opgeslagen.

Objecten uitsnijden

U kunt er ook voor kiezen om de gedetecteerde objecten als afzonderlijke bestanden uit te snijden. In ons geval kunnen voor elk gedetecteerd label een aantal afbeeldingen worden geëxtraheerd. Dit wordt eenvoudig bereikt via de results.crop() methode, die een runs/detect/ map, met expN/crops (waarbij N toeneemt voor elke run), waarin voor elk label een map met bijgesneden afbeeldingen wordt gemaakt:

results.crop()

Saved 1 image to runs/detect/exp2
Saved results to runs/detect/exp2

[{'box': [tensor(295.09409),
   tensor(277.03699),
   tensor(514.16113),
   tensor(494.83691)],
  'conf': tensor(0.25112),
  'cls': tensor(0.),
  'label': 'person 0.25',
  'im': array([[[167, 186, 165],
          [174, 184, 167],
          [173, 184, 164],

U kunt de structuur van het uitvoerbestand ook controleren met:

! ls runs/detect/exp2/crops


! ls runs/detect/exp2/crops

Objecten tellen

Standaard, wanneer u detectie uitvoert of afdrukt, results object - je krijgt het aantal afbeeldingen waarop de inferentie daarvoor is uitgevoerd results object (YOLOv5 werkt ook met batches afbeeldingen), de resolutie en het aantal gedetecteerde labels:

print(results)

Dit resulteert in:

image 1/1: 720x1280 14 persons, 1 car, 3 buss, 6 traffic lights, 1 backpack, 1 umbrella, 1 handbag
Speed: 35.0ms pre-process, 256.2ms inference, 0.7ms NMS per image at shape (1, 3, 384, 640)

Inferentie met scripts

Als alternatief kunt u het detectiescript uitvoeren, detect.py, door de YOLOv5-repository te klonen:

$ git clone https://github.com/ultralytics/yolov5 
$ cd yolov5
$ pip install -r requirements.txt

En dan rennen:

$ python detect.py --source img.jpg

Als alternatief kunt u een URL, een videobestand, een pad naar een map met meerdere bestanden, een glob in een pad dat alleen overeenkomt met bepaalde bestanden, een YouTube-link of een andere HTTP-stream opgeven. De resultaten worden opgeslagen in de runs/detect directory.

Verder gaan - Praktisch diep leren voor computervisie

Je leergierige karakter maakt dat je verder wilt gaan? We raden aan om onze Type cursus: "Praktisch diep leren voor computervisie met Python".

Nog een cursus computervisie?

We zullen geen classificatie van MNIST-cijfers of MNIST-mode doen. Ze hebben lang geleden hun deel gediend. Te veel leermiddelen zijn gericht op basisgegevenssets en basisarchitecturen voordat geavanceerde black-box-architecturen de last van de prestaties op zich nemen.

We willen ons concentreren op demystificatie, uitvoerbaarheid, begrip, intuïtie en echte projecten. Willen leren hoe je kan een verschil maken? We nemen je mee op een reis van de manier waarop onze hersenen afbeeldingen verwerken tot het schrijven van een onderzoeksclassificatie voor diep leren voor borstkanker tot diepgaande leernetwerken die 'hallucineren', je de principes en theorie leren door middel van praktisch werk, en je uitrusten met de knowhow en tools om een ​​expert te worden in het toepassen van deep learning om computervisie op te lossen.

Wat zit erin?

• De eerste principes van visie en hoe computers kunnen worden geleerd om te "zien"
• Verschillende taken en toepassingen van computervisie
• De tools van het vak die uw werk gemakkelijker maken
• Datasets zoeken, maken en gebruiken voor computervisie
• De theorie en toepassing van convolutionele neurale netwerken
• Omgaan met domeinverschuiving, gelijktijdig voorkomen en andere vooroordelen in datasets
• Overdragen Leren en de trainingstijd en computerbronnen van anderen gebruiken in uw voordeel
• Het bouwen en trainen van een state-of-the-art classifier voor borstkanker
• Hoe je een gezonde dosis scepsis toepast op mainstream ideeën en de implicaties begrijpt van algemeen aanvaarde technieken?
• De "conceptruimte" van een ConvNet visualiseren met t-SNE en PCA
• Casestudy's van hoe bedrijven computervisietechnieken gebruiken om betere resultaten te behalen
• Correcte modelevaluatie, visualisatie van de latente ruimte en het identificeren van de aandacht van het model
• Domeinonderzoek doen, eigen datasets verwerken en modeltesten opzetten
• Geavanceerde architecturen, de voortgang van ideeën, wat ze uniek maakt en hoe ze te implementeren
• KerasCV – een WIP-bibliotheek voor het maken van ultramoderne pijplijnen en modellen
• Hoe papers te ontleden en te lezen en ze zelf te implementeren?
• Modellen selecteren afhankelijk van uw toepassing
• Een end-to-end machine learning-pijplijn maken
• Landschap en intuïtie bij objectdetectie met snellere R-CNN's, RetinaNets, SSD's en YOLO
• Instantie en semantische segmentatie
• Realtime objectherkenning met YOLOv5
• YOLOv5-objectdetectoren trainen
• Werken met Transformers met KerasNLP (industriële WIP-bibliotheek)
• Transformers integreren met ConvNets om bijschriften van afbeeldingen te genereren
• DeepDream

Conclusie

In deze korte handleiding hebben we bekeken hoe u objectdetectie kunt uitvoeren met YOLOv5 gebouwd met PyTorch.