Objektdetektering med Sipeed MaiX -kort (Kendryte K210): 6 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:37

Som en fortsättning på min tidigare artikel om bildigenkänning med Sipeed MaiX Boards bestämde jag mig för att skriva en annan handledning med fokus på objektdetektering. Det var en del intressant hårdvara som dök upp nyligen med Kendryte K210 -chip, inklusive Seeed AI Hat for Edge Computing, M5 stack's M5StickV och DFRobot's HuskyLens (även om den har proprietär firmware och mer riktad för kompletta nybörjare). På grund av det billiga priset har Kendryte K210 tilltalat människor som vill lägga till datorsyn i sina projekt. Men som vanligt med kinesiska hårdvaruprodukter saknas teknisk support och det är något som jag försöker förbättra med mina artiklar och videor. Men kom ihåg att jag inte är med i Kendryte- eller Sipeed -utvecklarteamet och inte kan svara på alla frågor som rör deras produkt.

Med det i åtanke, låt oss börja! Vi börjar med en kort (och förenklad) översikt över hur CNN -modeller för objektigenkänning fungerar.

UPPDATERING MAY 2020: När jag såg hur min artikel och video om objektdetektering med K210-kort fortfarande är mycket populära och bland toppresultat på YouTube och Google bestämde jag mig för att uppdatera artikeln så att den innehåller information om aXeleRate, Keras-baserat ramverk för AI på Edge utvecklar jag. aXeleRate är i huvudsak baserat på samlingen av skript jag använde för att träna modeller för bildigenkänning/objektdetektering - kombinerade till ett enda ramverk och optimerat för arbetsflöde på Google Colab. Det är mer bekvämt att använda och mer uppdaterat.

För den gamla versionen av artikeln kan du fortfarande se den på steemit.com.

Steg 1: Objektdetekteringsmodellarkitektur förklarad

Modeller för bildigenkänning (eller bildklassificering) tar hela bilden som input och matar ut en lista med sannolikheter för varje klass vi försöker känna igen. Det är mycket användbart om objektet vi är intresserade av upptar en stor del av bilden och vi inte bryr oss så mycket om dess plats. Men tänk om vårt projekt (säg ansiktsspårningskamera) kräver att vi inte bara har kunskap om typen av objekt i bilden, utan också dess koordinater. Och hur är det med projekt som kräver att detektera flera objekt (till exempel för att räkna)?

Här är när objektdetekteringsmodeller kommer till nytta. I den här artikeln kommer vi att använda YOLO (du tittar bara en gång) arkitektur och fokusera förklaringen på den interna mekaniken i just denna arkitektur.

Vi försöker avgöra vilka objekt som finns på bilden och vilka deras koordinater är. Eftersom maskininlärning inte är magi och inte "en tänkande maskin", utan bara en algoritm som använder statistik för att optimera funktionen (neuralt nätverk) för att bättre lösa ett visst problem. Vi måste omskriva detta problem för att göra det mer "optimerbart". Ett naivt tillvägagångssätt här skulle vara att algoritmen minimerar förlust (skillnad) mellan dess förutsägelse och korrekta koordinater för objektet. Det skulle fungera ganska bra, så länge vi bara har ett objekt i bilden. För flera objekt har vi ett annat tillvägagångssätt - vi lägger till rutnätet och får vårt nätverk att förutsäga förekomsten (eller frånvaron) av objekt (er) i varje rutnät. Låter bra, men lämnar fortfarande för mycket osäkerhet för nätverket - hur skickar man ut förutsägelsen och vad man ska göra när det finns flera objekt med centrum inuti en rutnätcell? Vi måste lägga till ytterligare en begränsning - så kallade ankare. Ankare är initialstorlekar (bredd, höjd) varav några (närmast objektstorleken) kommer att ändras till objektstorleken - med hjälp av några utgångar från det neurala nätverket (slutlig funktionskarta).

Så här är en vy på högsta nivå om vad som händer när YOLO-arkitekturen neuralt nätverk utför en objektdetektering på bilden. Enligt funktioner som detekteras av funktionsuttagarnätverk görs en uppsättning förutsägelser för varje rutnätcell, som inkluderar ankarförskjutning, ankarsannolikhet och ankarklass. Sedan slänger vi förutsägelserna med låg sannolikhet och voila!

Steg 2: Förbered miljön

aXeleRate är baserat på ett underbart projekt av penny4860, SVHN yolo-v2-sifferdetektor. aXeleRate tar denna implementering av YOLO -detektorn i Keras till en nästa nivå och använder sitt bekväma konfigurationssystem för att utföra utbildning och konvertering av bildigenkänning/objektdetektering och bildsegmenteringsnätverk med olika backends.

