SE5 ECEAI 2024/2025/elhasnaoui-chaouni

Introduction

Objectifs du projet

Séance 1 (03/09) : Lors de la première séance, nous avons entamé une réflexion sur les différentes idées de projets que nous pourrions développer en utilisant notre carte STM32, pour explorer les possibilités offertes par la carte, en considérant des applications potentielles dans divers domaines, tels que l'automatisation, la reconnaissance de formes ou le contrôle intelligent de systèmes. Ces premières discussions nous ont permis de poser les bases de projets innovants, alignés sur nos objectifs d'apprentissage et les capacités techniques de la STM32.

Par ailleurs, nous avons également configuré notre environnement de travail en installant les logiciels nécessaires, à savoir NanoEdge AI et STM32, afin de pouvoir commencer le développement de nos projets de manière efficace.

Configuration Réseau

Configuration serveur Cloud

Nous allons créer une machine virtuelle sur Capbreton avec un accès internet IPv6.
Cette machine virtuelle sera déployée grâce à Xen (Hyperviseur) et portera le nom "SE5-elhaschaouni".
La commande lancée pour créer cette machine est la suivante :

xen-create-image --hostname SE5-elhaschaouni --force --dist bookworm --size 10G --memory 1G --dir /usr/local/xen --dhcp --bridge bridgeStudents

Configuration Réseau

Nous devrons ensuite configurer son réseau, sa résolution DNS, et ses sources de paquets Debian.
Pour configurer le réseau de notre machine, nous allons modifier le fichier /etc/network/interfaces qui est un fichier de configuration réseau où sont spécifiés les paramètres de l'interface.

auto eth0
iface eth0 inet6 auto

Configuration DNS

Pour configurer la résolution DNS de notre machine, nous allons modifier le fichier /etc/resolv.conf. Ce fichier permet de spécifier la configuration des serveurs de nom (DNS) afin de résoudre les noms de domaine en adresses IP. Voici la configuration DNS à appliquer :

domain plil.info
search plil.info
nameserver 2a01:c916:2047:c800:216:3eff:fe82:8a5c

Communication des objets

Communication RaspberryPi & Serveur Cloud

La communication entre la Raspberry Pi et le serveur Cloud se fait en utilisant le protocole MQTT. Le serveur Cloud est une machine virtuelle (VM) dans le même sous-réseau que la Raspberry Pi. Nous avons configuré le serveur MQTT en utilisant un Dockerfile pour créer et déployer le conteneur Docker sur le serveur Cloud. Nous avons également développé deux scripts Python pour gérer la communication : subscriber.py pour le serveur Cloud et publisher.py pour la Raspberry Pi.

Déploiement du Serveur MQTT

Nous avons créé un Dockerfile pour configurer Mosquitto.

# Utiliser l'image de base de Mosquitto
FROM eclipse-mosquitto:latest
# Fichier de configuration 
COPY mosquitto.conf /mosquitto/config/mosquitto.conf
# Exposer le port 1883 pour MQTT
EXPOSE 1883 
EXPOSE 9001

Nous avons construit l'image Docker à partir du Dockerfile avec la commande suivante :

docker build -t mosquitto-mqtt .

Puis, nous avons lancé le conteneur Mosquitto avec la commande :

docker run -d --name mosquitto -p 1883:1883 -p 9001:9001 mosquitto-mqtt

Cette commande démarre Mosquitto en arrière-plan (-d) et mappe le port 1883 du conteneur au port 1883 de l'hôte (RasberryPI), qui est le port par défaut utilisé par MQTT.

REST-API Flask

Nous avons développé un serveur HTTP avec Flask pour récupérer et afficher les données reçues via MQTT. Ce serveur permet à la Raspberry Pi de communiquer avec le serveur Cloud en temps réel, affichant les messages publiés sous une forme interactive. L'interface utilisateur de Flask permet de visualiser facilement les informations, facilitant ainsi la surveillance et l'analyse des données.

from flask import Flask, render_template
from flask_socketio import SocketIO
import paho.mqtt.client as mqtt

app = Flask(__name__)
socketio = SocketIO(app)

# MQTT configuration, BROKER : Serveur MQTT (RaspberryPi)
mqtt_broker = 'IP_ADDRESS_RASPBERRYPI'
# TOPIC : Messages queue
mqtt_topic = 'default/topic'

