Robot de reconnaissance des panneaux de signalisation Raspberry Pi 4: 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Cette instructable est basée sur mon projet universitaire. L'objectif était de créer un système où un réseau de neurones analyse une image et, en fonction de la reconnaissance, dira à un robot arduino de se déplacer via Ros.

Par exemple, si un signe de virage à droite est reconnu alors le robot tournera à droite, si un signe de virage à gauche est reconnu alors le robot tournera à gauche, si aucun n'est reconnu alors le robot continuera d'avancer. L'ensemble de données qui sera utilisé est la reconnaissance officielle des panneaux de signalisation de l'INI (2019) (Institut Fur Neuroinformatik), cet ensemble de données comporte 43 classes mais seulement deux sont nécessaires; Les dossiers 00033 et 00034 de l'ensemble de données sont des panneaux de virage à gauche et à droite.

Étape 1: Exigences

Les exigences pour ce projet sont les suivantes:

Un robot arduino. (essentiellement un arduino uno, un pilote de moteur et des moteurs) (pas nécessaire si vous n'utilisez pas de robot)

Une framboise pi 4.

Une caméra pi.

Logiciel requis:

Python3.

OpenCV 4.

Tensorflow.

arduino IDE (pas nécessaire si vous n'utilisez pas de robot)

Ros (pas nécessaire si vous n'utilisez pas de robot)

Quelle que soit votre idée python préférée (sur le raspberry pi, j'utilise Thonny).

Pour configurer OpenCV et Tensorflow, suivez les instructions d'Adrian. Lien:

Je recommande de regarder autant de ses tutoriels que possible, ils sont vraiment intéressants et sont à la fois utiles pour les débutants comme pour les intermédiaires.

Étape 2: Entraînement des données

Le script de train est conçu pour accéder à l'ensemble de données qui compile environ 50 000 images de 43 classes. Le script est écrit en python, à l'aide d'une variété de bibliothèques: os - c'est pour lier le script python au bon répertoire où se trouve l'ensemble de données. Matplotlib - c'est pour afficher les données du modèle d'entraînement. Tensorflow et keras - ce sont les bibliothèques utilisées pour créer le modèle de réseau de neurones artificiels, elles sont utilisées pour concevoir le modèle. Numpy - cette bibliothèque sert à transformer les images en un tableau qui peut ensuite être utilisé dans le modèle pour récupérer une prédiction.

Le script joint est le code python pour créer un modèle à partir du jeu de données. Il s'agit d'une convolution 2D avec une entrée (5, 5) et une activation de relu puis pooling, une fois cela fait l'entrée passe par une autre convolution avec une entrée (3, 3) avec la même activation et pooling. Cela se produit une dernière fois avant d'être aplati, puis la densité est appliquée au nombre de classes qu'il y a, dans ce cas 43.

L'étape suivante consistait à compiler le modèle. C'est la partie qui définit l'optimiseur, un sgd était le plus approprié car il était similaire à l'optimiseur utilisé dans l'affectation 1. Sgd signifie descente de gradient stochastique. De plus, dans le compilateur, la perte doit être définie, le choix d'une perte sparse_categorical_crossentropy est le meilleur ajustement car les catégories sont des nombres entiers et le modèle produira une prédiction pour chaque classe sous la forme d'un flottant entre 0 et 1. 1 étant une précision de 100%.

Une fois le compilateur terminé, un générateur doit être appliqué pour que le modèle commence à traiter les entrées d'image. Le générateur se compose de plusieurs parties: training_set - c'est le lien vers l'ensemble de données utilisé pour l'entraînement, steps_per_epoch - c'est le nombre d'étapes par époque qui sont nécessaires, époques - c'est combien de fois le programme va parcourir un ensemble complet de données, validation_data - c'est le lien vers l'ensemble de données utilisé pour la validation, validation_steps - le nombre d'étapes utilisées pour la validation, la validation se produit à la fin de chaque époque.

En règle générale, un effacement complet de l'ensemble de données doit être complet par époque. Ainsi, par exemple, un ensemble de données de 1024 images nécessitera: Taille du lot = 32, Pas par époque = 32, Époques = 1. Chaque étape comprend la taille complète du lot, donc avec une taille de lot de 32, les étapes seront de 32. De l'autre part, il est préférable d'avoir une taille de lot plus grande que le nombre de classes, car si la taille du lot est plus petite, chaque étape ne peut pas inclure une image de chaque classe.

Une fois que le modèle a terminé la formation, en utilisant matplotlib, le programme fera un graphique des sorties, cela montre l'historique de la formation du début à la fin. Le graphique comprend la précision, la précision de validation, la perte et la perte de validation, il est divisé par époque pour montrer comment la formation a progressé. La dernière étape consiste à enregistrer le modèle dans un fichier.h5 auquel on pourra accéder ultérieurement pour le processus de prédiction. L'enregistrement du modèle signifie que chaque fois que le programme de prédiction est exécuté, le programme d'entraînement n'a pas besoin d'être exécuté à nouveau. Le programme d'entraînement peut prendre jusqu'à 10 minutes par époque sur un Raspberry Pi.

Ci-joint le script de formation:

Étape 3: Implémentation des prédictions de la caméra Pi

Le programme suivant est le script de prédiction et d'éditeur.

La première étape consiste à charger le modèle à l'aide de model.load(). La deuxième étape consiste à parcourir les images de la caméra pi à l'aide d'opencv, puis à redimensionner l'image à la même taille que les tailles d'entrée utilisées dans l'étape d'entraînement, 32 x 32 pixels. Une fois cela fait, le nouveau cadre redimensionné est soumis au modèle à l'aide de model.predict () qui génère une matrice, chaque élément de la matrice est un flottant de 0 à 1, l'indice d'élément est le même que la classe qu'il représente, d'où le premier élément est la classe un et le nombre est la prédiction de la certitude que l'image appartient à cette classe. Par exemple.

REMARQUE: si vous n'utilisez pas le côté robot. Supprimez simplement les lignes:

"importer rospy"

def locuteur(direction):

message = chaîne()

pub = rospy. Publisher('robot', chaîne, queue_size=10)

rospy.init_node('talker', anonyme=True)

message = sens

rospy.loginfo(message)

pub.publier(message)"

« locuteur (direction) »

Ci-joint le script de la caméra Pi.

Étape 4: Robot Arduino

La dernière étape est le script du programme du robot.

Ceci est écrit en C++ et est un fichier.ino pour l'arduino uno. Le programme nécessite la bibliothèque ros qui se trouve dans le gestionnaire de bibliothèques de l'ide. Une fois celui-ci importé, il existe des fichiers d'exemple, j'ai choisi de développer le fichier led blink car cela aurait un objectif similaire à celui dont j'avais besoin. Le programme continue de tourner en boucle jusqu'à ce que l'alimentation soit déconnectée, d'abord il écoute le robot du sujet, quand il attrape une commande de ce sujet, il aura une instruction if pour voir ce que dit la commande. Si la commande est à gauche, le script exécute la méthode tourner à gauche, si la commande est à droite, il exécutera la méthode tourner à droite et sinon, il exécutera la méthode avant. Ces trois méthodes sont très similaires les unes aux autres, elles indiquent aux broches numériques d'être soit LOW (masse) soit 100 (PWM), c'est pour que le robot ne soit pas trop rapide en disant au conducteur du moteur de ne laisser qu'un peu de tension en sortie. L'ordre de ces sorties est ce qui fait que le robot tourne à gauche et à droite ou avance, cela est dû à l'orientation de la tension allant aux moteurs.

Ci-joint le script.ino pour arduino.

Étape 5: Tester

Les images jointes ainsi le projet du début à la fin. La première image montre la formation en cours. Une fois cela terminé, une impression du modèle réalisé est affichée. La troisième image montre une prédiction du script d'entraînement. c'est la dernière étape du script de formation. Si vous regardez dans le dossier dans lequel se trouve le script de formation, un graphique et un modèle ont été créés. Le graphique devrait ressembler à l'image 4 ici, cela montre l'historique de la formation du début à la fin.

L'image finale est lors de l'exécution du script de la caméra pi, il s'agit d'un flux en direct de la caméra pi. une prédiction est faite sur chaque trame et la prédiction est imprimée dans le terminal. Le cadre montre ce que la caméra voit.

Ci-joint mon rapport universitaire pour ce projet. Veuillez lire pour plus de détails sur le projet.

Étape 6: Tous les fichiers supplémentaires

Certains d'entre eux étaient des fichiers de test que j'avais créés en cours de route.