To är två sätt att använda aXeleRate: kör lokalt på Ubuntu -maskin eller i Google Colab. För att köra i Google Colab, ta en titt på detta exempel:

PASCAL-VOC Object Detection Colab Notebook

Att träna din modell lokalt och exportera den för att användas med hårdvaruacceleration är också mycket enklare nu. Jag rekommenderar starkt att du installerar alla nödvändiga beroenden i Anaconda -miljön för att hålla ditt projekt åtskilt från andra och undvika konflikter.

Ladda ner installationsprogrammet här.

När installationen är klar skapar du en ny miljö:

conda create -n yolo python = 3.7

Låt oss aktivera den nya miljön

conda aktivera yolo

Ett prefix före bash -skalet visas med namnet på miljön, vilket indikerar att du arbetar nu i den miljön.

Installera aXeleRate på din lokala maskin med

pip installera git+https://github.com/AIWintermuteAI/aXeleRate

Och kör sedan det här för att ladda ner skript du behöver för utbildning och slutsatser:

git -klon

Du kan köra snabba tester med tests_training.py i aXeleRate -mappen. Det kommer att köra utbildning och slutsatser för varje modelltyp, spara och konvertera utbildade modeller. Eftersom det bara är utbildning för fem epoker och datauppsättningen är mycket liten kommer du inte att kunna få användbara modeller, men detta skript är endast avsett för att kontrollera om det inte finns några fel.

Steg 3: Träna en objektdetekteringsmodell med Keras

Nu kan vi köra ett träningsskript med konfigurationsfilen. Eftersom Keras implementering av YOLO -objektdetektor är ganska komplicerad, i stället för att förklara varje relevant kod, kommer jag att förklara hur du konfigurerar utbildningen och även beskriva relevanta moduler, om du vill göra några ändringar i dem själv.

Låt oss börja med ett leksaksexempel och träna en racoon -detektor. Det finns en config -fil inuti /config -mappen, raccoon_detector.json. Vi väljer MobileNet7_5 som arkitektur (där 7_5 är alfa -parameter för den ursprungliga Mobilenet -implementeringen, styr bredden på nätverket) och 224x224 som ingångsstorlek. Låt oss titta på de viktigaste parametrarna i konfigurationen:

Typ är modell frontend - Classifier, Detector eller SegnetArchitecture är modell backend (funktionsutdragare)

- Full Yolo - Tiny Yolo - MobileNet1_0 - MobileNet7_5 - MobileNet5_0 - MobileNet2_5 - SqueezeNet - VGG16 - ResNet50

Mer information om ankare finns här

Etiketter är etiketter som finns i din datamängd. VIKTIGT: Vänligen, lista alla etiketter som finns i datamängden.

object_scale avgör hur mycket som ska straffas med fel förutsägelse av tillförlitlighet hos objektprediktorer

no_object_scale avgör hur mycket som ska straffas med fel förutsägelse av förtroende för icke-objektprediktorer

coord_scale avgör hur mycket som ska straffas för fel position och storleksprognoser (x, y, w, h)

class_scale avgör hur mycket som ska straffas för fel klassprognoser

augumentation - image augumentation, resizing, shifting and suddig bild för att förhindra överanpassning och ha större variation i dataset.

train_times, validation_times - hur många gånger uppgiften ska upprepas. Användbart om du har förstärkning

aktiverad

first_trainable_layer - låter dig frysa vissa lager om du använder ett förutbildat funktionsnätverk

Nu måste vi ladda ner datauppsättningen, som jag delade på min Google Drive (originaluppsättning), som är en racoon -detekteringsuppsättning som innehåller 150 annoterade bilder.

Se till att ändra raderna i konfigurationsfilen (train_image_folder, train_annot_folder) i enlighet därmed och börja sedan träningen med följande kommando:

python axelerate/train.py -c configs/raccoon_detector.json

train.py läser konfigurationen från.json -filen och tränar modellen med axelerate/networks/yolo/yolo_frontend.py -skript. yolo/backend/loss.py är där anpassad förlustfunktion implementeras och yolo/backend/network.py är där modellen skapas (ingång, funktionsutdragare och detekteringslager tillsammans). axelerate/networks/common_utils/fit.py är ett skript som implementerar träningsprocessen och axelerate/networks/common_utils/feature.py innehåller funktionsutdragare. Om du tänker använda en utbildad modell med K210 -chip och Micropython -firmware kan du på grund av minnesbegränsningar välja mellan MobileNet (2_5, 5_0 och 7_5) och TinyYolo, men jag har funnit att MobileNet ger bättre detekteringsnoggrannhet.