# Callback when a message is received from MQTT
def on_message(client, userdata, message):
    msg = message.payload.decode()
    print(f'Received message: {msg} on topic {message.topic}')
    socketio.emit('mqtt_message', {'message': msg, 'topic': message.topic})

mqtt_client = mqtt.Client()
mqtt_client.on_message = on_message
mqtt_client.connect(mqtt_broker)
mqtt_client.subscribe(mqtt_topic)
mqtt_client.loop_start()

# The index.html file contains the page HTML to show the data received over MQTT
# We have only one ENDPOIT (Route) /
# To access the page go to : https://VM_IP:5000 
@app.route('/')
def index():
    return render_template('index.html')

if __name__ == '__main__':
    socketio.run(app, debug=True)

Entraînement du modèle d’apprentissage

Entraînement sur Microcontrôleur NUCLEO

L'idée sera de développer un système capable de détecter et de reconnaître les chiffres de 0 à 5, représentés par les positions des doigts de la main.

Pour cela, nous utilisons la carte NUCLEO-F401RE associée au capteur de distance X-NUCLEO-53L5A1, ainsi que NanoEdge AI Studio pour l'entraînement et le déploiement d'un modèle d'apprentissage automatique.

Les étapes principales du projet sont :

Collect Dataset

Collecte des donnés pour la classe "1"

Les chiffres de 0 à 5 ont été associés à des configurations spécifiques des doigts :

0 : Poing fermé. --> Class-0

1 : Seul le pouce levé. --> Class-1

2 : Pouce et index levés. --> Class-2

3 : Pouce, index et majeur levés. --> Class-3

4 : Tous les doigts sauf le pouce levés. --> Class-4

5 : Main entièrement ouverte. --> Class-5

Pour améliorer la précision et la robustesse du modèle, nous avons adopté une stratégie consistant à capturer plusieurs positions de la main pour chaque chiffre.

On a collecté 15 lignes de données pour chaque signal (Chiffre) de 0 à 5.

Réalisation de Benchmark

Score Benchmarks réalisés

Nous avons réalisé plusieurs séries de benchmarks en utilisant différents datasets afin de maximiser les performances et la fiabilité de notre modèle. Chaque test a permis d'évaluer l'impact des variations de données sur l'accuracy, la consommation de ressources (RAM et Flash), et le temps d'exécution.

Après plusieurs itérations, nous avons obtenu un score final de 82,84 %, avec une précision équilibrée de 86,94 % (variation minimale de 83,33 % et maximale de 90,28 %, avec un écart-type de 2,87 %).

Ce résultat indique que le modèle est bien optimisé pour reconnaître les différentes configurations de doigts tout en restant adapté aux contraintes matérielles, avec une utilisation de 29,9 KB de RAM et 62 KB de Flash, et un temps d'exécution de seulement 11,4 ms sur un microcontrôleur STM32F411 cadencé à 84 MHz.

Validation du Modèle

Pour valider le modèle, une phase de test en temps réel a été mise en place. Les données étaient collectées en continu à partir du capteur X-NUCLEO-53L5A1, et chaque configuration de main (chiffres de 0 à 5) était analysée par le modèle embarqué sur la carte NUCLEO-F401RE. Les prédictions générées par le modèle étaient affichées instantanément sur un terminal série, permettant de visualiser en temps réel le chiffre détecté.

Cette étape a permis de vérifier la robustesse du modèle dans des conditions réelles. Nous avons évalué sa capacité à prédire avec précision les chiffres malgré des variations d'angles, de distances ou d’éclairage. Les résultats ont confirmé que le modèle pouvait maintenir une précision élevée et une réactivité satisfaisante, validant ainsi son utilisation pour l’application embarquée.

0x0px

Déploiement du modèle

[...]

Visualisation

Visualisation du modèle

Nous visualisons les résultats du modèle d'IA en temps réel grâce à la communication MQTT. Cette visualisation permet de suivre l’efficacité du modèle, d’évaluer les performances et de détecter d’éventuelles anomalies dans les configurations de main, garantissant ainsi une interface utilisateur claire et dynamique.

Les données sont envoyées dans le topic default/topic.