De OpenMV camera gebruiken om automatisch leren toe te passen bij het detecteren van objecten

Het gebruik van automatisch leren (ML) voor het detecteren van objecten wordt binnen embedded systemen steeds dringender, vooral voor het Internet of Things (IoT), beveiliging, geavanceerde rijhulpsystemen (ADAS) en industriële automatisering. Maar het detecteren van objecten is complex en ML is nog vrij nieuw, zodat het ontwikkelen van ML-toepassingen om objecten te detecteren moeilijk en omslachtig kan zijn.

Voor het detecteren van objecten moesten ontwikkelaars bijvoorbeeld een framework als OpenCV leren en voor duizenden dollars computerapparatuur aanschaffen om enige kans van slagen te hebben. De traditionele aanpak van objecten detecteren en machine vision is daardoor niet alleen tijdrovend, maar ook duur.

Ingenieurs die ML en machine vision willen toepassen om objecten te detecteren zonder expert in ML te worden of een klein fortuin aan apparatuur uit te geven, vinden in de met Python programmeerbare OpenMV H7 cameramodule van SparkFun Electronics is een innovatieve oplossing. De module is ontworpen als een goedkope 'Arduino'-achtige module voor beeldverwerking en -detectie. De module en het bijbehorende software ecosysteem vormen een goedkope, unieke en interessante oplossing om snel een systeem voor het detecteren en classificeren met gebruikmaking van ML te bouwen.

In dit artikel wordt de OpenMV H7 cameramodule geïntroduceerd en wordt aangegeven hoe ontwikkelaars ML voor het detecteren van objecten kunnen toepassen door gebruik te maken van de CIFAR-10 gegevensverzameling voor computer vision.

De OpenMV H7 cameramodule

De OpenMV H7 cameramodule heeft een zeer uitgebreide softwarebibliotheek waarmee een ontwerper snel een ML-toepassing kan bouwen. Zo kunnen ontwikkelaars de OpenMV camera gebruiken voor gezichts- en oogherkenning en zelfs voor het nauwkeurig volgen van de pupillen. Hij kan worden gebruikt om blobs of markers te maken die vervolgens een kleur kunnen traceren. Er worden zelfs voorbeelden gegeven hoe ML kan worden gebruikt om zelf te definiëren objecten te detecteren en te traceren.

De OpenMV H7 cameramodule is één geïntegreerd ontwikkelboard met alle hardwarecomponenten die nodig zijn om door middel van ML objecten te detecteren en te classificeren en dat voor een prijs die grootteordes lager is dan traditionele systemen voor machine vision. De module is met zijn afmetingen van 3,55 x 4,45 cm betrekkelijk klein en bevat:

• een geavanceerde microcontroller
• een geïntegreerde en uitwisselbare cameramodule
• een batterijconnector
• een micro-USB-connector
• een driekleuren led
• een microSD-slot (voor kaarten tot 64 Gigabyte)
• een I/O-uitbreidingseenheid

Afbeelding 1: De OpenMV H7 cameramodule wordt geleverd inclusief alle componenten die nodig zijn om snel door middel van ML een toepassing met machine vision te ontwikkelen en uit te rollen. (Afbeelding: SparkFun Electronics)

De I/O-uitbreidingseenheid stelt ontwikkelaars in staat allerlei randapparaten aan te sluiten (Afbeelding 2). Dit zijn onder meer communicatiesystemen als:

• UART
• SPI
• I²C
• CAN

De I/O-uitbreidingseenheid bevat verder regel- en gegevenskanalen om servo's aan te sturen, signalen via een digitaal-analoogconverter (DAC) te genereren of sensorgegevens via een analoog-digitaalconverter (ADC) uit te lezen. Deze I/O-mogelijkheden maken de OpenMV module bijzonder interessant voor vision toepassingen voor domotica, robotbesturing, industriële automatisering en detecteren en volgen van objecten.