Eftersom det är ett leksaksexempel och bara innehåller 150 bilder av tvättbjörnar, bör träningsprocessen vara ganska snabb, även utan GPU, även om noggrannheten kommer att vara långt ifrån fantastisk. För arbetsrelaterat projekt har jag utbildat en trafikskyltdetektor och en nummerdetektor, båda datamängderna innehåller över några tusen träningsexempel.

Steg 4: Konvertera den till.kmodel -format

Med aXeleRate utförs modellkonvertering automatiskt - detta är förmodligen den största skillnaden från den gamla versionen av träningsmanus! Dessutom får du modellfilerna och träningsdiagrammet snyggt sparade i projektmappen. Jag tyckte också att vaiidationsnoggrannheten ibland inte ger någon uppskattning av modellens verkliga prestanda för objektdetektering och det är därför jag lade till mAP som en valideringsmetrik för objektdetekteringsmodeller. Du kan läsa mer om mAP här.

Om mAP, genomsnittlig genomsnittlig precision (vårt valideringsvärde) inte förbättras för 20 epoker, kommer träningen att sluta för tidigt. Varje gång mAP förbättras sparas modellen i projektmappen. När träningen är över konverterar aXeleRate automatiskt den bästa modellen till angivna format - du kan välja "tflite", "k210" eller "edgetpu" från och med nu.

Nu till det sista steget, faktiskt kör vår modell på Sipeed -hårdvara!

Steg 5: Kör på Micropython Firmware

Det är möjligt att köra slutsatser om vår objektdetekteringsmodell med C -kod, men för enkelhets skull använder vi Micropython -firmware och MaixPy IDE istället.

Ladda ner MaixPy IDE härifrån och micropython firmware här. Du kan använda python script kflash.py för att bränna fast programvara eller ladda ner separat GUI flash -verktyg här.

Kopiera model.kmodel till roten på ett SD -kort och sätt in SD -kortet i Sipeed Maix Bit (eller annan K210 -enhet). Alternativt kan du bränna.kmodel till enhetens flashminne. Mitt exempelskript läser.kmodel från flashminne. Om du använder SD -kort, vänligen ändra den här raden

uppgift = kpu.load (0x200000)

till

uppgift = kpu.load ("/sd/model.kmodel")

Öppna MaixPy IDE och tryck på anslutningsknappen. Öppna raccoon_detector.py -skriptet från mappen example_scripts/k210/detector och tryck på Start -knappen. Du borde se en livestream från kameran med avgränsande lådor runt … ja, tvättbjörnar. Du kan öka modellens noggrannhet genom att tillhandahålla fler träningsexempel, men kom ihåg att det är en liten liten modell (1,9 M) och det kommer att ha problem med att upptäcka små föremål (på grund av låg upplösning).

En av frågorna jag fick i kommentarer till min tidigare artikel om bildigenkänning är hur man skickar detekteringsresultaten över UART/I2C till en annan enhet som är ansluten till Sipeed -utvecklingsbrädor. I mitt github -arkiv kommer du att kunna hitta ett annat exempelskript, raccoon_detector_uart.py, som (du gissade det) detekterar tvättbjörnar och skickar koordinaterna för gränslådor över UART. Tänk på att stift som används för UART -kommunikation skiljer sig från olika kort, det här är något du måste kontrollera själv i dokumentationen.

Steg 6: Sammanfattning

Kendryte K210 är ett solidt chip för datorsyn, flexibelt, om än med begränsat minne tillgängligt. Hittills har vi i mina självstudier täckt att använda det för att känna igen anpassade objekt, upptäcka anpassade objekt och köra några OpenMV -baserade datorvisionsuppgifter. Jag vet förvisso att det också är lämpligt för ansiktsigenkänning och med lite pyssel borde det vara möjligt att göra posdetektering och bildsegmentering (du kan använda aXeleRate för att träna semantisk segmenteringsmodell, men jag har ännu inte implementerat slutsatsen med K210). Ta en titt på aXeleRate -arkivfrågor och gör en PR om du tror att det finns några förbättringar som du kan bidra med!

Här är några artiklar jag använde när jag skrev den här självstudien, ta en titt om du vill lära dig mer om objektdetektering med neurala nätverk:

Begränsande lådobjektdetektorer: förstår YOLO, du ser bara en gång

Förstå YOLO (mer matematik)

Mild guide om hur YOLO Object Localization fungerar med Keras (del 2)

Objektdetektering i realtid med YOLO, YOLOv2 och nu YOLOv3

Hoppas du kan använda den kunskap du har nu för att bygga några fantastiska projekt med maskinsyn! Du kan köpa Sipeed -brädor här, de är bland de billigaste alternativen som finns tillgängliga för ML på inbyggda system.

Lägg till mig på LinkedIn om du har några frågor och prenumerera på min YouTube -kanal för att få besked om mer intressanta projekt som involverar maskininlärning och robotik.