Q-learning

Reinforcement Learning avec Gymnasium en Python

Fouad Trad

Machine Learning Engineer

Introduction au Q-learning

Abréviation de quality learning
Technique sans modèle
Apprend la Q-table optimale par interaction

Schéma des étapes du Q-learning : initialiser une Q-table, 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.

Q-learning vs SARSA

SARSA

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

Met à jour selon l’action effectuée
Apprentissage on-policy

Q-learning

Image montrant la formule mathématique de la règle de mise à jour du Q-learning.

Met à jour indépendamment des actions effectuées
Apprentissage off-policy

Implémentation du Q-learning

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 du Q-learning

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

    while not terminated:

        # Sélection d’une action aléatoire
        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 Q-table
        update_q_table(state, action, new_state)

        episode_reward += reward
        state = new_state

    reward_per_random_episode.append(episode_reward)

Mise à jour du Q-learning

Image montrant la formule mathématique de la mise à jour du Q-learning.

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 Q-table 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)

Évaluer le Q-learning

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 en barres montrant que la politique apprise donne un bien meilleur retour (environ 0,26) que la politique aléatoire (environ 0,01).

Passons à la pratique !

Reinforcement Learning avec Gymnasium en Python