SE5 ECEAI/eceai 2023/2024/black-blgrim

Compte rendu des séances

Séance du 04/12/2023

Création de la machine virtuelle

Création d'une machine virtuelle sur le serveur chassiron :

xen-create-image --hostname= --force --dist=bookworm --size=10G --memory=10G --dir=/usr/local/xen --password=glopglop --dhcp --bridge=bridgeStudents

Raspberry-Pi

mettre la config de la raspberry

Capteurs

pas de capteurs lors de la première séance

Séance du 18/12/2023

Sur la VM

script serveur.py

sur la raspberry

script client.py

lecture sur l'uart des données envoyés par le stm32

envoie au serveur (tcp)

sur le capteur

pris ene main du capteur, mettre le code,

Séance du 19/12/2023 et du 20/12/2023

utilisation de la bibliothèque sciait-learn pour l'apprentissage automatique. Nous avons décidé que le but de notre application serait de traduire le langage des signes.

Pour cela nous avons entrainé notre modèle avec quelques signes, comme la lettre A, B ou C et des chiffres 1, 2 et 3 pour commencer.

//mettre screen des résultats entrainement.py et test.py

Les résultats sont satisfaisants mais avec quelques erreurs, la prochaine étape est donc d'améliorer notre algorithme d'apprentissage (pour l'instant on utilise l'algorithme des k plus proches voisins), pour cela nous allons rajouter par exemple du filtrage et tester d'autres algo d'apprentissage automatique

Coté serveur:

Création d'un serveur web, afin de lire les données qui proviennet depuis la raspberrypi et les afficher.

Mise en Place de l'algorithme d'apprentissage

nous avons tester plusieurs méthode d'apprentissage comme la Méthode des k plus proches voisins (K-Neighbour) ou encore forêt aléatoire Random forest.

Random Forest

Présentation du projet

1. Introduction

---

Le projet SignSpeak a pour ambition de créer une solution innovante pour la traduction du langage des signes en texte. L'objectif principal est de développer un système capable de capturer les mouvements des mains et de les interpréter en langage des signes, permettant une communication fluide entre les personnes sourdes ou malentendantes et celles qui ne connaissent pas le langage des signes. Ce projet intègre des technologies avancées telles que l'edge computing, l'intelligence artificielle embarquée, et les communications MQTT, offrant une approche novatrice dans le domaine de l'accessibilité et de la communication.

2. Architecture du Système

---

Notre solution repose sur une architecture intégrée impliquant plusieurs composants clés :

• Capteurs et STM32 : Des capteurs sont connectés à un microcontrôleur STM32, responsables de la capture des mouvements de main. Ces données sont ensuite transmises pour traitement.
• Raspberry Pi : Agissant comme un intermédiaire, la Raspberry Pi reçoit les données des capteurs via UART, exécute un traitement préliminaire et communique avec le serveur.
• Serveur et Machine Learning : Un serveur, hébergé sur une VM Xen, traite les données à l'aide d'un modèle SVM pour la traduction en langage des signes et fournit une interface web pour l'interaction utilisateur.

3. Collecte et Préparation des Données

---

Le processus de collecte des données est géré par le script enregistrementData.py. Ce script lit les données transmises par le STM32 via UART et les enregistre dans un fichier CSV. Chaque entrée du fichier représente les valeurs de capteurs à un moment donné, accompagnées d'une étiquette correspondant au signe effectué. Cette approche assure une collecte de données structurée, essentielle pour l'entraînement précis du modèle d'apprentissage automatique.

import serial
import csv
import sys
import time

# Vérification de l'argument d'entrée
if len(sys.argv) < 2:
    print("Usage: python script.py <etiquette>")
    sys.exit(1)

etiquette = sys.argv[1]

# Paramètres de l'UART
port = "/dev/ttyACM0"
baudrate = 460800

# Créer une connexion UART
ser = serial.Serial(port, baudrate, timeout=1)

# Nom du fichier CSV
filename = f"data_complete.csv"

# Vérifier si le fichier existe déjà
file_exists = False
try:
    with open(filename, 'r') as f:
        file_exists = True
except FileNotFoundError:
    file_exists = False

