Brug OpenMV-kameraet til hurtigt at begynde at bruge maskinlæring til objektdetektion

Anvendelsen af maskinlæring (ML) til objektdetektion og klassificering er ved at blive et presserende behov inden for den integrerede systemindustri – især indenfor IoT (Internet of Things), sikkerhed, avancerede kørehjælpssystemer (ADAS) og industrielle automatiseringsbaserede systemer. Objektdetektion er imidlertid et komplekst emne, og ML er relativt nyt, så det kan være vanskeligt og besværligt at udvikle ML-applikationer til at registrere objekter.

For eksempel har objektdetektion traditionelt krævet, at udviklere lærer et framework som OpenCV og at de køber for tusinder af dollars computerudstyr for at få succes. Som sådan er traditionelle tilgange til objektdetektion og machine-vision ikke bare tidskrævende, de er også dyrt.

For ingeniører, der ønsker at anvende ML til objektdetektering og machine-vision applikationer uden at have behov for at blive en ekspert i ML eller for at bruge en lille formue på udstyr, er Python programmerbar OpenMV H7-kameramodul fra SparkFun Electronics en innovativ løsning. Modulet er designet til at være et billigt "Arduino"-lignende modul til billedbehandling og detektion. Som sådan giver modul- og softwaresystemet en unik og interessant løsning, der muliggør let detektering og klassificering af objekter ved hjælp af ML i form af et billigt modul.

Denne artikel introducerer OpenMV H7-kameramodulet og viser, hvordan udviklere kan komme i gang med at anvende ML til objektdetektion ved hjælp af CIFAR-10 computer-vision billeddatasæt.

OpenMV H7-kameramodulet

Med sine funktionsrige softwarebiblioteker giver OpenMV H7-kameramodulet megen hjælp, så en udvikler hurtigt kan oprette en ML-applikation. For eksempel kan udviklere bruge OpenMV-kameraet til ansigts- og øjendetektering og endda til præcist at spore pupiller. Det kan bruges til at oprette blobber eller markører, der derefter sporer en farve. Der er endda eksempler på, hvordan man bruger ML til at registrere og spore brugerdefinerede objekter.

OpenMV H7-kameramodulet er et enkelt integreret udviklingskort, der inkluderer alle de hardwarekomponenter, der er nødvendige for ML-baseret objektdetektion og klassificering, til en pris, der er størrelsesordner mindre end traditionelle machine-vision systemer. Modulet er relativt lille og måler kun 3,6 x 4,4 cm (1,4 x 1,75 inches) og inkluderer:

• En avanceret mikrocontroller
• Et integreret og udskifteligt kameramodul
• Batterikonnektorer
• USB micro-stik
• Trefarvet LED
• Et microSD-stik (understøtter kort på op til 64 Gigabyte)
• Udvidelsesinput og -output (I/O)

Figur 1: OpenMV H7-kameramodulet er fuldt integreret med alle de nødvendige komponenter til hurtigt at udvikle og implementere en machine-vision applikation ved hjælp af ML. (Billedkilde: SparkFun Electronics)

Udvidelses-I/O’en giver udviklere en række perifere funktioner fra mikrokontrolleren (figur 2). Disse funktioner inkluderer kommunikationsgrænseflader såsom:

• UART
• SPI
• I²C
• CAN

Udvidelses-I/O inkluderer også kontrol- og datakanaler til kørsel af servoer, generering af signaler gennem en digital til analog konverter (DAC) eller læsning af sensorværdier gennem en analog til digital konverter (ADC). Disse udvidelses-I/O’er gør OpenMV-modulet ekstremt interessant til vision-applikationer inden for hjemmeautomatisering, robotstyring, industriel automatisering og objektdetektering og sporing af områder.

Figur 2: OpenMV H7-kameramodulet leveres med en overflod af I/O-ben, der kan benyttes til udvidelser. Disse ben kan bruges til at styre servomotorer, prøvesensorer eller til at kommunikere med et Wi-Fi-modul for at oprette en IoT-enhed. (Billedkilde: SparkFun)

