3D Object Detection (3D Bounding Boxes) i Python med MediaPipe Objectron

Beskrivning

Objektdetektering har fått fart och förbättringar görs på flera sätt att lösa det. Under de senaste åren har YOLO-baserade metoder överträffat andra när det gäller noggrannhet och hastighet, med nya framsteg som YOLOv7 och YOLOv6 (som släpptes oberoende, efter YOLOv7).

Men alla dessa är oroande 2D-objektdetektering, vilket är en svår uppgift i och för sig. Nyligen har vi kunnat prestera framgångsrikt 3D-objektdetektering, och medan dessa detektorer fortfarande befinner sig i ett mer instabilt stadium än 2D-objektdetektorer, ökar deras noggrannhet.

I den här guiden kommer vi att utföra 3D-objektdetektering i Python med MediaPipes Objectron.

Notera: MediaPipe är Googles ramverk med öppen källkod för att bygga pipelines för maskininlärning för att bearbeta bilder, videor och ljudströmmar, främst för mobila enheter. Den används både internt och externt och tillhandahåller förutbildade modeller för olika uppgifter, såsom ansiktsdetektering, ansiktsmaskning, hand- och poseuppskattning, hårsegmentering, objektdetektering, boxspårning, etc.

Alla dessa kan och används för nedströmsuppgifter – som att applicera filter på ansikten, automatisk kamerafokusering, biometrisk verifiering, handkontrollerad robotik, etc. De flesta projekt är tillgängliga med API:er för Android, iOS, C++, Python och JavaScript, medan vissa är bara tillgängliga för vissa språk.

I den här guiden kommer vi att arbeta med MediaPipes Objectron, tillgänglig för Android, C++, Python och JavaScript.

MediaPipe och 3D-objektdetektion

Smakämnen Objectron lösning tränades på Objectron Dataset, som innehåller korta objektcentrerade videor. Datauppsättningen innehåller bara 9 objekt: cyklar, böcker, flaskor, kameror, flingslådor, stolar, koppar, bärbara datorer och skor, så det är inte en väldigt allmän datauppsättning, men bearbetningen och upphandlingen av dessa videor är ganska dyr (kameraposer, sparsam punktmoln, karakterisering av de plana ytorna, etc. för varje bildruta i varje video), vilket gör datasetet nästan 2 terrabyte stort.

Den tränade Objectron-modellen (känd som en lösning för MediaPipe-projekt) utbildas i fyra kategorier – skor, stolar, muggar och kameror.

2D-objektdetektering använder termen "begränsande rutor", medan de faktiskt är rektanglar. 3D-objektdetektering förutsäger faktiskt boxar kring objekt, från vilka man kan sluta sig till deras orientering, storlek, grova volym, etc. Detta är en ganska svår uppgift att ta sig an, särskilt med tanke på bristen på lämpliga datauppsättningar och kostnaden för att skapa dem. Även om det är svårt, lovar problemet många Ökad verklighet (AR) applikationer!

Objectron-lösningen kan köras i ett enstegs- eller tvåstegsläge – där enstegsläget är bättre på att upptäcka flera objekt, medan tvåstegsläget är bättre på att upptäcka ett enda huvudobjekt i scenen, och körs betydligt snabbare. Enstegspipelinen använder ett MobileNetV2-stamnät, medan tvåstegspipelinen använder TensorFlow Object Detection API.

När ett objekt upptäcks i en video görs inte ytterligare förutsägelser för det på varje bildruta av två anledningar:

• Kontinuerliga förutsägelser introducerar hög skakighet (på grund av den inneboende stokasticiteten i förutsägelserna)
• Det är dyrt att köra stora modeller på varje ram

Teamet laddar ner de tunga förutsägelserna till första möten och spårar sedan den rutan så länge objektet i fråga fortfarande är i scenen. När siktlinjen är bruten och objektet återinförs, görs en förutsägelse igen. Detta gör det möjligt att använda större modeller med högre noggrannhet, samtidigt som beräkningskraven hålls låga, och sänker hårdvarukraven för realtidsinferens!

