Mise à jour : 02/06/26

Présentation

Dans cet article nous allons apprendre au robot MR25 à éviter les obstacles en utilisant un neurone perception. Le perceptron est le neurone artificiel le plus simple, a été inventé en 1957 par Frank Rosenblatt au laboratoire d’aéronautique de l’université Cornell. Ce neurone reçoit plusieurs entrées, les combine avec des poids, puis prend une décision binaire. 

Voici un exemple simple de neurone perceptron à 2 entrées utilisant les capteurs de proximité n°2 et n°4 du MR25.

Voici le principe de fonctionnement :

Entrées du neurone :

• • x1 = proxSensor(2)
  • x2 = proxSensor(4)

Sortie du neurone :

• • • 0 → arrêt du robot
    • 1 → avance du robot

Le calcul effectué par le neurone est :

Avec :

• x1​ : valeur du capteur 2
• x2 : valeur du capteur 4
• w1​ : poids associé au capteur 2
• w2​ : poids associé au capteur 4
• b : biais du neurone
• s : somme pondérée

Ensuite, une fonction d’activation à seuil décide de la sortie du neurone :

Le perceptron est entraîné avec quelques exemples :

• obstacle proche → stop le robot
• espace libre → avancer le robot

-> Si les deux capteurs détectent un espace libre (valeurs élevées), la somme est grande alors le robot avance.

-> Si un obstacle est proche (valeur faible), la somme diminue → le robot MR25 s’arrête.

Le Programme

#!/usr/bin/python3

import MR25
import time

# -----------------------------
# Fonctions du perceptron
# -----------------------------

def activation(x):
    """Fonction seuil"""
    if x >= 0:
        return 1
    return 0


# poids initiaux
w1 = 0.0
w2 = 0.0
b = 0.0

# taux d'apprentissage
eta = 0.1

# -----------------------------
# Jeu d'apprentissage
# -----------------------------
#
# x1 = capteur 2
# x2 = capteur 4
#
# Les distances sont normalisées entre 0 et 1
#
# sortie :
# 0 = stop
# 1 = avance

training_data = [
    ([0.1, 0.1], 0),  # obstacle proche
    ([0.2, 0.3], 0),
    ([0.3, 0.2], 0),
    ([0.8, 0.8], 1),  # espace libre
    ([0.7, 0.9], 1),
    ([0.9, 0.7], 1),
]

# -----------------------------
# Apprentissage
# -----------------------------

for epoch in range(100):

    erreur_totale = 0

    for inputs, target in training_data:

        x1, x2 = inputs

        y = activation(w1*x1 + w2*x2 + b)

        erreur = target - y

        w1 += eta * erreur * x1
        w2 += eta * erreur * x2
        b += eta * erreur

        erreur_totale += abs(erreur)

    if erreur_totale == 0:
        break

print("Apprentissage terminé")
print("w1 =", w1)
print("w2 =", w2)
print("b =", b)

# -----------------------------
# Pilotage du robot
# -----------------------------

SEUIL_MAX = 80.0  # mm

while True:

    # lecture des capteurs
    x1 = MR25.proxSensor(2)
    x2 = MR25.proxSensor(4)

    # normalisation 0..1
    x1 = min(x1, SEUIL_MAX) / SEUIL_MAX
    x2 = min(x2, SEUIL_MAX) / SEUIL_MAX

    # décision du perceptron
    sortie = activation(w1*x1 + w2*x2 + b)

    if sortie == 1:
        MR25.forward(20)
        print("AVANCE")
    else:
        MR25.stop()
        print("STOP")

    time.sleep(0.1)

Ce neurone perceptron constitue la base des réseaux de neurones : un réseau plus complexe n’est qu’un assemblage de nombreux perceptrons connectés entre eux.

Améliorations

Le perceptron à 2 entrées est un bon point de départ, mais pour ce robot il existe plusieurs améliorations possibles. Voici quelques idées :

• Ajouter les autres capteurs n°1, 3 et 5

Un neurone à 5 entrées permettrait une meilleure perception :

• Ajouter les déplacements comme tourner à droite ou à gauche.

Par exemple :

• Si obstacle à droite → Alors tourner à gauche
• Si obstacle à gauche → Alors tourner à droite
• Si voie libre → Alors avancer

• Ajouter la valeur réels des capteurs 

L’exemple précédent utilise un simple seul binaire qui fait perdre beaucoup d’information.

On peux faire dépendre la vitesse du robot de la sortie du neurone :

vitesse = int(sortie * 50)
MR25.forward(vitesse)

Le robot MR25 ralentit lorsqu’il y a un obstacle.

• Utiliser une fonction sigmoide comme fonction d’activation

La fonction d’activation précédent permet d’avoir une sortie binaire.

Avec cette fonction on obtient une probabilité en sortie du neurone :

Les déplacements du robot devient beaucoup plus fluide.

• Utiliser un petit réseau de neurone

Au lieu d’utiliser une seule neurone, utiliser :

• neurone 1 : obstacle à gauche
• neurone 2 : obstacle devant
• neurone 3 : obstacle à droite

Puis un neurone de décision choisit l’action :

• Avancer
• Tourner gauche
• Tourner droite
• Stop

Pour le MR25 équipé de 5 capteurs de proximité, l’amélioration la plus efficace est généralement : 5 entrées + 3 sorties (gauche, avance, droite) + apprentissage automatique des poids. Cela permet déjà d’obtenir un véritable comportement d’évitement d’obstacles basé sur un réseau neuronal simple.

A vous de jouez !