Réalisation d'une IA jouant au jeu Taxi avec Q-Learning

Présentation du jeu Taxi

Le jeu Taxi est un environnement de type toy text disponible dans Gymnasium. Le but est simple :

• Un taxi doit récupérer un passager à un emplacement donné, puis le déposer à une destination précise dans une grille.
• Le taxi peut se déplacer dans quatre directions (nord, sud, est, ouest) et a la capacité de prendre ou déposer un passager.
• L’agent reçoit des récompenses négatives à chaque action (pour encourager la rapidité) et une récompense positive lorsqu’il dépose le passager à la bonne destination.

Cet environnement est idéal pour débuter avec le Q-Learning, car il est suffisamment simple pour être compris, mais assez complexe pour illustrer les défis du Reinforcement Learning.

Principe du Q-Learning

Le Q-Learning est un algorithme d’apprentissage par renforcement qui permet à un agent d’apprendre une politique optimale en interagissant avec son environnement. L’idée est d’apprendre une table de valeurs Q(s,a), où :

• Q(s,a) représente la valeur d’une action a dans un état s.
• L’agent met à jour cette table en utilisant la récompense immédiate et une estimation de la valeur future des états.

La formule de mise à jour de Q est la suivante :

$$Q(s,a)\leftarrow Q(s,a)+\alpha \left[r+\gamma \underset{a^{\prime }}{\max }Q(s^{\prime },a^{\prime })-Q(s,a)\right]$$

• $\alpha$ : taux d’apprentissage (learning rate)
• $\gamma$ : facteur d’escompte (discount factor)
• r : récompense reçue après l’action
• s′ : nouvel état après l’action

Étapes pour réaliser l’IA

Initialisation de l’environnement et des paramètres

On commence par importer les bibliothèques nécessaires et initialiser deux environnements :

• Un pour l’entraînement (sans rendu visuel).
• Un autre pour l’évaluation (avec rendu visuel).

import gymnasium as gym
import numpy as np

# Initialisation des environnements
env = gym.make("Taxi-v3")
eval_env = gym.make("Taxi-v3", render_mode="human")  # Pour visualiser l'agent en action

# Nombre d'états et d'actions possibles
state_space = env.observation_space.n  # 500 états possibles
action_space = env.action_space.n      # 6 actions possibles

# Initialisation de la table Q avec des zéros
Q_table = np.zeros((state_space, action_space))

# Hyperparamètres
alpha = 0.1        # Taux d'apprentissage
gamma = 0.5        # Facteur d'escompte (importance des récompenses futures)
epsilon = 1.0      # Probabilité d'exploration (100% au début)
epsilon_dim = 0.999 # Décroissance de epsilon à chaque épisode
epsilon_min = 0.001 # Valeur minimale de epsilon

Boucle d’entraînement

Pour chaque épisode, l’agent interagit avec l’environnement en choisissant des actions selon une stratégie $ϵ$ -gloutonne :

• Exploration : Avec une probabilité $ϵ$, l’agent choisit une action aléatoire.
• Exploitation : Sinon, il choisit l’action avec la plus grande valeur Q pour l’état courant.

À chaque étape, la table Q est mise à jour selon la formule du Q-Learning.

for ep in range(10000):
    terminated = False
    truncated = False

    # Utilisation de l'environnement d'évaluation pour les 10 derniers épisodes
    if ep >= 9990:
        observation, info = eval_env.reset()
        current_env = eval_env
    else:
        observation, info = env.reset()
        current_env = env

    while not (terminated or truncated):
        # Stratégie epsilon-gloutonne
        if np.random.uniform(0, 1) < epsilon:
            # Exploration : action aléatoire
            action = current_env.action_space.sample()
        else:
            # Exploitation : action avec la meilleure valeur Q
            valid_actions = np.where(info["action_mask"] == 1)[0]  # Actions valides
            q_values = Q_table[observation, valid_actions]
            action = valid_actions[np.argmax(q_values)]

        # Exécution de l'action
        next_state, reward, terminated, truncated, info = current_env.step(action)
        print("Récompense :", reward)

        # Mise à jour de la table Q
        Q_table[observation, action] = (1 - alpha) * Q_table[observation, action] + alpha * (reward + gamma * np.max(Q_table[next_state]))

        # Passage à l'état suivant
        observation = next_state

    # Décroissance de epsilon
    epsilon = max(epsilon_min, epsilon * epsilon_dim)

Points à retenir

• Exploration vs Exploitation : Le paramètre $ϵ$ permet de trouver un équilibre entre découvrir de nouvelles stratégies et exploiter les connaissances acquises.
• Décroissance de $ϵ$ : $ϵ$ diminue exponentiellement pour favoriser l’exploitation en fin d’entraînement.
• Actions valides : Le masque d’actions (action_mask) évite de choisir des actions invalides dans certains états.