Primi passi con la visione artificiale con TinyML e OpenMV - Parte 1

Gli ingegneri dei sistemi embedded devono affrontare molti problemi applicativi, ma l'apprendimento automatico e tinyML possono potenzialmente risolverli. Un problema particolare, molto difficile da codificare da zero, è il rilevamento e il riconoscimento degli oggetti in un'immagine. Il rilevamento e il riconoscimento di oggetti è un compito perfetto per tinyML. Tuttavia, iniziare con tinyML e la visione artificiale (MV) può essere complesso. Nei prossimi numerosi post esploreremo come affrontare la visione artificiale utilizzando la telecamera OpenMV.

Introduzione alla OpenMV Cam H7

Supponiamo di essere interessati alla visione artificiale per applicazioni a basso consumo utilizzando un microcontroller. In tal caso, è necessario progettare un modulo telecamera su misura o trovarne uno già disponibile in commercio. Creare un modulo da zero sarebbe probabilmente divertente, ma costoso e dispendioso. Una soluzione interessante e disponibile in commercio è OpenMV Cam.

OpenMV Cam è una piccola scheda di sviluppo simile ad Arduino che include tutto ciò di cui uno sviluppatore ha bisogno per iniziare a lavorare con la visione artificiale. In primo luogo, è importante tenere conto che esistono diverse versioni hardware. L'ultima versione è la OpenMV Cam H7 (Figura 1). La Cam H7 si basa sul microcontroller STM32H743VI di STMicroelectronics che si avvale di un'architettura ARM Cortex-M7 con una velocità di clock di 480 MHz. Dispone anche di 1 MB di SRAM e 2 MB di flash. Quando si lavora con applicazioni di visione artificiale e di apprendimento automatico, è sempre bene avere a disposizione molta memoria. La Cam H7 utilizza un modulo telecamera MT9M114 in grado di acquisire immagini di 640 x 320 in scala di grigi a 8 bit a 40 fps o 320 x 240 QVGA a 40-80 fps. Il modulo telecamera può essere cambiato in base alle esigenze dell'applicazione.

Figura 1: Il modulo OpenMV Cam H7 ha tutto ciò che serve per iniziare a realizzare progetti di visione artificiale. (Immagine per gentile concessione di OpenMV)

L'ambiente di sviluppo OpenMV

L'ambiente di sviluppo integrato (IDE) OpenMV, illustrato nella Figura 2, è il modo attraverso il quale gli sviluppatori interagiscono con la Cam H7. L'IDE offre agli sviluppatori la possibilità di modificare gli script Python che verranno eseguiti sul modulo. La Cam H7 utilizza MicroPython, un porting di C Python specificamente progettato per funzionare su sistemi basati su microcontroller. Gli sviluppatori possono quindi collegarsi alla Cam H7, caricare il loro script sul dispositivo ed eseguire l'applicazione. L'IDE può essere utilizzato anche per ottenere un feed in tempo reale delle immagini del frame buffer della Cam H7.

Figura 2: L'ambiente di sviluppo OpenMV include tutto ciò di cui gli sviluppatori hanno bisogno per programmare e interagire con la Cam H7, come un editor di testo, un terminale e un display per l'acquisizione di immagini. (Immagine per gentile concessione di OpenMV)

Gli sviluppatori che desiderano iniziare a utilizzare il modulo per la visione artificiale e magari l'apprendimento automatico, non devono cercare molto lontano. L'IDE di OpenMV comprende script di esempio che vanno dall'attivazione della modalità a basso consumo del sistema al riconoscimento di oggetti e volti. Sono presenti anche esempi di interfacciamento del modulo con schede di sviluppo esterne come Wi-Fi, unità di misurazione inerziale (IMU) e altre opzioni.

Riconoscimento di un cerchio in un'immagine

L'IDE di OpenMV include uno script HelloWorld che consente allo sviluppatore di connettersi alla telecamera e acquisire immagini che alimentano il frame buffer. Per questo post, ho pensato che sarebbe stato interessante esaminare un esempio in grado di riconoscere un elemento contenuto in un'immagine, ad esempio un cerchio.

