Équilibrer exploration et exploitation

Reinforcement Learning avec Gymnasium en Python

Fouad Trad

Machine Learning Engineer

Entraînement avec actions aléatoires

L’agent explore l’environnement
Aucune optimisation de stratégie basée sur l’apprentissage
L’agent utilise ses connaissances une fois l’entraînement terminé

Image montrant un agent dans un environnement

Compromis exploration–exploitation

Équilibre exploration et exploitation
L’exploration continue empêche d’affiner la stratégie
Une exploitation exclusive rate des opportunités inconnues

Image montrant un agent qui essaie d’explorer de nouvelles actions pour découvrir plus de récompenses, et d’exploiter ses connaissances tout en risquant d’en manquer.

Choix au restaurant

Image montrant une table de restaurant.

Stratégie epsilon-greedy

Explorer avec une 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 une probabilité epsilon
Exploiter avec une probabilité 1 - epsilon
Assure une exploration continue tout en utilisant les connaissances

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éduit 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 accumulées

Image montrant la diminution d’epsilon 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 instantané 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   # Exploration rate

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 epsilon-greedy décroissant

epsilon = 1.0   # Exploration rate
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 en 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