Équilibrer exploration et exploitation

Reinforcement Learning avec Gymnasium en Python

Fouad Trad

Machine Learning Engineer

Entraîner avec des actions aléatoires

L'agent explore l'environnement
Aucune optimisation de stratégie selon les acquis
L'agent utilise ses acquis une fois l'entraînement terminé

Image montrant un agent dans un environnement

Compromis exploration–exploitation

Équilibre exploration et exploitation
Exploration continue empêche d'affiner la stratégie
Exploitation seule rate des occasions non découvertes

Image montrant qu'un agent tente d'explorer de nouvelles actions pour découvrir plus de récompenses et d'exploiter ses connaissances tout en risquant d'en manquer.

Choisir où manger

Image montrant une table de restaurant.

Stratégie epsilon-greedy

Explorer avec la probabilité epsilon

Schéma montrant qu'avec une probabilité epsilon, l'agent explore en choisissant une action aléatoire.

Stratégie epsilon-greedy

Explorer avec la probabilité epsilon
Exploiter avec la probabilité 1 - epsilon
Assure une exploration continue tout en utilisant les acquis

Schéma montrant qu'avec une probabilité epsilon, l'agent explore en choisissant une action aléatoire, et avec une probabilité de 1 - epsilon, il exploite en sélectionnant la meilleure action connue.

Stratégie epsilon-greedy décroissante

Réduire epsilon au fil du temps
Plus d'exploration au début
Plus d'exploitation ensuite
L'agent s'appuie de plus en plus sur ses connaissances

Image montrant comment epsilon diminue au fil du temps.

Implémentation avec Frozen Lake

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

action_size = env.action_space.n
state_size = env.observation_space.n
Q = np.zeros((state_size, action_size))


alpha = 0.1
gamma = 0.99
total_episodes = 10000

Image montrant un aperçu de l'environnement Frozen Lake.

Implémenter epsilon_greedy()

def epsilon_greedy(state):

    if np.random.rand() < epsilon:
        action = env.action_space.sample()  # Explore

    else:
        action = np.argmax(Q[state, :])  # Exploit
    return action

Entraîner epsilon-greedy

epsilon = 0.9   # Taux d'exploration

rewards_eps_greedy = []

for episode in range(total_episodes):
    state, info = env.reset()
    terminated = False
    episode_reward = 0
    while not terminated:
        action = epsilon_greedy(state)
        new_state, reward, terminated, truncated, info = env.step(action)       
        Q[state, action] = update_q_table(state, action, new_state) 
        state = new_state

        episode_reward += reward
    rewards_eps_greedy.append(episode_reward)

Entraîner avec epsilon-greedy décroissant

epsilon = 1.0   # Taux d'exploration
epsilon_decay = 0.999
min_epsilon = 0.01

rewards_decay_eps_greedy = []
for episode in range(total_episodes):
    state, info = env.reset()
    terminated = False
    episode_reward = 0
    while not terminated:
        action = epsilon_greedy(state)
        new_state, reward, terminated, truncated, info = env.step(action)
        episode_reward += reward        
        Q[state, action] = update_q_table(state, action, new_state) 
        state = new_state
    rewards_decay_eps_greedy.append(episode_reward)

    epsilon = max(min_epsilon, epsilon * epsilon_decay)

Comparer les stratégies

avg_eps_greedy= np.mean(rewards_eps_greedy)
avg_decay = np.mean(rewards_decay_eps_greedy)
plt.bar(['Epsilon Greedy', 'Decayed Epsilon Greedy'],
        [avg_eps_greedy, avg_decay], 
        color=['blue', 'green'])
plt.title('Average Reward per Episode')
plt.ylabel('Average Reward')
plt.show()

Image d'un diagramme à barres montrant que la récompense moyenne obtenue avec epsilon-greedy est d'environ 0,02, tandis qu'avec epsilon-greedy décroissant elle est d'environ 0,55.

Passons à la pratique !

Reinforcement Learning avec Gymnasium en Python