Machine Learning - Exemple d'apprentissage par renforcement

Imaginez que vous apprenez à un chiot la commande « sit ». Vous ne lui dites pas directement ce que le mot « sit » signifie, mais vous le guidez plutôt par des récompenses et des punitions.

  • Lorsque le chiot effectue par hasard l'action de s'asseoir, vous lui donnez immédiatement une friandise (récompense）。
  • Quand il fait une bêtise, vous ne lui donnez pas de friandise (punition）。

Après de nombreuses tentatives, le chiot finit par comprendre l'association entre la commande "sit" et l'obtention d'une friandise, et apprend ainsi cette compétence.

Apprentissage par renforcementC'est une méthode d'apprentissage automatique qui permet à un ordinateur (ou agent) d'apprendre à prendre des décisions optimales afin d'obtenir une récompense cumulée maximale grâce à des interactions de type essai-erreur avec l'environnement.

Apprentissage par renforcementIl existe une différence essentielle avec l'apprentissage supervisé (avec des réponses standards) et l'apprentissage non supervisé (recherche d'une structure inhérente dans les données) que nous avons étudiés précédemment. Le cœur de l'apprentissage par renforcement est l'agentetenvironnementinteraction continue entre [l'agent et l'environnement].

Analyse des concepts clés

Avant de plonger dans le code, comprenons quelques concepts clés. Ils sont comme les règles d'un jeu, définissant comment fonctionne le monde de l'apprentissage par renforcement.

  • Agent :L'agent est notre apprenant ou notre décideur. Dans l'analogie ci-dessus, c'est le chiot. Dans un programme, c'est un algorithme chargé d'observer l'environnement, d'effectuer des actions et d'apprendre à partir des résultats.

  • Environnement :L'environnement est le monde extérieur dans lequel l'agent évolue. Il reçoit les actions de l'agent et fournit deux signaux de rétroaction : le nouvel état de l'environnement et la récompense immédiate apportée par l'action.

  • État :Un état est une description de la situation spécifique de l'environnement à un moment donné. Par exemple, dans un jeu de labyrinthe, l'état correspond aux coordonnées de la position actuelle de l'agent.

  • Action :Une action est un choix que l'agent peut faire dans un certain état. Par exemple, dans un labyrinthe, les actions peuvent être haut, bas, gauche ou droite.

  • Récompense :Une récompense est un signal d'évaluation direct provenant de l'environnement pour l'action de l'agent, généralement une valeur numérique.Récompense positiveindique un encouragement,Récompense négativeindique une punition. L'objectif ultime de l'agent est de maximiser larécompense totale (récompense cumulée)。

  • Politique :Une politique est le code de conduite de l'agent. Elle définit quelle action doit être choisie dans chaque état possible. Le processus d'apprentissage est essentiellement le processus d'optimisation de cette politique.

Pour mieux comprendre intuitivement comment ces concepts fonctionnent ensemble, examinons le flux d'interaction de base de l'apprentissage par renforcement :

Cette boucle continue jusqu'à ce qu'un état terminal soit atteint (comme réussir ou échouer au jeu).

Problème classique : Cliff Walking

Pour mettre la théorie en pratique, nous utiliserons un environnement d'exemple classique d'apprentissage par renforcement :CliffWalking-v0(Cliff Walking). Il provient degymnasiumbibliothèque (une branche maintenue de l'OpenAI Gym d'origine).

Description de l'environnement

  • Scénario: un monde en grille 4x12.
  • Point de départ: coin inférieur gauche (coordonnées [3, 0]).
  • Point d'arrivée: coin inférieur droit (coordonnées [3, 11]).
  • Falaise: toutes les positions de la rangée du bas, sauf les points de départ et d'arrivée ([3, 1] à [3, 10]). Tomber de la falaise entraîne une énorme pénalité et un retour au point de départ.
  • Objectif: L'agent doit se déplacer en toute sécurité du point de départ au point d'arrivée tout en évitant de tomber de la falaise.
  • Actions: haut (0), droite (1), bas (2), gauche (3).
  • Récompenses：
    • Chaque pas sur une grille normale : -1 (encourage à atteindre la destination en moins d'étapes)
    • Tomber de la falaise : -100, et l'agent est renvoyé au point de départ
    • Atteindre l'objectif : 0, et met fin à cet épisode

Introduction à l'algorithme : Q-Learning

Nous allons utiliser l'algorithmeQ-Learningpour résoudre ce problème. C'est un algorithme d'apprentissage par renforcementsans modèle, ce qui signifie que l'agent n'a pas besoin de connaître à l'avance les règles sous-jacentes de l'environnement (telles que les probabilités de transition d'état). Il apprend par essais et erreurs continus.

Son cœur est une table appeléeQ-table.

  • LigneLes lignes représentent tous les états possibles.
  • ColonneLes colonnes représentent toutes les actions possibles.
  • La valeur d'une cellule (valeur Q)représente le retour attendu à long terme de l'exécution d'une certaine action dans un certain état.

Le processus d'apprentissage du Q-Learning peut être résumé dans les étapes suivantes. Il montre comment l'agent met à jour ses connaissances (Q-table) à travers une seule expérience :

Formule centrale : équation de Bellman

La base mathématique des mises à jour de la Q-table est l'équation de Bellman, et sa formule de mise à jour est la suivante :

\[ Q(S, A) \leftarrow Q(S, A) + \alpha [R + \gamma \max_{a} Q(S', a) - Q(S, A)] \]

Décomposons chaque partie de cette formule :

Symbole Signification Explication par analogie
\( Q(S, A) \) Valeur Q d'origine de l'action A dans l'état S Votre ancienne évaluation de la décision d'aller tout droit à une intersection
\(\alpha \) Taux d'apprentissage (0 < α ≤ 1) Dans quelle mesure vous faites confiance à cette nouvelle expérience. α=1 signifie remplacer complètement les anciennes connaissances par la nouvelle expérience ; α=0.1 signifie que la nouvelle expérience ne corrige que légèrement les anciennes connaissances
\(R \) Larécompense immédiate Après être allé tout droit, vous constatez que la route est dégagée et recevez un petit retour positif (+1)
\(\gamma \) Facteur d'actualisation (0 ≤ γ < 1) Dans quelle mesure vous valorisez les récompenses futures. γ=0 signifie que vous ne vous souciez que des récompenses immédiates ; γ=0.9 signifie accorder une grande importance aux rendements à long terme
\(\max_{a} Q(S', a) \) La valeur Q maximale parmi toutes les actions possibles dans le nouvel état S' Après être arrivé à la nouvelle intersection, vous évaluez laquelle des options tourner à gauche, tourner à droite ou aller tout droit a le meilleur retour futur
\(R + \gamma \max_{a} Q(S', a)\) Valeur Q cible, représentant une estimation nouvelle et meilleure de la décision actuelle En combinant la récompense immédiate et le meilleur retour futur, une nouvelle évaluation est obtenue pour la décision d'aller tout droit à l'ancienne intersection
\(R + \gamma \max_{a} Q(S', a) - Q(S, A)\) Erreur de différence temporelle, l'écart entre les nouvelles et les anciennes connaissances La différence entre la nouvelle évaluation et l'ancienne. Cette différence motive l'apprentissage.

En termes simples, cette formule permet à l'agent d'utiliserla récompense immédiate + la meilleure estimation actualisée du futurpour réviser continuellement son jugement sur la valeur de la décision actuelle.

Mise en pratique : Écrire un agent Q-Learning

Maintenant, utilisons du code pour implémenter un agent Q-Learning qui résout le problème Cliff Walking.

Étape 1 : Installer et importer les bibliothèques

Tout d'abord, assurez-vous d'avoir installé les bibliothèques nécessaires. Exécutez ce qui suit dans le terminal ou la ligne de commande :

Exemple

pip install gymnasium numpy

Ensuite, importez-les dans un fichier Python :

Exemple

import gymnasium as gym
import numpy as np
import random

Étape 2 : Initialiser l'environnement et la Q-Table

Exemple

# 1. Créer l'environnement
env = gym.make("CliffWalking-v0", render_mode="human") # render_mode="human" est utilisé pour la visualisation

# 2. Obtenir des informations sur l'environnement
n_states = env.observation_space.n  # Nombre total d'états (4*12=48)
n_actions = env.action_space.n      # Nombre total d'actions (4 directions)

# 3. Initialiser la Q-table avec la forme [nombre d'états, nombre d'actions], toutes les valeurs initiales à 0
Q_table = np.zeros((n_states, n_actions))
print(f"Nombre d'états de l'environnement : {n_states}, nombre d'actions : {n_actions}")
print(f"Forme de la Q-table : {Q_table.shape}")

Étape 3 : Définir les hyperparamètres

Les hyperparamètres sont les réglages qui contrôlent le comportement de l'algorithme et doivent être ajustés en fonction du problème.

Exemple

# Définir les hyperparamètres
alpha = 0.1   # Taux d'apprentissage : le degré d'influence des nouvelles informations
gamma = 0.99  # Facteur de remise : importance des récompenses futures
epsilon = 0.1 # Taux d'exploration : probabilité d'effectuer une exploration aléatoire (plutôt que de choisir le meilleur connu)
num_episodes = 500  # Nombre d'épisodes d'entraînement (combien de fois l'agent joue au jeu)

Étape 4 : Implémenter la stratégie ε-greedy

C'est la stratégie centrale pour la prise de décision de l'agent ; elle équilibreExplorationetExploitation。

  • Exploration: sélectionner aléatoirement des actions pour découvrir des stratégies potentiellement meilleures.
  • Exploitation: sélectionner l'action que la Q-table actuelle considère comme optimale pour obtenir le bénéfice maximal.

Exemple

def choose_action(state, Q_table, epsilon):
    """
Sélectionner une action selon la politique ε-greedy.

Paramètres :
state : état actuel
Q_table : table des valeurs Q
epsilon : probabilité d'exploration

Retourne :
action : l'action sélectionnée (0, 1, 2, 3)
    """
    # Générer un nombre aléatoire entre 0 et 1
    if random.uniform(0, 1) < epsilon:
        # Exploration : sélectionner aléatoirement une action
        action = env.action_space.sample()
    else:
        # Exploitation : sélectionner l’action avec la valeur Q la plus élevée dans l’état actuel
        # np.argmax renvoie l’indice de la valeur maximale, c’est-à-dire l’action optimale
        action = np.argmax(Q_table[state])
    return action

Étape 5 : Boucle d’entraînement principale

C’est le processus principal par lequel l’algorithme apprend.

Exemple

# Utilisé pour enregistrer la récompense totale de chaque épisode afin d’observer la progression de l’apprentissage
reward_history = []

for episode in range(num_episodes):
    # Réinitialiser l’environnement et obtenir l’état initial
    state, _ = env.reset()
    total_reward = 0  # Récompense cumulée pour cet épisode
    terminated = False  # Indique si l’état terminal a été atteint (objectif/falaise)
    truncated = False   # Indique si l'épisode s'est terminé pour dépassement de la limite de pas (généralement, cela ne se produira pas dans cet environnement)

    # Boucle d'interaction pour cet épisode jusqu'à la fin du jeu
    while not (terminated or truncated):
        # 1. Sélectionner une action
        action = choose_action(state, Q_table, epsilon)

        # 2. Exécuter l'action et obtenir le retour de l'environnement
        next_state, reward, terminated, truncated, _ = env.step(action)

        # 3. Mettre à jour la table Q (formule de mise à jour centrale du Q-Learning)
        # Obtenir la valeur Q actuelle
        current_q = Q_table[state, action]
        # Calculer la valeur Q cible : récompense immédiate + valeur Q maximale future actualisée
        # Remarque : si l'état suivant est un état terminal, il n'y a pas de valeur Q future
        if terminated:
            target_q = reward
        else:
            target_q = reward + gamma * np.max(Q_table[next_state])

        # Appliquer l'équation de Bellman pour mettre à jour la valeur Q
        Q_table[state, action] = current_q + alpha * (target_q - current_q)

        # 4. Passer à l'état suivant et accumuler la récompense
        state = next_state
        total_reward += reward

    # Enregistrer la récompense totale pour cet épisode
    reward_history.append(total_reward)

    # Afficher la progression tous les 100 épisodes
    if (episode + 1) % 100 == 0:
        avg_reward = np.mean(reward_history[-100:])  # Récompense moyenne sur les 100 derniers épisodes
        print(f"Épisode {episode + 1}, récompense moyenne sur les 100 derniers épisodes : {avg_reward:.2f}")

# Entraînement terminé, fermer l'environnement
env.close()

Étape 6 : Tester l'agent entraîné

Une fois l'entraînement terminé, nous désactivons l'exploration et laissons l'agent exploiter purement les connaissances apprises (Q-table) pour parcourir l'environnement et voir comment il se comporte.

Exemple

print("\n"=== Début du test ===")
# Créer un nouvel environnement de test (vous pouvez omettre render_mode, ou le changer en "human" pour l'affichage)
test_env = gym.make("CliffWalking-v0", render_mode="human")
state, _ = test_env.reset()
test_terminated = False
test_truncated = False
step_count = 0

while not (test_terminated or test_truncated):
    # Lors du test, nous définissons epsilon=0, c'est-à-dire une exploitation pure, aucune exploration
    action = choose_action(state, Q_table, epsilon=0)
    state, reward, test_terminated, test_truncated, _ = test_env.step(action)
    step_count += 1
    print(f"Étape {step_count} : état {state}, action {action}, récompense {reward}")

print(f"Test terminé ! Nombre total d'étapes : {step_count}, récompense totale : {reward} (la récompense pour avoir atteint l'objectif est 0)")
test_env.close()

Résultats d'exécution et analyse

Code complet :

Exemple

import gymnasium as gym
import numpy as np
import random

# =========================
# 1. Créer l'environnement
# =========================
env = gym.make("CliffWalking-v0", render_mode="human")

# =========================
# 2. Obtenir des informations sur l'environnement
# =========================
n_states = env.observation_space.n
n_actions = env.action_space.n

# =========================
# 3. Initialiser la table Q
# =========================
Q_table = np.zeros((n_states, n_actions))

print(f"Nombre d'états de l'environnement : {n_states}")
print(f"Nombre d'actions : {n_actions}")
print(f"Forme de la Q-table : {Q_table.shape}")

# =========================
# 4. Définir les hyperparamètres
# =========================
alpha = 0.1
gamma = 0.99
epsilon = 0.1
num_episodes = 500

# =========================
# 5. politique ε-greedy
# =========================
def choose_action(state, Q_table, epsilon):
    if random.uniform(0, 1) < epsilon:
        return env.action_space.sample()
    return np.argmax(Q_table[state])

# =========================
# 6. Boucle d'entraînement
# =========================
reward_history = []

for episode in range(num_episodes):
    state, _ = env.reset()
    total_reward = 0
    terminated = False
    truncated = False

    while not (terminated or truncated):
        action = choose_action(state, Q_table, epsilon)
        next_state, reward, terminated, truncated, _ = env.step(action)

        current_q = Q_table[state, action]

        if terminated:
            target_q = reward
        else:
            target_q = reward + gamma * np.max(Q_table[next_state])

        Q_table[state, action] = current_q + alpha * (target_q - current_q)

        state = next_state
        total_reward += reward

    reward_history.append(total_reward)

    if (episode + 1) % 100 == 0:
        avg_reward = np.mean(reward_history[-100:])
        print(f"Épisode {episode + 1}, récompense moyenne sur les 100 derniers épisodes : {avg_reward:.2f}")

env.close()

# =========================
# 7. Tester les résultats de l'entraînement
# =========================
print("\n"=== Début du test ===")

test_env = gym.make("CliffWalking-v0", render_mode="human")
state, _ = test_env.reset()
terminated = False
truncated = False
step_count = 0
total_reward = 0

while not (terminated or truncated):
    action = choose_action(state, Q_table, epsilon=0)
    state, reward, terminated, truncated, _ = test_env.step(action)
    step_count += 1
    total_reward += reward
    print(f"Étape {step_count} : état {state}, action {action}, récompense {reward}")

print(f"Test terminé, nombre total d'étapes : {step_count}, récompense totale : {total_reward}")

test_env.close()

Après avoir exécuté tout le code ci-dessus, vous verrez deux phénomènes très intuitifs : l'évolution des récompenses pendant la phase d'entraînement, et le chemin d'action réel de l'agent pendant la phase de test.

1. Phase d'entraînement : les récompenses augmentent progressivement

Pendant l'entraînement, la console affiche la récompense moyenne des 100 derniers épisodes tous les 100 épisodes. Par exemple :

轮次 100, 最近100轮平均奖励: -120.45
轮次 200, 最近100轮平均奖励: -65.32
轮次 300, 最近100轮平均奖励: -32.18
轮次 400, 最近100轮平均奖励: -18.06
轮次 500, 最近100轮平均奖励: -13.94

Vous remarquerez une tendance évidente :La récompense moyenne ne cesse d'augmenter (la valeur absolue des valeurs négatives diminue)。

Qu'est-ce que cela indique ?

  • Au début de l'entraînement, l'agent tombe fréquemment dans la falaise et reçoit un grand nombre de-100pénalités.
  • Au fur et à mesure de l'entraînement, la Q-table apprend progressivement « quels chemins sont dangereux et lesquels sont sûrs ».
  • L'agent commence à éviter de manière proactive la falaise et à choisir un itinéraire sûr plus long, mais avec des pénalités plus faibles.

L'amélioration des récompenses reflète essentiellement l'amélioration de la qualité de la politique.

2. Phase de test : performances comportementales de l'agent

Dans la phase de test, nous fixonsepsilonε à 0, ce qui signifie :

  • Ne plus effectuer aucune exploration aléatoire
  • Agir entièrement selon la politique optimale apprise dans la Q-table

Si vous l'avez activérender_mode="human", vous verrez un comportement très typique :

  • L'agent part du point de départ
  • Se déplace horizontalement à une position une cellule au-dessus de la falaise
  • Puis se déplace vers le bas lorsqu'il s'approche de l'objectif, l'atteignant en toute sécurité

C'est exactement ce qui est considéré dans l'environnement CliffWalking comme la politiqueoptimale：

  • pas le chemin le plus court (en rasant la falaise)
  • mais plutôtlechemin de pénalité attendue minimale

Cela reflète une caractéristique essentielle de l'apprentissage par renforcement :Il recherche des rendements cumulés à long terme, et non l'optimalité à court terme。

3. Pourquoi a-t-il appris à faire un détour au lieu de prendre le chemin direct risqué ?

C’est une question très importante et aussi très classique.

D’après l’intuition humaine, marcher le long de la falaise est le chemin le plus court, mais pour l’agent :

  • En cas d’un seul faux pas, il reçoit immédiatement-100une énorme pénalité.
  • En comparaison, faire quelques pas supplémentaires n’entraîne que quelques pénalités de plus.-1

Sous l’effet cumulatif de l’équation de Bellman :

De petites pertes régulières < de grands désastres occasionnels

Par conséquent, Q-Learning convergera naturellement vers une politique plus conservatrice avec un rendement attendu global plus élevé.

Problèmes courants et effets des paramètres

1. Que se passe-t-il si le taux d’apprentissage α est trop grand ou trop petit ?

  • α trop grand: le processus d’apprentissage oscille, la politique est instable et il remet facilement en cause l’expérience existante de façon répétée
  • α trop petit: l’apprentissage est très lent et nécessite de nombreux épisodes pour converger

Dans cet exemple,0.1est un choix relativement sûr.

2. Signification intuitive du facteur d'actualisation γ

  • γ → 0: l'agent ne se soucie que des récompenses immédiates et devient facilement myope
  • γ → 1: l'agent accorde une grande importance aux conséquences à long terme et ressemble davantage à un planificateur prévoyant

Dans le problème de la marche le long de la falaise, un γ plus grand aide l'agent à comprendre que faire un pas supplémentaire maintenant sert à éviter des pertes plus importantes à l'avenir.

3. Le rôle essentiel de ε

εIl détermine la personnalité de l'agent :

  • ε grand → aime prendre des risques, explore davantage
  • ε petit → conservateur, exploite davantage l'expérience existante

Dans les projets réels, nous utilisons généralementune stratégie de décroissance de ε :：

  • explorer davantage dans la phase initiale
  • et converger progressivement vers une politique stable dans la phase ultérieure

Limites de cet exemple et pistes d'extension

Bien que Q-Learning soit un classique, il présente également des limites évidentes :

  • La taille de la Q-table augmente linéairement avec l'espace d'états
  • Ne peut pas gérer directement les états continus (comme le monde physique réel)
  • Converge lentement dans les environnements complexes

C'est pourquoi, dans des problèmes plus complexes, nous introduisons :

  • Deep Q-Network（DQN）
  • Policy Gradient
  • Actor-Critic

Ils utilisent des réseaux de neurones pour remplacer la Q-table, ce qui permet d'appliquer l'apprentissage par renforcement à des scénarios du monde réel tels que les jeux, le contrôle de robots et la conduite autonome.

Résumé

Grâce à cet exemple complet d'apprentissage par renforcement, vous avez :

  1. Compris la différence fondamentale entre l'apprentissage par renforcement et l'apprentissage supervisé / non supervisé
  2. Maîtrisé la boucle fermée complète de l'agent, de l'environnement, de l'état, de l'action, de la récompense et de la politique
  3. Implémenté à la main un agent Q-Learning exécutable, observable et convergent
  4. Compris l'idée centrale de l'apprentissage par renforcement : maximiser les retours à long terme
Extensions supplémentaires