Echilibrul dintre explorare și exploatare

Reinforcement Learning cu Gymnasium în Python

Fouad Trad

Machine Learning Engineer

Antrenament cu acțiuni aleatoare

Agentul explorează mediul
Nicio optimizare a strategiei pe baza cunoștințelor acumulate
Agentul folosește cunoștințele după finalizarea antrenamentului

Imagine cu un agent într-un mediu

Compromisul explorare-exploatare

Echilibrează explorarea și exploatarea
Explorarea continuă împiedică rafinarea strategiei
Exploatarea exclusivă ratează oportunități nedescoperite

Imagine cu un agent care încearcă să exploreze acțiuni noi pentru a descoperi mai multe recompense și să exploateze cunoștințele sale, riscând să rateze unele recompense.

Alegeri la restaurant

Imagine cu o masă de restaurant.

Strategia epsilon-greedy

Explorează cu probabilitatea epsilon

Diagramă care arată că, cu probabilitatea epsilon, agentul explorează alegând o acțiune aleatorie.

Strategia epsilon-greedy

Explorează cu probabilitatea epsilon
Exploatează cu probabilitatea 1-epsilon
Asigură explorare continuă, folosind cunoștințele acumulate

Diagramă care arată că, cu probabilitatea epsilon, agentul explorează alegând o acțiune aleatorie, iar cu probabilitatea 1 - epsilon, exploatează selectând cea mai bună acțiune cunoscută.

Strategia epsilon-greedy cu descreștere

Reduce epsilon în timp
Mai multă explorare inițial
Mai multă exploatare ulterior
Agentul se bazează din ce în ce mai mult pe cunoștințele acumulate

Imagine care arată cum epsilon scade în timp.

Implementare cu 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

Imagine cu un instantaneu al mediului Frozen Lake.

Implementarea 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

Antrenament 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)

Antrenament epsilon-greedy cu descreștere

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)

Compararea strategiilor

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()

Imagine cu un grafic cu bare care arată că recompensa medie obținută cu epsilon-greedy este în jur de 0,02, iar cea obținută cu epsilon-greedy cu descreștere este în jur de 0,55.

Să exersăm!

Reinforcement Learning cu Gymnasium în Python