# Ouvrir le fichier CSV en mode append
with open(filename, 'a', newline='') as file:
    writer = csv.writer(file)

    # Écrire l'en-tête si le fichier n'existait pas
    if not file_exists:
        writer.writerow(["Capteur1", "Capteur2", "Capteur3", "Capteur4", "Capteur5", "Capteur6", "Capteur7", "Capteur8", "Capteur9", "Capteur10", "Capteur11", "Capteur12", "Capteur13", "Capteur14", 
"Capteur15", "Capteur16", "Etiquette"])
    elif file_exists:
        writer.writerow([])
    while True:
        # Lire une ligne de données depuis l'UART
        data = ser.readline().decode('utf-8').rstrip()
        print(f"Données reçues : '{data}'")

        # Vérifier si des données ont été reçues
        if data:
            # Diviser les données en valeurs individuelles
            sensor_values = data.split(',')

            # Filtrer les chaînes vides ou non numériques et convertir en flottants
            try:
                sensor_values = [float(value) for value in sensor_values if value.strip().isdigit()]

                # Vérifier qu'il y a 16 valeurs de capteur
                if len(sensor_values) == 16:
                    sensor_values.append(etiquette)
                    writer.writerow(sensor_values)
                else:
                    print("Données incomplètes reçues")

            except ValueError as e:
                print(f"Erreur de conversion : {e}")
                print(f"Données problématiques : '{data}'")

        time.sleep(0.1)

• Le script commence par établir une communication série avec le STM32.
• Il lit ensuite les données en série, les décode et les stocke dans un fichier CSV pour une utilisation ultérieure.

• Une fois les données collectées et stockées dans le fichier CSV, elles sont préparées pour l'entraînement du modèle.
• Cette préparation implique la normalisation des données, la gestion des valeurs manquantes ou aberrantes, et leur formatage dans un bon format.
  

4. Entraînement du Modèle d'Apprentissage Automatique

---

L'entraînement du modèle est réalisé par un script Python utilisant la bibliothèque scikit-learn. Le modèle SVM, choisi pour sa capacité à gérer des espaces de grande dimension, est entraîné sur l'ensemble des données collectées. Ce processus comprend la division des données en ensembles d'entraînement et de test, l'entraînement du modèle, et sa validation par le calcul de la précision. Nous avions testé plusieurs modèle, comme par exemple un modèle Knn ou randomForest, des 3 algorithmes, c'est celui qui nous à apporté les meilleurs résultats pour un meme nombre de data d'entrainement. (RandomForest en deuxième position)

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
import pickle

# Charger vos données
data = pd.read_csv('data_complete.csv')

# Séparer les caractéristiques et les étiquettes
X = data.drop('Etiquette', axis=1)
y = data['Etiquette']

# Diviser les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Créer et entraîner le modèle SVM
model = SVC(kernel='rbf')
model.fit(X_train, y_train)

# Sauvegarder le modèle entraîné
with open('modele_svm.pkl', 'wb') as file:
    pickle.dump(model, file)

# Charger le modèle et faire des prédictions
with open('modele_svm.pkl', 'rb') as file:
    loaded_model = pickle.load(file)
    predictions = loaded_model.predict(X_test)
    print("Précision :", accuracy_score(y_test, predictions))

1. Séparation des Données:
   • Les données sont divisées en deux ensembles : un ensemble d'entraînement et un ensemble de test. Cette séparation est cruciale pour évaluer objectivement la performance du modèle.
   • Généralement, on adopte une répartition de 80% pour l'entraînement et 20% pour les tests.
2. Entraînement du Modèle SVM:
   • Le modèle SVM avec un noyau RBF (Radial Basis Function) est entraîné sur l'ensemble d'entraînement.
   • L'entraînement implique l'ajustement du modèle aux données d'entraînement, en apprenant à distinguer les différents signes.
3. Sauvegarde et Réutilisation du Modèle
   • Une fois entraîné et validé, le modèle est sauvegardé à l'aide de la bibliothèque pickle
4. Validation et Évaluation du Modèle:
   • Après l'entraînement, le modèle est testé sur l'ensemble de test pour évaluer sa performance.
   • La métrique principale utilisée est la précision, qui mesure la proportion de prédictions correctes par rapport au total des prédictions.

Ensuite on peut générer le modèle comme ceci:

Avec cette prédiction lorsque notre modèle prédit le résultat, il est correct environ 71.81% du temps.

5. Intégration MQTT et Communication

---

Protocole de communication  :

Dans le cadre de notre projet, la communication entre les dispositifs Raspberry Pi et le serveur  est établie via le protocole MQTT.

Justification du Choix de MQTT :

