Sommaire
Introduction
Dans ce tutoriel, nous allons découvrir une première approche de l’intelligence artificielle embarquée avec un ESP32 WROOM programmé en MicroPython.
L’objectif est de créer une petite IA capable de prendre une décision simple à partir de deux informations :
- l’humidité du jour ;
- la température du jour.
L’IA devra déterminer s’il est conseillé de sortir ou de rester chez soi. Le projet est volontairement simple afin de comprendre les bases du fonctionnement d’un neurone artificiel.
Nous allons utiliser trois étapes principales :
- entraîner une IA très simple avec des exemples ;
- utiliser cette IA avec des valeurs données à la main ;
- utiliser cette IA avec de vraies mesures provenant d’un capteur DHT22.
Ce tutoriel permet de comprendre les notions essentielles suivantes :
- les données d’entrée ;
- les poids ;
- le biais ;
- la fonction sigmoïde ;
- l’apprentissage ;
- l’inférence ;
- la prise de décision automatique.
Montage
Dans cette section, nous listons le matériel nécessaire et présentons le câblage entre une carte ESP32 et la carte Shield DHT22 pour ESP32.
Matériel nécessaire
- 1 Carte ESP32 WROOM-32
- 1 Shield Capteur DHT22 pour ESP32
- 1 câble USB Type-C
Shield Capteur DHT22 pour ESP32 – Température et humidité précises, format parfait
8,99 € (7,49 € HT)
Vous économisez
Carte de Développement ESP32-DevKitC Version-2 16 MB – ESP32-WROOM-32
24,99 € (20,83 € HT)
Vous économisez
Câble USB Type C pour Arduino et ESP32 – Transfert Fiable et Rapide pour Projets Créatifs
4,99 € (4,16 € HT)
Vous économisez
Assemblez le shield ESP32 avec la carte ESP32 :
Tableau récapitulatif
Le tableau ci-dessous indique la correspondance entre les broches numériques de l’ ESP32 WROOM-32 et le module SHIELD DHT22 POUR ESP32
| ESP32 WROOM | Shield DHT22 pour ESP32 |
|---|---|
| D4 / GPIO 4 | DATA / OUT |
| 3.3V | VCC |
| GND |
Principe du projet
L’IA utilisée dans ce projet est composée d’un seul neurone artificiel.
Ce neurone possède deux entrées :
- humi_du_jour
- temp_du_jour
L’ESP32 va lire la température et l’humidité. Ces valeurs seront transformées en 1 ou 0.
Pour la température :
- temp_du_jour = 1 si la température est entre 16 °C et 25 °C ; (Température favorable)
- temp_du_jour = 0 si la température est inférieure à 16 °C ou supérieure à 25 °C. (Température défavorable)
Pour l’humidité :
- humi_du_jour = 1 si l’humidité est entre 40 % et 60% ; (Humidité favorable)
- humi_du_jour = 0 si l’humidité est inférieure à 40% ou supérieure à 60 %. (Humidité défavorable)
Ces deux valeurs seront ensuite données à notre IA.
Le neurone possède aussi deux poids :
- poids_humi
- poids_temp
Un poids représente l’importance d’une entrée dans la décision finale.
Installation du logiciel MicroPython sur Windows, Mac et Linux
Pour programmer l’ESP32 en MicroPython, nous allons utiliser Thonny.
Thonny est un logiciel simple qui permet :
- d’écrire du code Python ;
- de flasher MicroPython sur l’ESP32 ;
- d’envoyer des fichiers sur l’ESP32 ;
- d’utiliser la console interactive de MicroPython.
Installation de Thonny
Télécharger Thonny depuis le site officiel :
https://thonny.org
Installer ensuite le logiciel selon votre système.
Sur Windows
- Télécharger l’installateur Windows.
- Lancer le fichier .exe.
- Suivre les étapes d’installation.
- Brancher l’ESP32 avec un câble USB.
Si l’ESP32 n’est pas reconnu, il faut peut-être installer un pilote USB selon la puce de votre carte :
- CP210x ;
- CH340 ;
- FTDI.
Sur macOS
- Télécharger la version macOS de Thonny.
- Glisser l’application dans le dossier Applications.
- Brancher l’ESP32.
- Autoriser l’application si macOS affiche un message de sécurité.
Selon la carte ESP32, un pilote USB peut aussi être nécessaire.
Sur Linux
Sur certaines distributions, Thonny peut être installé directement avec le gestionnaire de paquets.
Exemple avec Debian ou Ubuntu :
sudo apt install thonny
Si l’utilisateur n’a pas accès au port série, il peut être nécessaire de l’ajouter au groupe dialout :
sudo usermod -a -G dialout $USER
Après cette commande, il faut se déconnecter puis se reconnecter.
Configuration de l’ESP32 WROOM sur MicroPython et test de la LED intégrée sur D2
Installer MicroPython sur l’ESP32
- Brancher l’ESP32 à l’ordinateur.
- Ouvrir Thonny.
- Aller dans :
Outils > Options > Interpréteur
- Choisir :
MicroPython (ESP32)
- Sélectionner le port USB de l’ESP32.
- Cliquer sur :
Installer ou mettre à jour MicroPython
- Choisir le firmware adapté à l’ESP32.
- Lancer l’installation.
Une fois MicroPython installé, Thonny doit afficher une console MicroPython en bas de la fenêtre.
Tester la LED intégrée sur D2
Sur certaines cartes ESP32, la broche D2 correspond à GPIO 2. C’est souvent la broche de la LED intégrée.
Dans Thonny, créer un nouveau fichier et écrire le code suivant :
from machine import Pin
from time import sleep
# LED intégrée sur D2, souvent GPIO 2
led = Pin(2, Pin.OUT)
while True:
led.value(1)
sleep(1)
led.value(0)
sleep(1)
Cliquer sur Exécuter.
Si la LED clignote, l’ESP32 est bien configuré.
Enregistrer le programme sur l’ESP32
Pour que le programme démarre automatiquement au branchement de l’ESP32, l’enregistrer sur la carte sous le nom :
Blink.py
Entraînement de l’IA à un neurone et 2 entrées
Dans ce chapitre, nous allons créer une IA très simple.
Elle possède :
- deux entrées ;
- deux poids ;
- un biais
- un taux d’apprentissage
- une fonction sigmoïde ;
- une sortie entre
0et1.
Les deux entrées sont :
temp_du_jour
humi_du_jourL’entraînement consiste à montrer plusieurs exemples à l’IA.
Pour chaque exemple, on donne :
- les valeurs d’entrée ;
- le résultat attendu.
Dans notre cas, on veut que l’IA apprenne la règle suivante :
| humi_du_jour | temp_du_jour | Résultat attendu |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 0 |
Ce tableau signifie :
| Situation | Décision attendue |
|---|---|
| Humidité favorable et température favorable | Sortir |
| Humidité favorable mais température défavorable | Rester |
Le calcul du neurone se fait avec une somme pondérée :
somme = temp_du_jour * poids_temp + humi_du_jour * poids_humi + biaisPuis il transforme cette somme en probabilité avec la fonction sigmoïde :
probabilite = 1 / (1 + exp(-somme))Les poids
Les poids servent à indiquer l’importance de chaque entrée dans la décision de l’IA.
Si un poids est grand, l’entrée correspondante influence beaucoup le résultat.
Si un poids est petit, elle influence peu le résultat.
Pendant l’apprentissage, l’IA ajuste automatiquement ces poids pour réduire ses erreurs. Elle apprend donc quelles entrées sont importantes pour obtenir la bonne décision.
Nous utiliserons dans nos codes:
- poids_humi pour le poids ou importance de l’humidité
- poids_temp pour le poidsou importance de la température
Comprendre la fonction sigmoïde
La fonction sigmoïde transforme un nombre quelconque en une valeur comprise entre 0 et 1.
Cela permet d’interpréter le résultat comme une probabilité.
Exemple :
0.20signifie 20 % ;0.75signifie 75 % ;0.95signifie 95 %.
Le rôle du biais
Le biais est une valeur supplémentaire ajoutée au calcul du neurone.
Sans biais, le neurone calcule seulement :
- somme = humi_du_jour * poids_humi + temp_du_jour * poids_temp
Mais cela limite beaucoup ce que le neurone peut apprendre.
Avec un biais, le calcul devient :
- somme = humi_du_jour * poids_humi + temp_du_jour * poids_temp + biais
Le biais permet de décaler la décision du neurone.
On peut le comparer à un réglage de sensibilité.
Même si les entrées sont favorables, le biais peut rendre la décision plus stricte ou plus souple.
Dans notre projet, on veut que l’IA conseille de sortir uniquement si les deux conditions sont réunies :
- humidité favorable ET température favorable
- Cela correspond à une logique de type ET logique.
Sans biais, le neurone a du mal à apprendre correctement cette règle.
Il peut comprendre que les entrées sont importantes, mais il ne sait pas bien fixer le seuil de décision.
Avec un biais, le neurone peut apprendre une règle plus précise :
- Si une seule condition est favorable, on reste chez soi.
- Si les deux conditions sont favorables, on peut sortir.
Le biais est donc très important, car il permet au neurone de ne pas décider seulement en fonction de la force des entrées, mais aussi en fonction d’un seuil appris pendant l’entraînement.
Le taux d’apprentissage
Le taux d’apprentissage indique à quelle vitesse l’IA corrige ses poids. Si le taux est trop petit, L’IA apprends très lentement, à l’inverse si le taux est trop grand L’IA peut corriger trop fort, dépasser la bonne solution, puis osciller. L’erreur peut devenir instable.
Code d’entraînement simple
Ce code peut être exécuté sur l’ordinateur ou sur l’ESP32.
Il montre comment ajuster les poids petit à petit.
import math
# -----------------------------
# 1. Fonction sigmoïde
# -----------------------------
# Elle transforme un nombre en probabilité entre 0 et 1.
def sigmoide(x):
return 1 / (1 + math.exp(-x))
# -----------------------------
# 2. Dérivée de la sigmoïde
# -----------------------------
# Elle sert à corriger les poids pendant l'apprentissage.
def derivee_sigmoide(sortie):
return sortie * (1 - sortie)
# -----------------------------
# 3. Données d'entraînement
# -----------------------------
# Format :
# [humi_du_jour, temp_du_jour, resultat_attendu]
#
# humi_du_jour = 1 : humidité favorable
# humi_du_jour = 0 : humidité défavorable
#
# temp_du_jour = 1 : température favorable
# temp_du_jour = 0 : température défavorable
#
# resultat_attendu = 1 : on peut sortir
# resultat_attendu = 0 : on reste chez soi
donnees = [
[1, 1, 1], # humidité OK + température OK => sortir
[1, 0, 0], # humidité OK + température mauvaise => rester
[0, 1, 0], # humidité mauvaise + température OK => rester
[0, 0, 0], # humidité mauvaise + température mauvaise => rester
]
# -----------------------------
# 4. Initialisation du neurone
# -----------------------------
# Au départ, les poids sont choisis presque au hasard.
poids_humi = 0.1
poids_temp = 0.1
# Le biais permet de décaler la décision du neurone.
# Il est très important pour apprendre correctement.
biais = -0.1
# -----------------------------
# 5. Paramètres d'apprentissage
# -----------------------------
taux_apprentissage = 0.5
epoques = 10000
print("Début de l'entraînement...")
print("-" * 50)
# -----------------------------
# 6. Boucle d'entraînement
# -----------------------------
for epoque in range(epoques):
erreur_totale = 0
for humi_du_jour, temp_du_jour, resultat_attendu in donnees:
# Calcul de la somme pondérée
somme = (
humi_du_jour * poids_humi
+ temp_du_jour * poids_temp
+ biais
)
# Transformation en probabilité
prediction = sigmoide(somme)
# Calcul de l'erreur
erreur = resultat_attendu - prediction
erreur_totale += abs(erreur)
# Correction à appliquer
correction = erreur * derivee_sigmoide(prediction)
# Mise à jour des poids et du biais
poids_humi += taux_apprentissage * correction * humi_du_jour
poids_temp += taux_apprentissage * correction * temp_du_jour
biais += taux_apprentissage * correction
# Affichage de l'erreur toutes les 1000 répétitions
if epoque % 1000 == 0:
print("epoque :", epoque, "| Erreur totale :", erreur_totale)
print("-" * 50)
print("Entraînement terminé")
print("poids_humi =", poids_humi)
print("poids_temp =", poids_temp)
print("biais =", biais)
Le résultat attendu
Remarque importante
Ce modèle est volontairement très simple.
Dans une vraie IA, on utiliserait souvent :
- plus d’entrées ;
- plus de neurones ;
- des biais ;
- plusieurs couches ;
- beaucoup plus de données.
Ici, le but est pédagogique : comprendre le principe d’un neurone artificiel.
Inférence avec des données qu’on lui donne
Une fois les poids obtenus, on peut utiliser l’IA sans refaire l’entraînement.
C’est ce qu’on appelle l’inférence.
L’inférence signifie que l’IA utilise ce qu’elle a appris pour prendre une décision sur une nouvelle situation.
Dans cette partie, on ne fait plus d’apprentissage.
On utilise simplement les poids et le biais obtenus précédemment.
Exemple :
- humi_du_jour = 1
- temp_du_jour = 0
Cela veut dire :
- humidité correcte ;
- température non correcte.
- L’IA devrait donc conseiller de rester chez soi.
Code d’inférence simple
import math
# -----------------------------
# 1. Fonction sigmoïde
# -----------------------------
def sigmoide(x):
return 1 / (1 + math.exp(-x))
# -----------------------------
# 2. Poids appris pendant l'entraînement
# -----------------------------
# Remplace ces valeurs par celles obtenues avec ton script d'apprentissage.
poids_humi = 7.28
poids_temp = 7.28
biais = -11.01
# -----------------------------
# 3. Données du jour données à la main
# -----------------------------
# Exemple :
# humi_du_jour = 1 : humidité favorable
# temp_du_jour = 0 : température défavorable
humi_du_jour = 1
temp_du_jour = 0
# -----------------------------
# 4. Calcul de l'IA
# -----------------------------
somme = (
humi_du_jour * poids_humi
+ temp_du_jour * poids_temp
+ biais
)
probabilite_de_sortir = sigmoide(somme)
# -----------------------------
# 5. Affichage du résultat
# -----------------------------
print("humi_du_jour :", humi_du_jour)
print("temp_du_jour :", temp_du_jour)
print("Probabilité calculée par l'IA : {:.2f}%".format(probabilite_de_sortir * 100))
if probabilite_de_sortir >= 0.9:
print("Verdict : L'IA vous conseille de sortir !")
else:
print("Verdict : L'IA vous conseille de rester chez vous !")
Le résultat attendu
Explication
Si humi_du_jour = 1 et temp_du_jour = 0, cela signifie que seule l’humidité est favorable.
La probabilité ne sera donc probablement pas suffisante pour sortir si le seuil est fixé à 0.9.
Le seuil utilisé ici est : 0.9
Cela signifie que l’IA conseille de sortir seulement si la probabilité est supérieure ou égale à 90 %.
On peut tester les quatre cas possibles :
| humi_du_jour | temp_du_jour | Décision attendue |
|---|---|---|
| 1 | 1 | Sortir |
| 1 | 0 | Rester |
| 0 | 1 | Rester |
| 0 | 0 | Rester |
Cette étape est importante, car elle permet de vérifier que l’IA a bien appris la règle demandée.
Exécution de l’IA à partir des mesures prises par le capteur DHT22
Nous allons maintenant connecter un capteur DHT22 à l’ESP32.
Le DHT22 mesure :
- la température ;
- l’humidité.
L’ESP32 va ensuite convertir ces mesures en 1 ou 0, puis les envoyer à l’IA.
from machine import Pin
from time import sleep
import dht
import math
# -----------------------------
# 1. Configuration du capteur
# -----------------------------
# DHT22 branché sur D4, donc GPIO 4
capteur = dht.DHT22(Pin(4))
# -----------------------------
# 2. Fonction sigmoïde
# -----------------------------
def sigmoide(x):
return 1 / (1 + math.exp(-x))
# -----------------------------
# 3. Poids appris pendant l'entraînement
# -----------------------------
# Remplace ces valeurs par celles obtenues avec ton script d'apprentissage.
poids_humi = 7.28
poids_temp = 7.28
biais = -11.01
print("Démarrage de l'IA avec capteur DHT22...")
print("-" * 50)
# -----------------------------
# 4. Boucle principale
# -----------------------------
while True:
try:
# Le DHT22 doit être lu toutes les 2 secondes environ.
sleep(2)
# Lecture du capteur
capteur.measure()
temperature = capteur.temperature()
humidite = capteur.humidity()
print("-----------------------------")
print("Température mesurée :", temperature, "°C")
print("Humidité mesurée :", humidite, "%")
# -----------------------------
# 5. Conversion température en 1 ou 0
# -----------------------------
if temperature >= 16 and temperature <= 28:
temp_du_jour = 1
else:
temp_du_jour = 0
# -----------------------------
# 6. Conversion humidité en 1 ou 0
# -----------------------------
if humidite > 40 and humidite < 60:
humi_du_jour = 1
else:
humi_du_jour = 0
print("temp_du_jour :", temp_du_jour)
print("humi_du_jour :", humi_du_jour)
# -----------------------------
# 7. Calcul de l'IA
# -----------------------------
somme = (
humi_du_jour * poids_humi
+ temp_du_jour * poids_temp
+ biais
)
probabilite_de_sortir = sigmoide(somme)
# -----------------------------
# 8. Affichage du verdict
# -----------------------------
print("Probabilité calculée par l'IA : {:.2f}%".format(probabilite_de_sortir * 100))
if probabilite_de_sortir >= 0.9:
print("Verdict : L'IA vous conseille de sortir !")
else:
print("Verdict : L'IA vous conseille de rester chez vous !")
except OSError:
print("Erreur de lecture du DHT22")
Résumé du fonctionnement
Le projet fonctionne en plusieurs étapes.
D’abord, on entraîne l’IA avec plusieurs exemples simples :
[1, 1] donne 1
[1, 0] donne 0
[0, 1] donne 0
[0, 0] donne 0
Ensuite, le programme d’apprentissage trouve automatiquement les bonnes valeurs des poids et du biais.
Ces valeurs sont ensuite copiées dans le programme d’inférence.
Enfin, l’ESP32 utilise les mesures du DHT22 pour créer les deux entrées de l’IA :
- humi_du_jour
- temp_du_jour
Puis il calcule une probabilité et affiche un verdict.
Le principe général est donc :
Mesures du capteur
↓
Conversion en 1 ou 0
↓
Calcul avec les poids et le biais
↓
Fonction sigmoïde
↓
Probabilité
↓
Décision finale
Conclusion
Dans cet article, nous avons créé une première intelligence artificielle embarquée sur un ESP32.
Le modèle utilisé est très simple, mais il permet de comprendre plusieurs notions fondamentales :
- une IA utilise des données d’entrée ;
- chaque entrée possède un poids ;
- le biais permet d’ajuster le seuil de décision ;
- la fonction sigmoïde transforme le calcul en probabilité ;
- l’apprentissage sert à trouver les bonnes valeurs ;
- l’inférence sert à utiliser ces valeurs sur de nouvelles données.
Ce projet montre qu’un ESP32 peut analyser des mesures provenant de capteurs et prendre une décision automatique.
Même si cette IA reste très simple, elle constitue une excellente première étape pour comprendre le fonctionnement général de l’intelligence artificielle embarquée.
Évolutions possibles
Ce projet peut être amélioré de plusieurs façons.
On pourrait ajouter d’autres capteurs pour enrichir les données d’entrée de l’IA :
- un capteur de luminosité ;
- un capteur de qualité de l’air ;
- un capteur de mouvement ;
- un capteur de pression ;
- un capteur d’humidité du sol ;
- un capteur de distance.
On pourrait aussi ajouter un écran OLED pour afficher directement les mesures et le verdict :
Température : 22 °C
Humidité : 21 %
Décision : favorable
Une autre amélioration serait d’utiliser la connexion Wi-Fi de l’ESP32 pour envoyer les données vers :
- une page web ;
- une application mobile ;
- un tableau de bord ;
- une base de données.
Pour aller plus loin, il serait aussi possible d’entraîner un modèle plus complexe sur ordinateur avec Python, puis d’envoyer uniquement les poids ou la partie inférence vers l’ESP32.
C’est une méthode très utilisée en IA embarquée : l’ordinateur sert à entraîner le modèle, tandis que le microcontrôleur utilise le modèle pour prendre des décisions en temps réel.
