Robot per il riconoscimento dei segnali stradali Raspberry Pi 4: 6 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Questo istruibile si basa sul mio progetto universitario. L'obiettivo era creare un sistema in cui una rete neurale analizzasse un'immagine e poi in base al riconoscimento dicesse a un robot arduino di muoversi attraverso Ros.

Ad esempio, se viene riconosciuto un segnale di svolta a destra, il robot girerà a destra, se viene riconosciuto un segnale di svolta a sinistra, il robot girerà a sinistra, se nessuno dei due viene riconosciuto, il robot continuerà in avanti. Il set di dati che verrà utilizzato è il riconoscimento ufficiale dei segnali stradali dell'INI (2019) (Institut Fur Neuroinformatik), questo set di dati ha 43 classi ma ne sono necessarie solo due; Le cartelle 00033 e 00034 nel set di dati sono segnali di svolta a sinistra ea destra.

Passaggio 1: requisiti

I requisiti per questo progetto sono i seguenti:

Un robot arduino. (fondamentalmente un arduino uno, un driver per motore e motori) (non necessario se non stai usando un robot)

Un lampone pi 4.

Una macchina fotografica pi.

Software richiesto:

Pitone 3.

OpenCV 4.

Flusso tensoriale.

arduino IDE (non necessario se non stai usando un robot)

Ros (non necessario se non utilizzi un robot)

Qualunque sia il tuo ide Python preferito (sul lampone pi, io uso Thonny).

Per configurare OpenCV e Tensorflow, segui le istruzioni di Adrian. Link:

Consiglio di guardare il maggior numero possibile di suoi tutorial, sono davvero interessanti e sono utili sia per i principianti che per gli intermedi.

Fase 2: Formazione dei dati

Lo script train è progettato per accedere al set di dati che raccoglie circa 50.000 immagini da 43 classi. Lo script è scritto in python, utilizzando una varietà di librerie: os – serve per collegare lo script python alla directory corretta in cui si trova il set di dati. Matplotlib: serve per visualizzare i dati dal modello di addestramento. Tensorflow e keras: queste sono le librerie utilizzate per creare il modello di rete neurale artificiale, sono utilizzate per progettare il modello. Numpy: questa libreria serve a trasformare le immagini in un array che può quindi essere inserito nel modello per recuperare una previsione.

Lo script allegato è il codice Python per creare un modello dal set di dati. Questo consiste in un 2D convoluzionale con un input (5, 5) e un'attivazione di relu quindi pooling, una volta fatto questo l'input passa attraverso un'altra convoluzione con un input (3, 3) con la stessa attivazione e raggruppamento. Questo accade un'ultima volta prima di essere appiattito e quindi la densità viene applicata alla quantità di classi che ci sono, in questo caso 43.

Il passo successivo è stato quello di compilare il modello. Questa è la parte che imposta l'ottimizzatore, un sgd era il più appropriato poiché era simile all'ottimizzatore utilizzato nell'assegnazione 1. Sgd sta per Discesa gradiente stocastico. Inoltre, all'interno del compilatore è necessario impostare la perdita, la scelta di una perdita sparse_categorical_crossentropy è la soluzione migliore poiché le categorie sono come numeri interi e il modello restituirà una previsione per ogni classe come un float tra 0 e 1. 1 con una precisione del 100%.

Una volta completato il compilatore, è necessario applicare un generatore affinché il modello inizi a elaborare gli input dell'immagine. Il generatore è composto da più parti: training_set: questo è il collegamento al set di dati utilizzato per il training, steps_per_epoch: questo è il numero di passaggi per epoca richiesti, epochs: sono il numero di volte in cui il programma scorrerà un set completo di dati, validation_data – questo è il collegamento al set di dati utilizzato per la validazione, validation_steps – il numero di passaggi utilizzati per la validazione, la validazione avviene alla fine di ogni epoca.

In genere, una cancellazione completa dell'intero set di dati deve essere completa per epoca. Quindi, ad esempio, un set di dati di 1024 immagini richiederà: Dimensione batch = 32, Passi per epoca = 32, epoche = 1. Ogni passaggio include l'intera dimensione batch, quindi con una dimensione batch di 32 i passaggi saranno 32. Dall'altro d'altra parte, è meglio avere una dimensione batch maggiore rispetto al numero di classi, questo perché se la dimensione batch è inferiore, ogni passaggio non può includere un'immagine da ciascuna classe.