Au début du projet, une approche basée sur des sockets IPv6 avait été envisagée pour tirer parti de l'adressage direct et de la simplification de la configuration réseau qu'offre IPv6. Cependant, dans le but de respecter les impératifs de sobriété énergétique et d'assurer une scalabilité optimale du système, permettant ainsi de gérer aisément un nombre croissant de dispositifs Raspberry Pi, la décision a été prise d'adopter MQTT comme protocole de communication. Le protocole MQTT, reconnu pour sa légèreté et sa fiabilité, s'adapte parfaitement aux contraintes des applications IoT.

Installation du broker mosquitto sur le serveur:

apt install -y mosquitto mosquitto-clients
service mosquitto start

Activation de l'accès à distance au Broker Mosquitto:

ajouter l'authentification par username et mot de passe

sudo mosquitto_passwd -c /etc/mosquitto/passwd username

après on nous demande d'entrer le mot de passe

Modifier le fichier /etc/mosquitto/mosquitto.conf:

listener 1883 10.42.0.5
allow_anonymous false
password_file /etc/mosquitto/passwd

Restart Mosquitto:

service mosquitto restart

Vérification ds logs:

cat /var/log/mosquitto/mosquitto.log

Le script mqtt_client2.py joue un rôle clé dans cette architecture en facilitant la communication bidirectionnelle : il permet non seulement l'envoi des prédictions réalisées par le modèle SVM depuis la Raspberry Pi vers le serveur, mais autorise également la réception des commandes de contrôle, telles que les instructions de démarrage ou d'arrêt de la collecte de données.

import paho.mqtt.client as mqtt
import serial
import pandas as pd
import pickle
import time



MQTT_BROKER_ADDRESS = "10.42.0.5"
MQTT_USERNAME = "username"
MQTT_PASSWORD = "confidentiel"
pi_id = "rpi1234"

collecting_data = False 

client = mqtt.Client()
client.username_pw_set(MQTT_USERNAME, MQTT_PASSWORD)
client.connect(MQTT_BROKER_ADDRESS, 1883, 60)
client.loop_start()


def on_connect(client, userdata, flags, rc):
    print("Connected with result code " + str(rc))
    client.subscribe(f"config/{pi_id}")
    client.publish("raspberry_available", pi_id)

def on_message(client, userdata, msg):
    global collecting_data
    if msg.topic == f"config/{pi_id}":
        command = msg.payload.decode()
        if command == "start":
            collecting_data = True
        elif command == "stop":
            collecting_data = False



client.on_connect = on_connect
client.on_message = on_message


# Configurez le port série et chargez le modèle ici
port = "/dev/ttyACM0"
baudrate = 460800
ser = serial.Serial(port, baudrate, timeout=1)
with open('modele_svm.pkl', 'rb') as file:
    rf = pickle.load(file)
try:

    while True:
        if collecting_data:
            data = ser.readline().decode('utf-8').rstrip()
            if data:
                try:
                    sensor_values = [value for value in data.split(',') if value.strip().replace('.', '', 1).isdigit()]
                    if len(sensor_values) == 16:
                        sensor_values = list(map(float, sensor_values))
                        sensor_values_df = pd.DataFrame([sensor_values])
                        prediction = rf.predict(sensor_values_df)
                        client.publish(f"telemetry/{pi_id}", str(prediction[0]).encode())
                        print("Prédiction :", prediction[0])
                except ValueError as e:
                    print(f"Erreur de conversion : {e}")
        else:
            time.sleep(0.1)

except KeyboardInterrupt:
    print("Script interrompu")


client.loop_stop()
client.disconnect()

6. Interface Serveur et Gestion des Données

---

Le script app.py crée une interface serveur utilisant Flask. Cette interface gère les requêtes entrantes, les messages MQTT, et fournit une API pour l'interface utilisateur web. Elle permet également de visualiser les Raspberry Pi disponibles et les derniers messages traduits.

7. Conception de l'Interface Utilisateur

---

L'interface utilisateur est développée en HTML, CSS et JavaScript. Le fichier index.html fournit une interface claire et intuitive pour l'envoi de commandes et la visualisation des traductions. L'utilisation de JavaScript pour interroger dynamiquement le serveur Flask permet une mise à jour en temps réel des informations affichées.

9. Conclusion et Perspectives

---

SignSpeak représente une avancée significative dans le domaine de la traduction du langage des signes. Ce projet non seulement démont