Usare OpenMV Cam per iniziare rapidamente ad applicare l'apprendimento automatico al rilevamento di oggetti

L'applicazione dell'apprendimento automatico (ML) per il rilevamento e la classificazione degli oggetti sta diventando impellente nel settore dei sistemi embedded, specie per Internet delle cose (IoT), la sicurezza, i sistemi avanzati di assistenza alla guida (ADAS) e i sistemi basati sull'automazione industriale. Il rilevamento di oggetti è però un argomento complesso e l'apprendimento automatico è relativamente nuovo, per cui sviluppare applicazioni ML per questo scopo può essere difficile e macchinoso.

Ad esempio, per ottenere il rilevamento di oggetti gli sviluppatori dovevano in genere imparare un framework come OpenCV e spendere migliaia di dollari in attrezzature informatiche. Gli approcci tradizionali al rilevamento di oggetti e alla visione artificiale sono quindi non solo dispendiosi in termini di tempo, ma anche costosi.

Per gli ingegneri che cercano di applicare l'apprendimento automatico per il rilevamento di oggetti e la visione artificiale senza diventare necessariamente degli esperti in ML o spendere una piccola fortuna in attrezzature, il modulo telecamera OpenMV H7 programmabile Python di SparkFun Electronics è una soluzione innovativa. È stato progettato per essere un modulo a basso costo tipo "Arduino" per l'elaborazione e il rilevamento delle immagini. Il modulo e l'ecosistema software forniscono una soluzione unica e interessante per consentire un rilevamento e una classificazione facili degli oggetti utilizzando l'apprendimento automatico sotto forma di modulo a basso costo.

Questo articolo descrive il modulo telecamera OpenMV H7 e mostra come gli sviluppatori possono iniziare ad applicare l'apprendimento automatico al rilevamento di oggetti utilizzando il set dati di immagini per la visione artificiale CIFAR-10.

Modulo telecamera OpenMV H7

Grazie alle sue librerie software ricche di funzionalità, il modulo telecamera OpenMV H7 è estremamente utile per aiutare uno sviluppatore a creare rapidamente un'applicazione ML. Gli sviluppatori possono ad esempio utilizzarlo per il rilevamento di volti e occhi e persino per tracciare con precisione le pupille. Il modulo può essere utilizzato per creare blob o marcatori per tracciare un colore. Sono inclusi anche esempi su come usare l'apprendimento automatico per rilevare e tracciare oggetti personalizzati.

Il modulo telecamera OpenMV H7 è costituito da un'unica scheda di sviluppo integrata che include tutti i componenti hardware necessari per il rilevamento e la classificazione di oggetti basati su ML a un costo molto inferiore ai tradizionali sistemi di visione artificiale. Il modulo è relativamente piccolo, misura solo 35,56 x 44,45 mm e comprende:

• Un microcontroller di fascia alta
• Un modulo telecamera integrato e sostituibile
• Connettore per batteria
• Connettore micro USB
• LED di tre colori
• Una presa microSD (supporta schede fino a 64 GB)
• Ingresso e uscita (I/O) di espansione

Figura 1: Nel modulo telecamera OpenMV H7 sono totalmente integrati tutti i componenti necessari per sviluppare e implementare rapidamente un'applicazione di visione artificiale utilizzando l'apprendimento automatico. (Immagine per gentile concessione di SparkFun Electronics)

L'I/O di espansione offre agli sviluppatori una nutrita serie di funzionalità periferiche dal microcontroller (Figura 2). Tali funzionalità comprendono interfacce di comunicazione come:

• UART
• SPI
• I²C
• CAN

L'I/O di espansione include anche canali dati e di controllo per pilotare servomotori, generare segnali attraverso un convertitore digitale/analogico (DAC) o leggere i valori dei sensori attraverso un convertitore analogico/digitale (ADC). Questi I/O di espansione rendono il modulo OpenMV estremamente interessante per le applicazioni di visione nell'ambito della domotica, della guida di robot, dell'automazione industriale e degli spazi di rilevamento e tracciamento degli oggetti.

