3D-objectdetectie (3D-begrenzingsvakken) in Python met MediaPipe Objectron

Introductie

Objectdetectie wint aan kracht en er worden verbeteringen aangebracht in verschillende benaderingen om dit op te lossen. In de afgelopen jaren hebben op YOLO gebaseerde methoden beter gepresteerd dan andere in termen van nauwkeurigheid en snelheid, met recente ontwikkelingen zoals YOLOv7 en YOLOv6 (die onafhankelijk werden uitgebracht, na YOLOv7).

Maar – al deze zijn zorgwekkend 2D-objectdetectie, wat op zich al een moeilijke opgave is. Onlangs hebben we met succes kunnen optreden 3D-objectdetectie, en hoewel deze detectoren zich nog steeds in een onstabieler stadium bevinden dan 2D-objectdetectoren, neemt hun nauwkeurigheid toe.

In deze handleiding zullen we 3D-objectdetectie in Python uitvoeren met MediaPipe's Objectron.

Opmerking: MediaPipe is het open source-framework van Google voor het bouwen van pijplijnen voor machine learning om afbeeldingen, video's en audiostreams te verwerken, voornamelijk voor mobiele apparaten. Het wordt zowel intern als extern gebruikt en biedt vooraf getrainde modellen voor verschillende taken, zoals gezichtsdetectie, gezichtsmeshing, hand- en poseschatting, haarsegmentatie, objectdetectie, boxtracking, enz.

Al deze kunnen en worden gebruikt voor downstream-taken, zoals het toepassen van filters op gezichten, geautomatiseerde camerafocus, biometrische verificatie, handgestuurde robotica, enz. De meeste projecten zijn beschikbaar met API's voor Android, iOS, C++, Python en JavaScript, terwijl sommige zijn alleen beschikbaar voor bepaalde talen.

In deze handleiding werken we met Objectron van MediaPipe, beschikbaar voor Android, C++, Python en JavaScript.

MediaPipe en 3D-objectdetectie

De bezwaar oplossing werd getraind op de Objectron-gegevensset, die korte objectgerichte video's bevat. De dataset bevat slechts 9 objecten: fietsen, boeken, flessen, camera's, cornflakesdozen, stoelen, bekers, laptops en schoenen, dus het is geen erg algemene dataset, maar de verwerking en aanschaf van deze video's is vrij duur (camerahoudingen, schaars puntenwolken, karakterisering van de vlakke oppervlakken, enz. voor elk frame van elke video), waardoor de dataset bijna 2 terrabytes groot is.

Het getrainde Objectron-model (bekend als a oplossing voor MediaPipe-projecten) wordt getraind in vier categorieën: schoenen, stoelen, mokken en camera's.

2D-objectdetectie gebruikt de term "begrenzingsvakken", terwijl het eigenlijk rechthoeken zijn. 3D-objectdetectie voorspelt eigenlijk dozen rond objecten, waaruit je hun oriëntatie, grootte, ruw volume, enz. kunt afleiden. Dit is een vrij moeilijke taak, vooral gezien het gebrek aan geschikte datasets en de kosten om ze te maken. Hoewel moeilijk, is het probleem veelbelovend voor verschillende Augmented reality (AR) toepassingen!

De Objectron-oplossing kan worden uitgevoerd in een eentraps- of tweetrapsmodus, waarbij de eentrapsmodus beter is in het detecteren van meerdere objecten, terwijl de tweetrapsmodus beter is in het detecteren van een enkel hoofdobject in de scène, en aanzienlijk werkt sneller. De pijplijn met één fase maakt gebruik van een MobileNetV2-backbone, terwijl de pijplijn met twee fasen de TensorFlow Object Detection API gebruikt.

Wanneer een object in een video wordt gedetecteerd, worden er om twee redenen geen verdere voorspellingen voor elk frame gedaan:

• Continue voorspellingen introduceren hoge zenuwachtigheid (vanwege de inherente stochasticiteit in de voorspellingen)
• Het is duur om grote modellen op elk frame te gebruiken

Het team verplaatst de zware voorspellingen naar alleen de eerste ontmoetingen en volgt vervolgens die doos zolang het betreffende object zich nog in de scene bevindt. Zodra de zichtlijn is verbroken en het object opnieuw wordt geïntroduceerd, wordt er opnieuw een voorspelling gedaan. Dit maakt het mogelijk om grotere modellen met een hogere nauwkeurigheid te gebruiken, terwijl de rekenvereisten laag blijven en de hardwarevereisten voor real-time gevolgtrekking worden verlaagd!

Laten we doorgaan en MediaPipe installeren, de Objectron-oplossing importeren en toepassen op statische afbeeldingen en een videofeed die rechtstreeks van een camera komt.

MediaPipe installeren

Laten we eerst MediaPipe installeren en een hulpmethode voorbereiden om afbeeldingen van een bepaalde URL op te halen:

! pip install mediapipe

Laten we, nu het framework is geïnstalleerd, het importeren naast gewone bibliotheken:

import mediapipe as mp

import cv2
import numpy as np
import matplotlib.pyplot as plt

Laten we een hulpmethode definiëren om afbeeldingen op te halen met een URL en die een RGB-array retourneert die die afbeelding vertegenwoordigt:

import PIL
import urllib

def url_to_array(url):
    req = urllib.request.urlopen(url)
    arr = np.array(bytearray(req.read()), dtype=np.int8)
    arr = cv2.imdecode(arr, -1)
    arr = cv2.cvtColor(arr, cv2.COLOR_BGR2RGB)
    return arr