Afbeelding 2: de OpenMV H7 cameramodule beschikt over een overvloed aan I/O-pins. Deze pins kunnen worden gebruikt om servo's aan te sturen, sensoren uit te lezen of met een Wi-Fi-module te communiceren om op deze manier een IoT-apparaat te maken. (Afbeelding: SparkFun)

De ingebouwde microcontroller is de STMicroelectronics STM32F765VIT6, met een Arm Cortex-M7 processor in een 100-pins LQFP-behuizing. De processor draait op 216 megahertz (MHz) en beschikt over 2 megabyte (Mbyte) flashgeheugen en 512 kilobyte (Kbyte) RAM-geheugen. De processor is bijzonder krachtig en is dankzij zijn floating point unit (FPU) met dubbele precisie en volledige SSP-instructieset uitstekend geschikt voor machine vision. De microcontroller beschikt verder over een hardware JPEG-encoder waarmee beeldbewerkingstoepassingen sneller kunnen verlopen. Een algemeen blokschema van de STM32F765VIT6 is te zien in Afbeelding 3.

Afbeelding 3: De STM32F765VIT beschikt over 2 Mbyte flashgeheugen, 512 Kbyte RAM-geheugen, randapparaten als een hardware JPEG-encoder en een DSP-instructieset waardoor hij bij uitstek geschikt is voor machine vision. (Afbeelding: STMicroelectronics)

De OpenMV H7 cameramodule is uniek omdat hij verschillende cameramodules ondersteunt. Als een ontwikkelaar bijvoorbeeld niet de ingebouwde camera met een resolutie van 640 x 480 pixels wil gebruiken, dan kan hij of zij in plaats daarvan een module gebruiken die de MT9V034 beeldsensor van ON Semiconductor ondersteunt. De MT9V034 is een digitale CMOS actieve pixel beeldsensor met een breedte van 1/3 inch, VGA-formaat, een globale sluiter en een modus voor hoog dynamisch bereik (HDR). De sensor heeft een beeldresolutie van 752x480 pixels en een bedrijfstemperatuur van -30 tot +70 ˚C. ON Semiconductor levert voor deze beeldsensor een ontwikkelboard, de MT9V034C12STCH-GEVB (Afbeelding 4).

Afbeelding 4: De MT9V034C12STCH-GEVB is een ontwikkelboard voor de MT9V034 beeldsensor met een ingebouwd objectief voor snel ontwikkelen en testen. (Afbeelding: ON Semiconductor)

De eerste toepassing voor objecten detecteren ontwikkelen

Toepassingen ontwikkelen voor de OpenMV H7 cameramodule gebeurt geheel in de OpenMV IDE, met een Python ontwikkelinterface (Afbeelding 5). Met Python is kennis van een laag niveau programmeertaal niet nodig. Niet alleen worden scripts in Python geschreven, de OpenMV H7 cameramodule draait van nature op MicroPython. Hierdoor kunnen ontwikkelaars uiterst eenvoudig een eerste toepassing voor machine vision schrijven en met minimale inspanning de ML uitvoeren.

Afbeelding 5: De OpenMV IDE heeft een Python interface om toepassingscode voor de OpenMV H7 cameramodule te ontwikkelen. De toepassing wordt daarna als een script naar de cameramodule verzonden, die op MicroPython draait. (Afbeelding: Beningo Embedded Group)

Een van de eerste dingen die een ontwikkelaar doet na het instellen is de elementaire hello_world.py uitvoeren, met de code volgens Lijst 1. Het Python script laat de ontwikkelaar zien hoe de OpenMV moet worden ingeschakeld en voortdurend snapshots moeten worden genomen. Hiermee kan de ontwikkelaar een live videostream krijgen en de framesnelheid meten. De framesnelheid kan, met een pc verbonden, variëren van 25 frames per seconde (fps) tot ca. 60 fps. De toepassing wordt uitgevoerd door de OpenMV camera op de OpenMV IDE aan te sluiten met behulp van de 'connect'-knop links onder in het scherm en vervolgens op de groene 'run'-knop te drukken.

Copy
# Hello World voorbeeld
#
# Welkom bij de OpenMV IDE. Klik op de groene pijl hieronder om het script uit te voeren.
import sensor, image, time, os, nn
 
