{"id":3680,"date":"2026-06-26T17:11:39","date_gmt":"2026-06-26T16:11:39","guid":{"rendered":"https:\/\/www.macerobotics.com\/?p=3680"},"modified":"2026-06-26T17:16:23","modified_gmt":"2026-06-26T16:16:23","slug":"reseau-de-neurones-artificiel","status":"publish","type":"post","link":"http:\/\/www.macerobotics.com\/?p=3680","title":{"rendered":"R\u00e9seau de neurones artificiel"},"content":{"rendered":"

Pr\u00e9sentation<\/h2>\n

Dans cet article nous allons apprendre au robot MR25 \u00e0 \u00e9viter les obstacles en utilisant un r\u00e9seau de neurones. Nous allons coder un r\u00e9seau \u00e0 2 couches, une seule couche (le perceptron) suffit quand le probl\u00e8me est lin\u00e9airement s\u00e9parable<\/em>, c\u2019est-\u00e0-dire qu\u2019on peut tracer une ligne droite entre les cas \u00ab\u00a0oui\u00a0\u00bb et les cas \u00ab\u00a0non\u00a0\u00bb.<\/p>\n

\u00c9viter un obstacle unique devant soi, c\u2019est ce cas. Simple, rapide, mais tr\u00e8s limit\u00e9. Deux couches de neurones permet de r\u00e9soudre des probl\u00e8mes avec des fronti\u00e8res courbes ou des zones multiples. C\u2019est exactement notre cas : il faut distinguer 4 situations (libre, gauche, droite, obstacle) qui ne sont pas s\u00e9parables par une seule ligne dans l\u2019espace des 5 capteurs.<\/p>\n

La couche 1 construit des \u00ab\u00a0concepts interm\u00e9diaires\u00a0\u00bb (obstacle gauche, obstacle devant, obstacle droite), et la couche 2 combine ces concepts pour d\u00e9cider (action).<\/p>\n

Voici le r\u00e9seau de neurone utiliser avec le robot MR25 :<\/p>\n

\"\"<\/a><\/p>\n

Le Programme<\/h2>\n

Ce programme impl\u00e9mente un petit r\u00e9seau de neurones \u00e0 deux couches (apprentissage supervis\u00e9<\/strong> ) qui apprend \u00e0 piloter un robot MR25 \u00e0 partir de ses 5 capteurs de proximit\u00e9. Il comporte deux phases :<\/p>\n

    \n
  1. Phase d\u2019apprentissage\u00a0<\/strong> : le r\u00e9seau apprend \u00e0 associer des situations \u00e0 des actions.<\/li>\n
  2. Phase de pilotage en temps r\u00e9el\u00a0<\/strong> : le robot utilise le r\u00e9seau entra\u00een\u00e9 pour d\u00e9cider de ses mouvements.<\/li>\n<\/ol>\n

    Les 5 capteurs sont regroup\u00e9s en 3 zones :<\/p>\n

      \n
    • Neurone gauche : il mesure l\u2019\u00e9tat de la zone gauche.<\/li>\n
    • Neurone devant : il repr\u00e9sente l\u2019\u00e9tat de la zone centrale.<\/li>\n
    • Neurone droit : il repr\u00e9sente l\u2019\u00e9tat de la zone droite.<\/li>\n<\/ul>\n

      Le r\u00e9seau apprend gr\u00e2ce \u00e0 la r\u00e9tropropagation du gradient, puis pilote le robot en temps r\u00e9el en transformant les mesures des capteurs en actions de navigation et d\u2019\u00e9vitement d\u2019obstacles. La r\u00e9tropropagation du gradient (backpropagation<\/em> en anglais) est l\u2019algorithme qui permet \u00e0 un r\u00e9seau de neurones d\u2019apprendre de ses erreur, on commence par corriger la couche de sortie, puis on remonte vers la couche 1.<\/p>\n

      L\u2019id\u00e9e est simple :<\/em><\/p>\n

        \n
      1. Le r\u00e9seau fait une pr\u00e9diction.<\/em><\/li>\n
      2. On compare cette pr\u00e9diction \u00e0 la r\u00e9ponse attendue.<\/em><\/li>\n
      3. On mesure l\u2019erreur.<\/em><\/li>\n
      4. On remonte cette erreur de la sortie vers les couches pr\u00e9c\u00e9dentes.<\/em><\/li>\n
      5. On modifie les poids pour r\u00e9duire l\u2019erreur lors du prochain essai.<\/em><\/li>\n<\/ol>\n

        Le gradient indique dans quelle direction modifier les poids pour diminuer l\u2019erreur le plus rapidement. Le gradient indique la pente. Le r\u00e9seau suit la pente descendante pour atteindre le minimum d\u2019erreur.<\/p>\n

        #!\/usr\/bin\/python3import MR25import timeimport math# =============================================================================# MR25 \u2014 R\u00e9seau de neurones \u00e0 deux couches# =============================================================================##  Couche 1 : 3 neurones de perception (5 entr\u00e9es \u2192 3 sorties continues)##    Neurone 1 (gauche)  : capteurs 1 et 2#    Neurone 2 (devant)  : capteurs 2, 3 et 4#    Neurone 3 (droite)  : capteurs 4 et 5##  Couche 2 : 4 neurones de d\u00e9cision (3 entr\u00e9es \u2192 4 sorties)##    Sortie 0 : AVANCE#    Sortie 1 : TOURNE GAUCHE#    Sortie 2 : TOURNE DROITE#    Sortie 3 : STOP## =============================================================================# -----------------------------# Fonctions d'activation# -----------------------------def sigmoid(x):    """    Fonction sigmo\u00efde \u2014 sortie continue dans ]0, 1[.    Utilis\u00e9e dans la couche 1 pour produire un 'niveau d'obstacle' graduel.    """    return 1.0 \/ (1.0 + math.exp(-x))def softmax(vec):    """    Softmax \u2014 transforme un vecteur en distribution de probabilit\u00e9s.    Utilis\u00e9e dans la couche 2 : la somme des 4 sorties vaut 1.    L'action choisie est celle dont la probabilit\u00e9 est la plus haute.    """    e = [math.exp(v) for v in vec]    s = sum(e)    return [v \/ s for v in e]# -----------------------------# Architecture du r\u00e9seau# -----------------------------## Couche 1 \u2014 poids W1[neurone][capteur] et biais B1[neurone]## Chaque neurone de perception combine les capteurs de son c\u00f4t\u00e9.# Valeurs initiales : chaque capteur p\u00e8se pareil, biais nul.##  neurone 0 (gauche) \u2192 capteurs x1, x2#  neurone 1 (devant) \u2192 capteurs x2, x3, x4  (x2 et x4 = flancs proches centre)#  neurone 2 (droite) \u2192 capteurs x4, x5W1 = [    # x1    x2    x3    x4    x5    [0.5,  0.5,  0.0,  0.0,  0.0],   # neurone 0 : gauche    [0.0,  0.33, 0.33, 0.33, 0.0],   # neurone 1 : devant    [0.0,  0.0,  0.0,  0.5,  0.5],   # neurone 2 : droite]B1 = [0.0, 0.0, 0.0]# Couche 2 \u2014 poids W2[action][neurone] et biais B2[action]##  action 0 (AVANCE)         \u2192 r\u00e9compenser l'ABSENCE d'obstacle#  action 1 (TOURNE GAUCHE)  \u2192 obstacle \u00e0 droite, pas \u00e0 gauche#  action 2 (TOURNE DROITE)  \u2192 obstacle \u00e0 gauche, pas \u00e0 droite#  action 3 (STOP)           \u2192 obstacle des deux c\u00f4t\u00e9sW2 = [    # n_gauche  n_devant  n_droite    [-0.5,     -1.0,     -0.5],   # AVANCE       : mauvais score si obstacle    [ 0.0,     -0.5,      1.0],   # TOURNE GAUCHE: obstacle \u00e0 droite    [ 1.0,     -0.5,      0.0],   # TOURNE DROITE: obstacle \u00e0 gauche    [ 0.5,      1.0,      0.5],   # STOP         : obstacles partout]B2 = [0.0, 0.0, 0.0, 0.0]# Taux d'apprentissageeta = 0.1# -----------------------------# Jeu d'entra\u00eenement# -----------------------------## Entr\u00e9es : [x1, x2, x3, x4, x5] normalis\u00e9es dans [0, 1]#   0 = obstacle tr\u00e8s proche   1 = voie libre## Cibles : indice de l'action correcte#   0 = AVANCE   1 = TOURNE GAUCHE   2 = TOURNE DROITE   3 = STOP## R\u00e9partition des capteurs sur le MR25 (vue de dessus) :##        [1]  [2]  [3]  [4]  [5]#         \\    |   (avant)   |    \/#          gauche         droitetraining_data = [    # Voie compl\u00e8tement libre \u2192 AVANCE    ([1.0, 1.0, 1.0, 1.0, 1.0], 0),    # Obstacle devant uniquement \u2192 STOP (pas d'info sur quel c\u00f4t\u00e9 \u00e9viter)    ([0.9, 0.9, 0.1, 0.9, 0.9], 3),    # Obstacle \u00e0 gauche (capteurs 1-2 faibles) \u2192 TOURNE DROITE    ([0.1, 0.2, 0.8, 0.9, 0.9], 2),    ([0.2, 0.1, 1.0, 1.0, 1.0], 2),    # Obstacle \u00e0 droite (capteurs 4-5 faibles) \u2192 TOURNE GAUCHE    ([0.9, 0.9, 0.8, 0.2, 0.1], 1),    ([1.0, 1.0, 1.0, 0.1, 0.2], 1),    # Obstacle sur toute la largeur \u2192 STOP    ([0.1, 0.1, 0.1, 0.1, 0.1], 3),    ([0.2, 0.3, 0.2, 0.3, 0.2], 3),    # Obstacle l\u00e9ger devant-gauche, droite libre \u2192 TOURNE DROITE    ([0.3, 0.4, 0.4, 0.8, 0.9], 2),    # Obstacle l\u00e9ger devant-droite, gauche libre \u2192 TOURNE GAUCHE    ([0.9, 0.8, 0.4, 0.4, 0.3], 1),]# Noms des actions (pour les affichages)ACTIONS = ["AVANCE", "TOURNE GAUCHE", "TOURNE DROITE", "STOP"]# -----------------------------# Propagation avant (forward pass)# -----------------------------def forward(inputs):    """    Calcule la sortie compl\u00e8te du r\u00e9seau pour un vecteur d'entr\u00e9es.    Retourne :      h      \u2014 sorties de la couche 1 (3 valeurs sigmo\u00efdes)      probs  \u2014 distribution softmax de la couche 2 (4 probabilit\u00e9s)      action \u2014 indice de l'action ayant la probabilit\u00e9 la plus haute    """    # --- Couche 1 : neurones de perception ---    h = []    for n in range(3):        z = sum(W1[n][i] * inputs[i] for i in range(5)) + B1[n]        h.append(sigmoid(z))    # --- Couche 2 : neurones de d\u00e9cision ---    logits = []    for a in range(4):        z = sum(W2[a][n] * h[n] for n in range(3)) + B2[a]        logits.append(z)    probs  = softmax(logits)    action = probs.index(max(probs))    return h, probs, action# -----------------------------# Mise \u00e0 jour des poids (r\u00e9tropropagation simplifi\u00e9e)# -----------------------------## On utilise une r\u00e8gle delta adapt\u00e9e au softmax + entropie crois\u00e9e :#   delta_couche2[a] = probs[a] - (1 si a == cible, sinon 0)## Pour la couche 1, on r\u00e9tropropage le gradient \u00e0 travers la sigmo\u00efde :#   delta_couche1[n] = sigmoid'(h[n]) * somme_a(W2[a][n] * delta_c2[a])#   avec sigmoid'(h) = h * (1 - h)def train_step(inputs, target, h, probs):    """    Effectue une mise \u00e0 jour des poids W1, B1, W2, B2    \u00e0 partir d'un exemple (inputs, target).    """    # --- Gradient couche 2 ---    delta2 = [probs[a] - (1.0 if a == target else 0.0) for a in range(4)]    # --- Mise \u00e0 jour W2, B2 ---    for a in range(4):        for n in range(3):            W2[a][n] -= eta * delta2[a] * h[n]        B2[a] -= eta * delta2[a]    # --- Gradient couche 1 (r\u00e9tropropagation) ---    delta1 = []    for n in range(3):        grad = sum(W2[a][n] * delta2[a] for a in range(4))        delta1.append(h[n] * (1.0 - h[n]) * grad)    # --- Mise \u00e0 jour W1, B1 ---    for n in range(3):        for i in range(5):            W1[n][i] -= eta * delta1[n] * inputs[i]        B1[n] -= eta * delta1[n]# -----------------------------# Phase d'apprentissage# -----------------------------print("=" * 50)print("   APPRENTISSAGE DU R\u00c9SEAU DE NEURONES")print("=" * 50)for epoch in range(500):    nb_erreurs = 0    for inputs, target in training_data:        h, probs, action = forward(inputs)        if action != target:            nb_erreurs += 1        train_step(inputs, target, h, probs)    # Affichage toutes les 50 \u00e9poques    if (epoch + 1) % 50 == 0:        print(f"\u00c9poque {epoch + 1:4d} \u2014 erreurs : {nb_erreurs}\/{len(training_data)}")    if nb_erreurs == 0:        print(f"\\nConvergence atteinte \u00e0 l'\u00e9poque {epoch + 1}")        breakprint("\\nPoids finaux \u2014 couche 1 (perception) :")for n, nom in enumerate(["Gauche", "Devant", "Droite"]):    print(f"  Neurone {nom} : w={[f'{v:.3f}' for v in W1[n]]}  b={B1[n]:.3f}")print("\\nPoids finaux \u2014 couche 2 (d\u00e9cision) :")for a, nom in enumerate(ACTIONS):    print(f"  {nom:15s} : w={[f'{v:.3f}' for v in W2[a]]}  b={B2[a]:.3f}")# V\u00e9rification finale sur le jeu d'entra\u00eenementprint("\\nV\u00e9rification sur les donn\u00e9es d'entra\u00eenement :")for inputs, target in training_data:    _, probs, action = forward(inputs)    statut = "\u2713" if action == target else "\u2717"    print(f"  {statut} capteurs={inputs}  attendu={ACTIONS[target]:15s}  obtenu={ACTIONS[action]}")print("\\nD\u00e9marrage du robot dans 5 secondes\u2026")time.sleep(5)# -----------------------------# Pilotage en temps r\u00e9el# -----------------------------SEUIL_MAX = 80.0  # mm \u2014 distance au-del\u00e0 de laquelle la voie est consid\u00e9r\u00e9e libreprint("\\n" + "=" * 50)print("   PILOTAGE EN COURS  (Ctrl+C pour stopper)")print("=" * 50)try:    while True:        # --- Lecture et normalisation des 5 capteurs ---        raw = [MR25.proxSensor(i) for i in range(1, 6)]        inputs = [min(v, SEUIL_MAX) \/ SEUIL_MAX for v in raw]        # --- Inf\u00e9rence ---        h, probs, action = forward(inputs)        # --- Affichage diagnostique ---        obstacle = ["\u2b1b" if v < 0.5 else "\u2b1c" for v in inputs]        print(            f"Capteurs {''.join(obstacle)}  "            f"G={h[0]:.2f} D={h[1]:.2f} Dr={h[2]:.2f}  "            f"\u2192 {ACTIONS[action]}"        )        # --- Commande moteur ---        if action == 0:            MR25.forward(40)        elif action == 1:            MR25.turnLeft(30)        elif action == 2:            MR25.turnRight(30)        else:            MR25.stop()        time.sleep(0.1)  # 10 Hzexcept KeyboardInterrupt:    MR25.stop()    print("\\nArr\u00eat propre.")# end of file<\/code><\/pre> 
         <\/div> <\/div>\n
        <\/div>\n","protected":false},"excerpt":{"rendered":"
        Pr\u00e9sentation Dans cet article nous allons apprendre au robot MR25 \u00e0 \u00e9viter les obstacles en utilisant un r\u00e9seau de neurones. Nous allons coder un r\u00e9seau \u00e0 2 couches, une seule couche (le perceptron) suffit quand le probl\u00e8me est lin\u00e9airement s\u00e9parable, c\u2019est-\u00e0-dire qu\u2019on peut tracer une ligne droite entre les cas \u00ab\u00a0oui\u00a0\u00bb et les cas \u00ab\u00a0non\u00a0\u00bb. …<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-3680","post","type-post","status-publish","format-standard","hentry","category-non-classe"],"_links":{"self":[{"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=\/wp\/v2\/posts\/3680","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=3680"}],"version-history":[{"count":5,"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=\/wp\/v2\/posts\/3680\/revisions"}],"predecessor-version":[{"id":3685,"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=\/wp\/v2\/posts\/3680\/revisions\/3685"}],"wp:attachment":[{"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=3680"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=3680"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.macerobotics.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=3680"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}