Apprentissage Q

Reinforcement Learning avec Gymnasium en Python

Fouad Trad

Machine Learning Engineer

Introduction à l'apprentissage Q

Abréviation de quality learning
Méthode sans modèle
Apprend une table Q optimale par interaction

Schéma des étapes de l'apprentissage Q : initialiser une table Q, choisir une action, recevoir une récompense de l'environnement, puis mettre à jour la table. L'agent boucle jusqu'à convergence après un certain nombre d'épisodes.

Apprentissage Q vs SARSA

SARSA

Image montrant la formule mathématique de la mise à jour SARSA.

Mise à jour selon l'action effectuée
Apprenant « on-policy »

Apprentissage Q

Image montrant la formule mathématique de la règle de mise à jour de l'apprentissage Q.

Mise à jour indépendante des actions prises
Apprenant « off-policy »

Implémentation de l'apprentissage Q

env = gym.make("FrozenLake", is_slippery=True)


num_episodes = 1000
alpha = 0.1
gamma = 1


num_states, num_actions = env.observation_space.n, env.action_space.n
Q = np.zeros((num_states, num_actions))


reward_per_random_episode = []

Implémentation de l'apprentissage Q

for episode in range(num_episodes):
    state, info = env.reset()
    terminated = False
    episode_reward = 0

    while not terminated:

        # Sélection aléatoire d'une action
        action = env.action_space.sample()

        # Exécuter l'action et observer le nouvel état et la récompense
        new_state, reward, terminated, truncated, info = env.step(action)

        # Mettre à jour la table Q
        update_q_table(state, action, new_state)

        episode_reward += reward
        state = new_state

    reward_per_random_episode.append(episode_reward)

Mise à jour Q-learning

Image montrant la formule mathématique de la règle de mise à jour de l'apprentissage Q.

def update_q_table(state, action, reward, new_state):

  old_value = Q[state, action]

  next_max = max(Q[new_state])

  Q[state, action] = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)

Utiliser la politique

reward_per_learned_episode = []

policy = get_policy()

for episode in range(num_episodes):
    state, info = env.reset()
    terminated = False
    episode_reward = 0
    while not terminated:
        # Sélectionner la meilleure action selon la table Q apprise
        action = policy[state]
        # Exécuter l'action et observer le nouvel état
        new_state, reward, terminated, truncated, info = env.step(action)
        state = new_state

        episode_reward += reward

    reward_per_learned_episode.append(episode_reward)

Évaluation de l'apprentissage Q

import numpy as np
import matplotlib.pyplot as plt


avg_random_reward = np.mean(reward_per_random_episode)
avg_learned_reward = np.mean(reward_per_learned_episode)


plt.bar(['Random Policy', 'Learned Policy'],
        [avg_random_reward, avg_learned_reward],
        color=['blue', 'green'])

plt.title('Average Reward per Episode')
plt.ylabel('Average Reward')
plt.show()

Image d'un diagramme à barres montrant que la politique apprise procure un rendement bien plus élevé (environ 0,26) que la politique aléatoire (environ 0,01).

Passons à la pratique !

Reinforcement Learning avec Gymnasium en Python