mug = 'https://goodstock.photos/wp-content/uploads/2018/01/Laptop-Coffee-Mug-on-Table.jpg'
mug = url_to_array(mug)

Ten slotte willen we zowel de Objectron-oplossing als de tekenhulpprogramma's importeren om voorspellingen te visualiseren:

mp_objectron = mp.solutions.objectron
mp_drawing = mp.solutions.drawing_utils

3D-objectdetectie op statische afbeeldingen met MediaPipe

De Objectron class laat verschillende argumenten toe, waaronder:

• static_image_mode: Of u nu een afbeelding invoert of een stroom afbeeldingen (video)
• max_num_objects: Het maximaal identificeerbare aantal objecten
• min_detection_confidence: De detectiebetrouwbaarheidsdrempel (hoe zeker moet het netwerk zijn om een ​​object voor de gegeven klasse te classificeren)
• model_name: Welk model je ertussen wilt laden 'Cup', 'Shoe', 'Camera' en 'Chair'.

Met dat in gedachten - laten we een Objectron-instantie instantiëren en process() de invoerafbeelding:

objectron = mp_objectron.Objectron(
    static_image_mode=True,
    max_num_objects=5,
    min_detection_confidence=0.2,
    model_name='Cup')


results = objectron.process(mug)

De results bevatten de 2D- en 3D-oriëntatiepunten van het/de gedetecteerde object(en), evenals de rotatie, translatie en schaal voor elk. We kunnen de resultaten verwerken en de begrenzingsvakken vrij eenvoudig tekenen met behulp van de meegeleverde tekenhulpmiddelen:

if not results.detected_objects:
    print(f'No box landmarks detected.')


annotated_image = mug.copy()
for detected_object in results.detected_objects:
    
    mp_drawing.draw_landmarks(annotated_image, 
                              detected_object.landmarks_2d, 
                              mp_objectron.BOX_CONNECTIONS)

    
    mp_drawing.draw_axis(annotated_image, 
                         detected_object.rotation, 
                         detected_object.translation)
  

fig, ax = plt.subplots(figsize=(10, 10))
ax.imshow(annotated_image)
ax.axis('off')
plt.show()

Dit resulteert in:

3D-objectdetectie van video of webcam met MediaPipe

Een meer opwindende toepassing is op video's! U hoeft de code niet veel te wijzigen om video's te kunnen opnemen, of u er nu een van de webcam of een bestaand videobestand levert. OpenCV past perfect bij het lezen, manipuleren en invoeren van videoframes in het objectron-model:

cap = cv2.VideoCapture(0)



objectron = mp_objectron.Objectron(static_image_mode=False,
                            max_num_objects=5,
                            min_detection_confidence=0.4,
                            min_tracking_confidence=0.70,
                            model_name='Cup')
                            

while cap.isOpened():
    success, image = cap.read()

    image.flags.writeable = False
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    results = objectron.process(image)

    image.flags.writeable = True
    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
    if results.detected_objects:
        for detected_object in results.detected_objects:
            
            mp_drawing.draw_landmarks(image, 
                                      detected_object.landmarks_2d, 
                                      mp_objectron.BOX_CONNECTIONS)
            
            mp_drawing.draw_axis(image, 
                                 detected_object.rotation,
                                 detected_object.translation)

    cv2.imshow('MediaPipe Objectron', cv2.flip(image, 1))
    if cv2.waitKey(10) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

De afbeelding onbeschrijfbaar maken met image.flags.writeable = False zorgt ervoor dat het proces iets sneller verloopt en is een optionele wijziging. De laatste cv2.flip() op de resulterende afbeelding is ook optioneel - en maakt de uitvoer eenvoudig gespiegeld om het een beetje intuïtiever te maken.

Wanneer het op een camera en een wereldwijd gebruikelijke Ikea-mok wordt uitgevoerd, zijn dit de resultaten:

De uitvoer is enigszins zenuwachtig, maar kan de rotatievertaling goed aan, zelfs met een trillende hand die de camera met lage resolutie vasthoudt. Wat gebeurt er als een object uit het frame wordt gehaald?

De voorspellingen voor het object stoppen bij de eerste detectie, en het volgen van de doos pikt duidelijk op dat het object het frame heeft verlaten, en voert de voorspelling en tracking opnieuw uit zodra het object het frame weer binnenkomt. Het lijkt erop dat de tracking iets beter werkt als het model de kan zien mok handvat, omdat de uitgangen zenuwachtiger zijn wanneer het handvat niet zichtbaar is (vermoedelijk omdat het moeilijker is om de ware oriëntatie van de mok nauwkeurig vast te stellen).

Bovendien lijken sommige hoeken aanzienlijk stabielere outputs te produceren dan andere, in uitdagende lichtomstandigheden. Met name voor mokken helpt het om de lip van de mok te kunnen zien omdat dit helpt bij het perspectief, in plaats van een orthogonale projectie van het object te zien.

Bovendien had het model bij het testen op een transparante mok moeite om vast te stellen of het een mok was. Dit is waarschijnlijk een voorbeeld van een uit distributie object, aangezien de meeste mokken ondoorzichtig zijn en verschillende kleuren hebben.

Conclusie

3D-objectdetectie is nog wat jong, en MediaPipe's Objectron is een capabele demonstratie! Hoewel het gevoelig is voor lichtomstandigheden, objecttypes (transparante versus ondoorzichtige mokken, enz.) en enigszins zenuwachtig, geeft Objectron een goed beeld van wat binnenkort mogelijk zal zijn met een grotere nauwkeurigheid en toegankelijkheid dan ooit tevoren.