Se si apre OpenMV IDE e si fa clic su File->Examples->Feature-Detection->find_circles.py (vedere la Figura 3), viene visualizzato uno script che fa proprio questo. È facilissimo testare questo script. Per prima cosa, prendiamo un foglio e disegniamo un cerchio (lo so, disegno malissimo!). Nella parte inferiore sinistra dell'IDE, è presente un pulsante di connessione. Fare clic su di esso per collegarsi alla Cam H7. Quindi, fare clic sul pulsante verde Play, subito sotto il pulsante di connessione. Infine, puntare la Cam H7 sul cerchio disegnato e osservare il frame buffer nell'IDE di OpenMV.

Figura 3: Individuare lo script di esempio find_circles.py nell'IDE di OpenMV. (Immagine per gentile concessione di Beningo Embedded Group)

Notare che periodicamente, nel frame buffer, viene disegnato un cerchio rosso che si sovrappone al cerchio disegnato, come mostrato nella Figura 4. Vediamo anche che nonostante le mie scarse capacità artistiche, la Cam H7 è stata comunque in grado di rilevare la presenza di un elemento simile a un cerchio nell'immagine acquisita. Un cerchio è il nostro primo elemento riconosciuto in questa serie di blog, ma non l'ultimo! Diamo un'occhiata allo script di esempio per capire cosa sta facendo.

Figura 4: Lo script di esempio find_circles.py aggiunge un cerchio rosso al frame buffer, mettendo così in rilievo che ha riconosciuto un cerchio. (Immagine per gentile concessione di Beningo Embedded Group)

Analisi dell'esempio find_circles.py

Lo script fornito dall'IDE di OpenMV per rilevare i cerchi è semplice. Per prima cosa, importa le librerie Python necessarie e inizializza il sensore e l'orologio della telecamera, come mostrato nel listato 1.

Copyimport sensor, image, time

sensor.reset()
sensor.set_pixformat(sensor.RGB565) # grayscale is faster
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time = 2000)
clock = time.clock()

Listato 1: Codice di esempio che inizializza il sensore della telecamera. (Codice per gentile concessione di OpenMV)

Successivamente, un ciclo infinito esegue continuamente l'applicazione, proprio come in qualsiasi applicazione embedded standard. Infine, c'è la "magia" che provoca il riconoscimento. Esaminiamo il listato 2.

Copywhile(True):
  clock.tick()
  img = sensor.snapshot().lens_corr(1.8)

  for c in img.find_circles(threshold = 2000, x_margin = 10, y_margin = 10, r_margin = 10,
      r_min = 2, r_max = 100, r_step = 2):
    img.draw_circle(c.x(), c.y(), c.r(), color = (255, 0, 0))
    print(c)

  print("FPS %f" % clock.fps())

Listato 2: Codice di esempio che legge il sensore della fotocamera e cerca i cerchi nell'immagine. (Codice per gentile concessione di OpenMV)

Il codice del listato 2 inizia con l'acquisizione di un'istantanea. Un metodo chiamato find_circles, incluso nelle librerie OpenMV, viene quindi utilizzato per cercare i cerchi nell'immagine. Per maggiori dettagli sui parametri, si possono leggere i commenti nell'esempio del codice sorgente, ma a noi interessano soprattutto i parametri r_min, r_max e r_step. Il parametro r_min specifica il raggio minimo del cerchio che può essere rilevato. Il parametro r_max stabilisce il raggio massimo. Il programma vedrà cerchi compresi tra 2 e 100 pixel nell'esempio.

Quando viene rilevato un cerchio, viene utilizzato il metodo draw_circle, insieme ai valori x, y e al raggio, per disegnarne un altro sopra a quello rilevato. Notiamo che il colore è specificato in notazione R, G e B, in questo caso il rosso.

Conclusione

La visione artificiale e TinyML possono essere sfruttati dagli sviluppatori e implementati in un numero quasi infinito di applicazioni. In questo post, abbiamo appena presentato OpenMV Cam H7 e l'IDE di OpenMV che abbiamo utilizzato per riconoscere cerchi. Il riconoscimento del cerchio, tuttavia, non richiedeva tinyML, ma solo alcune funzioni di libreria. Nel prossimo post, esploreremo gli esempi di apprendimento automatico integrati, prima di passare a un esempio più complesso in cui addestreremo e distribuiremo il nostro progetto di rilevamento.