Neurone perceptron avec le robot MR25

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. Il 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 MR-25.

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 :

$x_{1}$ : valeur du capteur 2
: valeur du capteur 4
: poids associé au capteur 2
: poids associé au capteur 4
: biais du neurone
: 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.

Fin !