sensor.reset()                         # Reset en initialiseer de sensor.
sensor.set_pixformat(sensor.RGB565) # Stel het pixelformaat op RGB565 (of GRAYSCALE) in
sensor.set_framesize(sensor.QVGA)   # Stel de framegrootte op QVGA in (320x240)
sensor.skip_frames(time = 2000)     # Wacht tot de instellingen geëffectueerd zijn.
clock = time.clock()                # Maak een klok-object aan om FPS te tracken.
 
while(True):
    clock.tick()                    # Update de FPS-klok.
    img = sensor.snapshot()         # Neem een foto en produceer de afbeelding.
    print(clock.fps())              # Opmerking: OpenMV Cam werkt ongeveer half zo snel
                                                                        # bij aansluiting op de IDE. De FPS moet na het verbreken van de verbinding toenemen.

Lijst 1: De OpenMV cameramodule kan met de OpenMV IDE toepassing hello_world.py een live videostream produceren. (Code: OpenMV)

Om een test voor het detecteren en classificeren van objecten uit te voeren moet een ML netwerk eerst worden getraind met klassen van de gewenste te detecteren objecten. Een veel gebruikte afbeeldingenverzameling om modellen voor het detecteren van objecten te trainen en om te testen hoe goed het model werkt, is de CIFAR-10 gegevensverzameling. De CIFAR-10 gegevensverzameling bestaat uit 60.000 afbeeldingen van 32x32 pixels in kleur voor de volgende 10 klassen afbeeldingen:

• Vliegtuig
• Auto
• Vogel
• Kat
• Hert
• Hond
• Kikker
• Paard
• Schip
• Vrachtwagen

Het voert te ver binnen het kader van dit artikel het proces te beschrijven dat wordt gebruikt om het model te trainen en het in een interferentie om te zetten die op de OpenMV camera kan draaien. Maar het is onmogelijk een met CIFAR-10 getraind netwerk te gebruiken zonder een model te ontwikkelen: de OpenMV IDE beschikt al over een getraind model voor CIFAR-10 dat alleen nog maar in de camera hoeft te worden geladen.

Sluit vervolgens de OpenMV camera op de pc en de OpenMV IDE aan. Klik on de OpenMV IDE op tools -> machine learning -> CNN Network Library. Er verschijnt een venster met de map met OpenMV qtcreator modellen. Er zijn twee opties:

• cmsisnn
• tensorflow

Ga onder cmsisnn naar de map cifar10, klik op cifar10.network en vervolgens op 'open'. Er verschijnt een nieuw venster. In dit venster kunt u het bestand met het getrainde netwerk in de OpenMV camera opslaan. De gebruiker kan vervolgens het station selecteren dat bij de camera verschijnt om het netwerk op te slaan.

Als het netwerk opgeslagen is, dan kunt u het CIFAR-10 voorbeeld voor automatisch leren als volgt laden: ga naar File -> Examples -> 25-Machine-Learning -> nn_cifar10_search_whole_window.py. Hierdoor wordt het onderstaande voorbeeldscript geladen (Listing 2).

Copy
# CIFAR-10 Search Whole Window Example
#
# CIFAR is een convolutioneel neuraal netwerk bedoeld om het beeldveld in verschillende
# objecttypen te classificeren en werkt met RGB video.
#
# In dit voorbeeld wordt het LeNet detectievenster over de afbeelding geschoven en wordt een lijst activaties verkregen
# waar een object zou kunnen zijn. Let op dat het gebruik van een CNN met een schuivend venster bijzonder veel
# computerkracht kost en dat CNN daarom niet geschikt is voor real-time verwerking.
 
import sensor, image, time, os, nn
 