Una volta che il modello ha terminato l'addestramento, utilizzando matplotlib il programma creerà un grafico degli output, questo mostra la cronologia dell'addestramento dall'inizio alla fine. Il grafico è composto da accuratezza, accuratezza di convalida, perdita e perdita di convalida, questo è suddiviso per epoca per mostrare come è progredito l'allenamento. La fase finale consiste nel salvare il modello come file.h5 a cui è possibile accedere in seguito per il processo di previsione. Il salvataggio del modello significa che ogni volta che viene eseguito il programma di previsione, il programma di allenamento non deve essere eseguito nuovamente. Il programma di allenamento può richiedere fino a 10 minuti per epoca su un lampone pi.

In allegato lo script di allenamento:

Passaggio 3: implementazione delle previsioni della fotocamera Pi

Il prossimo programma è la previsione e lo script dell'editore.

La prima fase consiste nel caricare il modello utilizzando model.load(). La seconda fase consiste nell'iterare i fotogrammi dalla fotocamera pi utilizzando opencv e quindi ridimensionare il fotogramma alla stessa dimensione delle dimensioni di input utilizzate nella fase di addestramento, 32 x 32 pixel. Una volta fatto ciò, il nuovo frame ridimensionato viene inserito nel modello utilizzando model.predict() che restituisce una matrice, ogni elemento della matrice è un float da 0 a 1, l'indice dell'elemento è lo stesso della classe che rappresenta, quindi il primo elemento è la classe uno e il numero è la previsione di certezza dell'immagine che appartiene a quella classe. Per esempio.

NOTA: se non stai utilizzando il lato robot. Basta rimuovere le righe:

"importare rose"

def talker (direzione):

messaggio = stringa()

pub = rospy. Publisher('robot', String, queue_size=10)

rospy.init_node('talker', anonimo=Vero)

messaggio = direzione

rospy.loginfo(messaggio)

pub.pubblicare (messaggio)"

"interlocutore (direzione)"

In allegato è lo script della fotocamera Pi.

Passaggio 4: Robot Arduino

L'ultimo passaggio è lo script del programma del robot.

Questo è scritto in C++ ed è un file.ino per arduino uno. Il programma richiede la libreria ros che si trova nel gestore delle librerie all'interno dell'ide. Una volta importato questo, ci sono file di esempio, ho scelto di espandere il file di lampeggio del led poiché questo avrebbe fatto un obiettivo simile a quello di cui avevo bisogno. Il programma continua a eseguire il ciclo fino a quando l'alimentazione non viene disconnessa, in primo luogo ascolta il robot del topic, quando cattura un comando da quel topic avrà un'istruzione if per vedere cosa dice il comando. Se il comando viene lasciato, lo script esegue il metodo turn left, se il comando è corretto eseguirà il metodo turn right e altrimenti eseguirà il metodo forward. Questi tre metodi sono molto simili tra loro, dicono ai pin digitali di essere LOW (massa) o 100 (PWM) questo è per in modo che il robot non sia troppo veloce dicendo al driver del motore di lasciare solo un po' di tensione fuori. L'ordine di queste uscite è ciò che fa girare il robot a sinistra ea destra o andare avanti, questo è dovuto all'orientamento della tensione che va ai motori.

In allegato è lo script.ino per arduino.

Passaggio 5: test

Le immagini allegate così il progetto dall'inizio alla fine. La prima immagine mostra la formazione in corso. Una volta completata questa operazione viene mostrata una stampa del modello realizzato. La terza immagine mostra una previsione dallo script di addestramento. questa è l'ultima fase dello script di formazione. Se guardi nella cartella in cui si trova lo script di allenamento, è stato creato un grafico e un modello. Il grafico dovrebbe assomigliare all'immagine 4 qui, questo mostra la storia dell'allenamento dall'inizio alla fine.

L'immagine finale è durante l'esecuzione dello script della fotocamera pi, è un flusso live dalla fotocamera pi. viene fatta una previsione su ogni frame e la previsione viene stampata nel terminale. La cornice mostra ciò che la fotocamera sta vedendo.

In allegato è la mia relazione universitaria per questo progetto. Si prega di leggere per maggiori dettagli del progetto.

Passaggio 6: tutti i file aggiuntivi

Alcuni di questi stavano testando i file che ho creato lungo la strada.