Den indbyggede mikrokontroller er STMicroelectronics’ STM32F765VIT6, der inkluderer en Arm Cortex-M7-processor i en 100-ben LQFP. Processoren kører på 216 megahertz (MHz) og har 2 megabyte (Mbytes) Flash og 512 kilobytes (Kbytes) RAM. Processoren er ekstremt egnet og godt parret til machine-vision applikationer på grund af dens dobbeltpræcisions flydende tal-enhed (FPU) og fulde DSP-instruktioner. Mikrokontrolleren inkluderer også en hardwarebaseret JPEG-kode, der kan accelerere billedbehandlingsapplikationer. Det generelle blokdiagram for STM32F765VIT6 er vist i figur 3.

Figur 3: STM32F765VIT inkluderer 2 Mbytes Flash, 512 Kbytes RAM og perifere enheder såsom hardwarebaseret JPEG-kodning og DSP-instruktioner, der gør det perfekt til machine-vision applikationer. (Billedkilde: STMicroelectronics)

OpenMV H7-kameramodulet er unikt, idet det understøtter flere forskellige kameramoduler. Hvis en udvikler for eksempel ikke ønsker at bruge det indbyggede kamera, der har en opløsning på 640 x 480, kunne en udvikler skifte til et modul, der understøtter MT9V034 billedsensor fra ON Semiconductor. MT9V034 er en 8.4 mm (1/3 inch) bred VGA-format CMOS aktiv-pixel digital billedbehandlingssensor, der inkluderer en global lukker og har en HDR-tilstand (High Dynamic Range). Sensoren har en billedopløsning på 752 x 480 og er designet til at fungere over et bredt temperaturområde fra -30˚C til +70˚C. ON Semiconductor leverer et udviklingskort til denne billedsensor, MT9V034C12STCH-GEVB (figur 4).

Figur 4: MT9V034C12STCH-GEVB er et udviklingskort til MT9V034-billedsensoren, der inkluderer en indbygget linse til at fremskynde udvikling og test. (Billedkilde: ON Semiconductor)

Udvikling af en første objektdetekteringsapplikation

Applikationsudvikling til OpenMV H7-kameramodulet udføres via OpenMV IDE, der giver et Python-interface til applikationsudvikling (figur 5). Med Python er det ikke nødvendigt at kende et programmeringssprog på lavt niveau. Faktisk er scriptet ikke blot skrevet i Python, men OpenMV H7-kameramodulet kører naturligt MicroPython. Dette giver udviklere en ekstrem nem måde at komme i gang med at skrive machine-vision applikationer på og køre ML-inferenser med minimal indsats.

Figur 5: OpenMV IDE leverer et Python-baseret interface til at udvikle applikationskode til OpenMV H7-kameramodulet. Programmet sendes derefter som et script til kameramodulet, der kører MicroPython. (Billedkilde: Beningo Embedded Group)

En af de første ting, som en udvikler gør, efter at de har konfigureret, er at køre det grundlæggende hello_world.py, som indeholder koden, der er vist i liste 1. Python-scriptet viser en udvikler, hvordan man aktiverer OpenMV-kameraet og kontinuerligt tager snapshots. Dette gør det muligt for udvikleren at få live video og måle billedhastigheden. Billedhastigheden kan variere, når den er tilsluttet en pc fra så lavt som 25 billeder pr. sekund (fps) til ca. 60 fps. Programmet udføres ved blot at tilslutte OpenMV-kameraet til OpenMV IDE ved hjælp af forbindelsesknappen i nederste venstre hjørne af skærmen og derefter klikke på den grønne run-knap.

Kopi # Hello World Example # # Welcome to the OpenMV IDE! Click on the green run arrow button below to run the script!
import sensor, image, time   sensor.reset()                      # Reset and initialize the sensor.
sensor.set_pixformat(sensor.RGB565) # Set pixel format to RGB565 (or GRAYSCALE) sensor.set_framesize(sensor.QVGA)   # Set frame size to QVGA (320x240) sensor.skip_frames(time = 2000)     # Wait for settings take effect.
clock = time.clock()                # Create a clock object to track the FPS.
while(True):     clock.tick()                    # Update the FPS clock.
img = sensor.snapshot()         # Take a picture and return the image.
print(clock.fps())              # Note: OpenMV Cam runs about half as fast when connected                                                                         # to the IDE. The FPS should increase once disconnected. 

Liste 1: OpenMV IDE hello_world.py-applikationen gør det muligt for OpenMV-kameramodulet at levere live video. (Kildekode: OpenMV)