Låt oss gå vidare och installera MediaPipe, importera Objectron-lösningen och tillämpa den på statiska bilder och ett videoflöde som kommer direkt från en kamera.

Installerar MediaPipe

Låt oss först installera MediaPipe och förbereda en hjälpmetod för att hämta bilder från en given URL:

! pip install mediapipe

Med ramverket installerat, låt oss importera det tillsammans med vanliga bibliotek:

import mediapipe as mp

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

Låt oss definiera en hjälpmetod för att hämta bilder med en URL och som returnerar en RGB-matris som representerar den bilden:

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)

Slutligen vill vi importera både Objectron-lösningen och ritverktygen för att visualisera förutsägelser:

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

3D-objektdetektering på statiska bilder med MediaPipe

Smakämnen Objectron klass tillåter flera argument, inklusive:

• static_image_mode: Oavsett om du matar in en bild eller en ström av bilder (video)
• max_num_objects: Maximalt identifierbart antal objekt
• min_detection_confidence: Detektionsförtroendetröskeln (hur säkert nätverket måste vara för att klassificera ett objekt för den givna klassen)
• model_name: Vilken modell du vill ladda emellan 'Cup', 'Shoe', 'Camera' och 'Chair'.

Med dessa i åtanke – låt oss instansiera en Objectron-instans och process() ingångsbilden:

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


results = objectron.process(mug)

Smakämnen results innehåller 2D- och 3D-landmärkena för det eller de detekterade objekten samt rotation, translation och skala för var och en. Vi kan bearbeta resultaten och rita begränsningsrutorna ganska enkelt med hjälp av de medföljande ritverktygen:

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

Detta resulterar i:

3D-objektdetektering från video eller webbkamera med MediaPipe

En mer spännande applikation finns på videor! Du behöver inte ändra koden mycket för att ta emot videor, oavsett om du tillhandahåller en från webbkameran eller en befintlig videofil. OpenCV är en naturlig passform för att läsa, manipulera och mata in videorutor i objectron-modellen:

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

Gör bilden oskrivbar med image.flags.writeable = False gör att processen går något snabbare och är en valfri ändring. Den slutliga cv2.flip() på den resulterande bilden är också valfritt – och gör helt enkelt utmatningen spegelvänd för att göra den lite mer intuitiv.

När du kör på en kamera och en globalt vanlig Ikea-mugg är dessa resultaten:

Utmatningen är något skakig, men hanterar rotationsöversättning bra, även med en skakig hand som håller i lågupplösta kameran. Vad händer när ett föremål tas ut ur ramen?

Förutsägelserna stannar för objektet vid den första upptäckten och boxspårning upptäcker tydligt att objektet har lämnat ramen och utför förutsägelsen och spårningen igen så fort objektet går in i ramen igen. Det verkar som att spårningen fungerar något bättre när modellen kan se mugghandtag, eftersom utgångarna är mer skakiga när handtaget inte är synligt (förmodligen för att det är svårare att exakt fastställa muggens verkliga orientering).

Dessutom verkar vissa vinklar ge betydligt mer stabila uteffekter än andra under utmanande ljusförhållanden. Specifikt för muggar hjälper det att kunna se muggens läpp eftersom det hjälper till med perspektiv, snarare än att se en ortogonal projektion av föremålet.

Dessutom, när den testades på en genomskinlig mugg, hade modellen svårt att fastställa den som en mugg. Detta är troligen ett exempel på en ur distribution objekt, eftersom de flesta muggar är ogenomskinliga och har olika färger.

Slutsats

3D-objektdetektering är fortfarande något ungt, och MediaPipes Objectron är en kapabel demonstration! Även om det är känsligt för ljusförhållanden, objekttyper (transparenta kontra ogenomskinliga muggar, etc.) och något skakigt – är Objectron en bra inblick i vad som snart kommer att vara möjligt att göra med högre noggrannhet och tillgänglighet än någonsin tidigare.