sensor.reset()                         # Reset en in initialiseer de sensor.
sensor.set_pixformat(sensor.RGB565)    # Stel het pixelformaat op RGB565 (of GRAYSCALE) in.
sensor.set_framesize(sensor.QVGA)      # Stel de framegrootte op QVGA (320x240) in.
sensor.set_windowing((128, 128))       # Stel het venster op 128x128 pixels in.
sensor.skip_frames(time=750)           # Laat de autogain niet te lang werken.
sensor.set_auto_gain(False)            # Zet autogain uit.
sensor.set_auto_exposure(False)            # Zet de witbalans uit.
 
# Laad het cifar10 netwerk (Het netwerk kan van de OpenMV IDE worden verkregen).
net = nn.load('/cifar10.network')
# Sneller, kleiner en minder nauwkeurig.
# net = nn.load('/cifar10_fast.network')
labels = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
 
clock = time.clock()
while(True):
    clock.tick()
 
    img = sensor.snapshot()
 
    # net.search() zoekt een roi in de afbeelding voor het netwerk (of de hele afbeelding
    # als er geen roi is gespecificeerd). Op elke locatie in de afbeelding moet worden gezocht en als een van de classificatie-uitgangen
    # groter is dan de drempelwaarde, dan wordt een label in een objectenlijst opgeslagen en geretourneerd. Op elke schaal wordt het detectievenster
    # in de roi verplaatst met x_overlap (0-1) en y_overlap (0-1) als richtlijn.
    # Als u de overlap op 0,5 zet, dan overlapt elk detectievenster het vorige voor 50%. Opmerking
    # Bij een grotere overlap neemt de verwerking ENORM toe. Bij matchen op meerdere schalen nadat het netwerk
    # over de x/y-afmetingen is geschoven, wordt tenslotte het detectievenster met scale_mul (0-1) verkleind
    # tot aan min_scale (0-1). Als bijvoorbeeld scale_mul = 0,5, dan wordt het detectievenster 50% kleiner.
    # Opmerking: bij een kleinere schaal moet een nog groter gebied worden doorzocht als x_overlap en y_overlap klein zijn...
    # contrast_threshold zorgt dat het CNN vlakke gebieden overslaat.
 
    for obj in net.search(img, threshold=0.6, min_scale=0.5, scale_mul=0.5, \
            x_overlap=0.5, y_overlap=0.5, contrast_threshold=0.5):
        print("Detected %s - Confidence %f%%" % (labels[obj.index()], obj.value()))
        img.draw_rectangle(obj.rect(), color=(255, 0, 0))
    print(clock.fps())

Listing 2: De OpenMV IDE voorbeeldtoepassing nn_cifar10_search_whole_window.py kan worden gebruikt om afbeeldingen te classificeren en een betrouwbaarheidsniveau aan de classificatie toe te kennen. (Code: OpenMV)

De testtoepassing kan via het hello_world.py script worden uitgevoerd: sluit de OpenMV IDE op de module aan door op 'connect' links onder te klikken en vervolgens op 'run'. Hierna voert de camera het script uit en probeert de gepresenteerde afbeeldingen te classificeren. In het venster komt te staan of een afbeelding geclassificeerd is en wat het betrouwbaarheidsniveau is.

Hierna hoeft een ontwikkelaar alleen maar verschillende objecten te presenteren die in de CIFAR-10 gegevensverzameling staan en de camera deze te laten classificeren. In het kader van dit artikel kreeg de camera een afbeelding van een kat (Afbeelding 6) en van een vliegtuig (Afbeelding 7) te zien. Het is in de afbeelding moeilijk te zien, maar het betrouwbaarheidsniveau was ca. 70%. Het betrouwbaarheidsniveau kan laag zijn vanwege verschillen in de voor het trainen gebruikte afbeeldingen ten opzichte van de in de test getoonde afbeeldingen of in de belichting, of vanwege andere factoren. Hogere betrouwbaarheidsniveaus zijn zeker mogelijk door extra training en de omgeving van de camera constanter te houden.

Afbeelding 6: De OpenMV IDE camera voert een CNN-netwerk uit voor de CIFAR-10 gegevensverzameling waarbij een kat moet worden herkend. (Afbeelding: Beningo Embedded Group)