For at udføre en første objektdetekterings- og klassificeringstest skal et ML-netværk trænes med de ønskede objektgenkendelsesklasser. Et ofte anvendt billeddatasæt, der bruges til at træne objektdetekteringsmodeller og teste, hvor godt modellen fungerer, er CIFAR-10 datasættet. CIFAR-10 datasættet består af 60.000 billeder, der indeholder 32 x 32 farvebilleder i de følgende 10 forskellige billedklasser:

• Fly
• Bil
• Fugl
• Kat
• Hjort
• Hund
• Frø
• Hest
• Skib
• Lastbil

Beskrivelsen af processen, der bruges til at træne modellen og konvertere den til en inferens, der kan køre på OpenMV-kameraet, er uden for denne artikels emne. Men det er muligt at køre et CIFAR-10 trænet netværk uden at gå igennem modeludviklingen: OpenMV IDE inkluderer allerede en trænet model for CIFAR-10, der bare skal indlæses på kameraet.

For at bruge denne model skal du tilslutte OpenMV-kameraet til pc'en og OpenMV IDE. Fra OpenMV IDE skal du klikke på værktøjer -> maskinlæring -> CNN Network Library. Et vindue åbnes med mappen OpenMV qtcreator modeller. Der er to muligheder:

• cmsisnn
• tensorflow

Under cmsisnn skal du navigere til mappen cifar10, klikke på cifar10.network og derefter åbne. Et andet vindue åbnes derefter. Dette vindue er til at gemme den trænede netværksfil på OpenMV-kameraet. Brugeren kan derefter vælge det masselagringsdrev, der vises med kameraet til at gemme netværket.

Når netværket er blevet gemt, skal du indlæse CIFAR-10-maskinlæringseksemplet ved at gå til Fil -> Eksempler -> 25-Maskinlæring -> nn_cifar10_search_whole_window.py. Dette indlæser et eksempelscript, der kan ses nedenfor (liste 2).

Kopi # CIFAR-10 Search Whole Window Example # # CIFAR is a convolutional neural network designed to classify its field of view into several # different object types and works on RGB video data.
# # In this example we slide the LeNet detector window over the image and get a list of activations # where there might be an object. Note that use a CNN with a sliding window is extremely compute # expensive so for an exhaustive search do not expect the CNN to be real-time.
  import sensor, image, time, os, nn   sensor.reset()                         # Reset and initialize the sensor.
sensor.set_pixformat(sensor.RGB565)    # Set pixel format to RGB565 (or GRAYSCALE) sensor.set_framesize(sensor.QVGA)      # Set frame size to QVGA (320x240) sensor.set_windowing((128, 128))       # Set 128x128 window.
sensor.skip_frames(time=750)           # Don't let autogain run very long.
sensor.set_auto_gain(False)            # Turn off autogain.
sensor.set_auto_exposure(False)        # Turn off whitebalance.
  # Load cifar10 network (You can get the network from OpenMV IDE).
net = nn.load('/cifar10.network') # Faster, smaller and less accurate.
# 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() will search an roi in the image for the network (or the whole image if the roi is not     # specified). At each location to look in the image if one of the classifier outputs is larger than     # threshold the location and label will be stored in an object list and returned. At each scale the     # detection window is moved around in the ROI using x_overlap (0-1) and y_overlap (0-1) as a guide.
    # If you set the overlap to 0.5 then each detection window will overlap the previous one by 50%. Note     # the computational work load goes WAY up the more overlap. Finally, for mult-scale matching after     # sliding the network around in the x/y dimensions the detection window will shrink by scale_mul (0-1)     # down to min_scale (0-1). For example, if scale_mul is 0.5 the detection window will shrink by 50%.
    # Note that at a lower scale there's even more area to search if x_overlap and y_overlap are small...
    # contrast_threshold skips running the CNN in areas that are flat.
      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()) 

Liste 2: OpenMV IDE nn_cifar10_search_whole_window.py eksempelapplikationen bruges til at klassificere billeder og levere en konfidensniveaumåling for klassificeringen. (Kildekode: OpenMV)

Testapplikationen kan udføres i henhold til hello_world.py-scriptet: tilslut OpenMV IDE til modulet ved at klikke på opret forbindelse nederst til venstre, og derefter klikke på Kør. På dette tidspunkt kører kameraet scriptet og forsøger at klassificere de billeder, det ser. Terminalvinduet udsender om et billede er klassificeret eller ej, og hvad konfidensniveauet er.