Figura 2: Il modulo telecamera OpenMV H7 è dotato di numerosissimi pin di I/O di espansione. Questi pin possono essere utilizzati per controllare servomotori, sensori campione o per comunicare con un modulo Wi-Fi per creare un dispositivo IoT. (Immagine per gentile concessione di SparkFun)

Il microcontroller su scheda è STM32F765VIT6 di STMicroelectronics, che include un processore Arm Cortex-M7 in un LQFP a 100 pin. Il processore opera a 216 MHz e ha 2 MB di flash e 512 kB di RAM. È estremamente efficiente e particolarmente idoneo per applicazioni di visione artificiale grazie alla sua unità a virgola mobile (FPU) a doppia precisione e a un set completo di istruzioni DSP. Il microcontroller include anche un encoder JPEG basato su hardware in grado di accelerare le applicazioni di imaging. Nella Figura 3 è riportato il diagramma a blocchi generale per STM32F765VIT6.

Figura 3: STM32F765VIT include 2 MB di flash, 512 kB di RAM e periferiche come codifica JPEG basata su hardware e istruzioni DSP che lo rendono perfettamente idoneo per applicazioni di visione artificiale. (Immagine per gentile concessione di STMicroelectronics)

OpenMV H7 è un modulo telecamera particolare, in quanto supporta diversi moduli telecamera. Ad esempio, se uno sviluppatore non volesse usare la telecamera integrata, che ha una risoluzione di 640x480, potrebbe passare a un modulo che supporta il sensore di immagini MT9V034 di ON Semiconductor. MT9V034 è un sensore di imaging digitale a pixel attivi CMOS di formato VGA largo 8,46 millimetri che include un otturatore globale e una modalità di alta gamma dinamica (HDR). Il sensore ha una risoluzione delle immagini di 752x480 ed è progettato per funzionare in un ampio intervallo di temperatura da -30 °C a +70 °C. ON Semiconductor offre una scheda di sviluppo per questo sensore di immagini, MT9V034C12STCH-GEVB (Figura 4).

Figura 4: MT9V034C12STCH-GEVB è una scheda di sviluppo per il sensore di immagini MT9V034 che include un obiettivo incorporato per accelerare lo sviluppo e i test. (Immagine per gentile concessione di ON Semiconductor)

Sviluppo di una prima applicazione di rilevamento di oggetti

Lo sviluppo dell'applicazione per il modulo telecamera OpenMV H7 avviene interamente tramite l'IDE OpenMV, che offre un'interfaccia Python per lo sviluppo dell'applicazione (Figura 5). Con Python, non occorre conoscere un livello di programmazione di basso livello. Infatti, non solo lo script è scritto in Python, ma il modulo telecamera OpenMV H7 esegue in modalità nativa MicroPython. Questo fornisce agli sviluppatori un modo estremamente semplice per iniziare a scrivere applicazioni di visione artificiale ed eseguire inferenze ML senza troppa fatica.

Figura 5: L'IDE OpenMV offre un'interfaccia basata su Python per sviluppare il codice applicativo per il modulo telecamera OpenMV H7. L'applicazione viene poi inviata come script al modulo telecamera, che esegue MicroPython. (Immagine per gentile concessione di Beningo Embedded Group)

Una delle prime cose che fa uno sviluppatore non appena ha predisposto il lavoro è eseguire il file di base hello_world.py, che contiene il codice mostrato nel Listato 1. Lo script Python mostra a uno sviluppatore come abilitare la telecamera OpenMV e scattare istantanee in modo continuo. Lo sviluppatore può così ottenere video in diretta e misurare la frequenza dei fotogrammi. Mentre è collegato a un PC, la frequenza può variare da un minimo di 25 fps a circa 60 fps. L'applicazione viene eseguita semplicemente collegando la telecamera OpenMV all'IDE OpenMV tramite il pulsante di connessione nell'angolo in basso a sinistra dello schermo, e facendo quindi clic sul pulsante verde di esecuzione.