Afbeelding 7: De OpenMV IDE camera voert een CNN-netwerk uit voor de CIFAR-10 gegevensverzameling waarbij een vliegtuig moet worden herkend. (Afbeelding: Beningo Embedded Group)

De mogelijkheden van de OpenMV H7 uitbreiden

De OpenMV module kan op veel manieren worden uitgebreid voor gebruik met verschillende cameramodules en een schier eindeloos aantal externe sensoren.

Hoewel de OpenMV module een uitbreidingseenheid met veel I/O-aansluitingen heeft, kan het handig zijn een externe uitbreidingskaart te gebruiken voor meer aansluitingen voor voeding, massa en communicatie. Een voorbeeld van zo'n handige uitbreidingskaart is de DFR0578 Gravity Expansion Shield voor de OpenMV M7 module van DFRobot (Afbeelding 8). In de afbeelding is te zien dat de Gravity module over een groot aantal extra voedings- en massa-aansluitingen beschikt. Hij beschikt zelfs over extra I²C-aansluitingen en extra opties voor de voeding van de module. Hierdoor wordt het aansluiten van externe sensoren en modules eenvoudiger zonder een breadboard te hoeven gebruiken of draden te hoeven splitsen.

Afbeelding 8: De DFRobot Gravity uitbreidingskaart voor de OpenMV M7 camera beschikt over meerdere, eenvoudige bereikbare stiftlijsten voor eenvoudig rapid prototypen. (Afbeelding: DFRobot)

Naast de Gravity kaart is een andere interessante uitbreidingskaart voor ontwikkelaars de DFRobot DFR0498 FireBeetle Covers – Camera & Audio Media Board (Afbeelding 9).  De FireBeetle ontwikkelmodule bevat:

• een interface voor IIS-codecs
• een cameramodule
• een oortelefoon
• een microfoon

Er zijn, afhankelijk van de uiteindelijke toepassing, nog veel uitbreidingskaarten die op de OpenMV H7cameramodule kunnen worden aangesloten.

Afbeelding 9: De DFRobot FireBeetle DFR0498 bevat uitbreidingsmogelijkheden voor media-apparaten zoals een microfoon. (Afbeelding: DFRobot)

Tips voor het werken met OpenMV

Het is niet moeilijk om voor de eerste keer met de OpenMV H7 cameramodule te werken, maar er zijn veel details en keuzes waar iemand die er voor het eerst mee gaat ontwikkelen aan moet denken. Hier zijn een paar tips om snel met de module aan de slag te gaan:

• Als u de module voor het eerst gebruikt, moet u erop letten dat u de brandpuntsafstand op de module volgens de OpenMV documentatie instelt.
• Vanuit het menu Files -> Examples hebt u toegang tot tientallen voorbeelden van het detecteren van een kleur tot en met gezichtsherkenning.
• U zou een Wi-Fi shield kunnen gebruiken om een verbinding met het internet te maken. Tijdens het opstarten kan een Wi-Fi shield automatisch worden ingeschakeld in de OpenMV IDE vanuit Tools -> OpenMV Cam Settings.
• Ook zou u TensorFlow Lite kunnen gebruiken om een ML-model voor de van belang zijnde objecten te trainen.

Ontwikkelaars die voor het eerst met de OpenMV H7 cameramodule werken, zullen merken dat deze tips heel wat ergernis en tijd kunnen besparen.

Conclusie

We hebben laten zien dat de OpenMV H7 cameramodule bij uitstek geschikt is om ontwikkelaars te helpen die voor het eerst de principes van ML op het detecteren van objecten en soortgelijke toepassingen willen gebruiken. Er zijn niet alleen voorbeeldtoepassingen voor deze module beschikbaar waardoor ontwikkelaars het ontwerpproces kunnen versnellen, maar er zijn ook talloze opties om de module met camera's en sensoren uit te breiden. Als eerste stap hoeven ontwikkelaars alleen maar te weten hoe ze een paar regels Python code moeten schrijven, waarna ze, afhankelijk van de complexiteit, binnen luttele uren een toepassing werkend kunnen hebben.