På dette tidspunkt behøver en udvikler bare at præsentere forskellige objekter, der er inden for CIFAR-10 datasættet og lade kameraet klassificere dem. Til denne artikels formål var kameraet forsynet med et billede af en kat (figur 6) og et billede af et fly (figur 7). Det er vanskeligt at se fra billedet, men konfidensniveauet var omkring 70 %. Konfidensniveauet kan være lavt på grund af forskelle i de trænede billeder versus testbillederne, lysforholdene og andre faktorer. Højere niveauer er bestemt opnåelige med ekstra træning og strammere kontrol over kameramiljøet.

Figur 6: OpenMV IDE-kameraet, der kører et CNN-netværk for CIFAR-10-datasættet, præsenteret med en kat for genkendelse. (Billedkilde: Beningo Embedded Group)

Figur 7: OpenMV IDE-kameraet, der kører et CNN-netværk for CIFAR-10-datasættet, præsenteret med et fly for genkendelse. (Billedkilde: Beningo Embedded Group)

Udvidelse af OpenMV H7's muligheder

Der er mange muligheder for at udvide OpenMV-modulet til brug med forskellige kameramoduler og et næsten ubegrænset antal eksterne sensorer.

Mens der er I/O-udvidelseskapacitet på OpenMV-modulet, kan det være nyttigt at bruge et eksternt udvidelseskort til at give yderligere adgang til strøm-, jord- og kommunikationssignaler. Et nyttigt udvidelseskort er DFR0578 Gravity Expansion Shield for OpenMV M7-modulet fra DFRobot (figur 8). På figuren kan det ses, at Gravity-modulet giver adgang til ganske mange flere strøm- og jordben. Det udvider endda yderligere I²C-linjer og giver yderligere muligheder for at drive modulet. Dette gør det meget nemmere at interface eksterne sensorer og moduler uden at skulle bruge et brødbræt eller splejse ledninger.

Figur 8: DFRobot Gravity-udvidelseskort til OpenMV-cam M7 giver flere ekstra, let tilgængelige headerstik for at forenkle hurtig fremstilling af prototyper. (Billedkilde: DFRobot)

Ud over Gravity-kortet er der et andet interessant udvidelseskort, som udviklere kan finde nyttigt, nemlig DFRobot DFR0498 FireBeetle Covers – Kamera og lydmediekort (figur 9). FireBeetle udviklingskort inkluderer:

• En interface til at forbinde IIS-codec’er
• Et kameramodul
• Øretelefoner
• Mikrofon

Der er mange andre udvidelseskort, der kan tilsluttes OpenMV H7camera-modulet afhængigt af slutanvendelsen.

Figur 9: DFRobot FireBeetle DFR0498 inkluderer udvidelse til medieenheder såsom en mikrofon. (Billedkilde: DFRobot)

Tips og tricks til at arbejde med OpenMV

At komme i gang med OpenMV H7-kameramodulet er ikke svært, men der er mange nuancer og beslutninger, som udviklere, der arbejder med det for første gang, skal være opmærksomme på. Her er et par "tips og tricks" til at komme i gang med modulet:

• Når du først bruger modulet, skal du sørge for at justere fokus på modulet ved hjælp af proceduren beskrevet i OpenMV-dokumentationen.
• Fra menuen Filer -> Eksempler, få adgang til snesevis af eksempler, der spænder fra, hvordan man registrerer en farve til ansigtsgenkendelse.
• For at tilføje internetforbindelse skal du overveje at bruge et Wi-Fi-skjold. Et Wi-Fi-skjold kan aktiveres automatisk ved opstart i OpenMV IDE fra indstillingen Værktøjer -> OpenMV-kameraindstillinger.
• Overvej at bruge TensorFlow Lite til at træne en ML-model til det eller de interessante objekter.

Udviklere, der følger disse "tip og tricks", vil opdage, at de kan spare en hel del tid og problemer, når de arbejder med OpenMV H7-kameramodulet for første gang.

Konklusion

Som vist er OpenMV H7-kameramodulet unikt egnet til at hjælpe udviklere med hurtigt at komme i gang med at anvende ML-principper til objektdetektion og relaterede applikationer. Der er ikke kun eksempler på applikationer, som udviklere kan benytte sig af for at accelerere deres design, der er også mange udvidelsesmuligheder til kameraer og sensorer. For at komme i gang behøver udviklerne bare at vide, hvordan man skriver et par linjer Python-kode, og de kan have en fungerende applikation inden for nogle timer, afhængigt af kompleksiteten.