Copy
# 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.

Listato 1: L'applicazione hello_world.py dell'IDE OpenMV consente al modulo telecamera OpenMV di fornire video in diretta. (Codice per gentile concessione di OpenMV)

Per eseguire un primo test di riconoscimento e classificazione degli oggetti, occorre addestrare una rete ML con le classi desiderate di riconoscimento degli oggetti. Un set di dati di immagini di uso comune per addestrare i modelli di rilevamento degli oggetti e testarne il funzionamento è CIFAR-10. CIFAR-10 è costituito da 60.000 immagini che contengono immagini a colori di 32x32 per le seguenti 10 classi:

• Aerei
• Automobili
• Uccelli
• Gatti
• Ungulati
• Cani
• Rane
• Cavalli
• Navi
• Autocarri

La descrizione del processo utilizzato per addestrare il modello e convertirlo in un'inferenza eseguibile nella telecamera OpenMV esula dalle finalità di questo articolo. Ma è possibile gestire una rete addestrata per CIFAR-10 senza passare attraverso lo sviluppo del modello: l'IDE OpenMV include già un modello addestrato per CIFAR-10 che basta caricare nella telecamera.

Per utilizzare questo modello, collegare la telecamera OpenMV al PC e all'IDE OpenMV. Da dentro l'IDE OpenMV, fare clic su tools -> machine learning -> CNN Network Library. Si aprirà una finestra con la cartella dei modelli qtcreator di OpenMV. Vi sono due opzioni:

• cmsisnn
• tensorflow

In cmsisnn, navigare fino alla cartella cifar10, fare clic su cifar10.network e quindi su open. Si aprirà un'altra finestra. Questa finestra serve a salvare il file di rete addestrato sulla telecamera OpenMV. L'utente può quindi selezionare l'unità di archiviazione di massa che appare con la telecamera per salvare la rete.

Una volta salvata la rete, caricare l'esempio di apprendimento automatico CIFAR-10 andando su File -> Examples -> 25-Machine-Learning -> nn_cifar10_search_whole_window.py. Verrà così caricato uno script di esempio che può essere visto qui sotto (Listato 2).

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

Listato 2: L'applicazione di esempio nn_cifar10_search_whole_window.py dell'IDE OpenMV è usata per classificare le immagini e fornire una misurazione del livello di confidenza per la classificazione. (Codice per gentile concessione di OpenMV)

L'applicazione di test può essere eseguita secondo lo script hello_world.py: collegare l'IDE OpenMV al modulo facendo clic su connect in basso a sinistra e poi su run. A questo punto, la telecamera eseguirà lo script e cercherà di classificare le immagini che sta vedendo. La finestra del terminale indica se un'immagine è classificata o meno e qual è il livello di confidenza.

A questo punto, uno sviluppatore deve solo presentare diversi oggetti che si trovano all'interno del set di dati CIFAR-10 e lasciare che la telecamera li classifichi. Ai fini di questo articolo, alla telecamera sono state fornite l'immagine di un gatto (Figura 6) e l'immagine di un aereo (Figura 7). È difficile vederlo dall'immagine, ma il livello di confidenza si aggira intorno al 70%. Il basso livello di confidenza può essere dovuto alle differenze tra le immagini addestrate rispetto a quelle di prova, alle condizioni di illuminazione e ad altri fattori. Con un addestramento supplementare e un controllo più stretto sull'ambiente della telecamera è certamente possibile raggiungere livelli più elevati.

Figura 6: Telecamera con l'IDE OpenMV che esegue una rete CNN per il set di dati CIFAR-10 a cui viene presentato un gatto per il riconoscimento. (Immagine per gentile concessione di Beningo Embedded Group)

Figura 7: Telecamera con l'IDE OpenMV che esegue una rete CNN per il set di dati CIFAR-10 a cui viene presentato un aereo per il riconoscimento. (Immagine per gentile concessione di Beningo Embedded Group)

Espansione delle capacità di OpenMV H7

Esistono molte opportunità per espandere il modulo OpenMV per utilizzarlo con diversi moduli di telecamere e un numero quasi illimitato di sensori esterni.

Anche se sul modulo OpenMV è presente la capacità di espansione I/O, può essere utile utilizzare una scheda di espansione esterna per fornire un ulteriore accesso all'alimentazione, alla terra e ai segnali di comunicazione. Una scheda di espansione utile è Gravity Expansion Shield DFR0578 per il modulo OpenMV M7 di DFRobot (Figura 8). Nella figura, si può notare che il modulo Gravity fornisce l'accesso a diversi altri pin di alimentazione e pin di messa a terra. Espande anche linee I²C supplementari e offre ulteriori opzioni per alimentare il modulo. In questo modo è molto più facile interfacciare sensori e moduli esterni senza dover utilizzare una breadboard o giuntare fili.

Figura 8: La scheda di espansione Gravity di DFRobot per OpenMV Cam M7 offre diverse altre basette di facile accesso per semplificare la prototipazione rapida. (Immagine per gentile concessione di DFRobot)

Oltre alla scheda Gravity, un'altra scheda di espansione interessante che gli sviluppatori possono trovare utile è la FireBeetle Covers - Camera & Audio Media Board DFR0498 di DFRobot (Figura 9). Il modulo di sviluppo FireBeetle include:

• Un'interfaccia per collegare i codec IIS
• Un modulo telecamera
• Auricolari
• Microfono

Esistono molte altre schede di espansione che possono essere collegate al modulo telecamera OpenMV H7, a seconda dell'applicazione finale.

Figura 9: FireBeetle DFR0498 di DFRobot include l'espansione per dispositivi multimediali come un microfono. (Immagine per gentile concessione di DFRobot)

Suggerimenti e consigli per lavorare con OpenMV

Iniziare a lavorare con il modulo telecamera OpenMV H7 non è difficile, ma gli sviluppatori alla loro prima esperienza dovrebbero essere consapevoli delle molteplici sottigliezze e decisioni da prendere. Ecco alcuni suggerimenti e consigli per iniziare a utilizzare il modulo:

• Quando si utilizza il modulo per la prima volta, assicurarsi di regolarne la messa a fuoco seguendo la procedura descritta nella documentazione di OpenMV.
• Dal menu Files -> Examples, accedere a decine di esempi, da come rilevare un colore al riconoscimento facciale.
• Per aggiungere la connettività Internet, utilizzare uno shield Wi-Fi. Uno shield Wi-Fi può essere abilitato automaticamente all'avvio nell'IDE OpenMV da Tools -> OpenMV Cam Settings.
• Considerare l'utilizzo di TensorFlow Lite per addestrare un modello ML per gli oggetti di interesse.

Seguendo questi consigli, gli sviluppatori che lavorano con il modulo telecamera OpenMV H7 per la prima volta risparmieranno parecchio tempo ed eviteranno grattacapi.

Conclusione

Come è stato dimostrato, il modulo telecamera OpenMV H7 è particolarmente idoneo per aiutare gli sviluppatori a iniziare rapidamente ad applicare i principi ML al rilevamento di oggetti e alle applicazioni correlate. Oltre alle applicazioni di esempio che gli sviluppatori possono sfruttare per accelerare la progettazione, sono presenti anche numerose opzioni di espansione per telecamere e sensori. Per iniziare, gli sviluppatori devono solo sapere come scrivere alcune righe di codice Python e potranno avere un'applicazione funzionante in alcune ore, a seconda della complessità.