Balans tussen exploratie en exploitatie

Reinforcement Learning met Gymnasium in Python

Fouad Trad

Machine Learning Engineer

Trainnen met willekeurige acties

Agent verkent de omgeving
Geen strategie-optimalisatie op basis van geleerde kennis
Agent gebruikt kennis pas na trainen

Afbeelding van een agent in een omgeving

Exploratie-exploitatie-afweging

Balanceert exploratie en exploitatie
Voortdurend verkennen belemmert strategieverbetering
Alleen exploiteren mist onontdekte kansen

Afbeelding van een agent die nieuwe acties verkent om meer beloningen te ontdekken, en zijn kennis probeert te exploiteren terwijl hij mogelijk beloningen mist.

Eetkeuzes

Afbeelding van een restauranttafel.

Epsilon-greedy strategie

Exploreer met kans epsilon

Diagram dat laat zien dat met kans epsilon de agent verkent door een willekeurige actie te kiezen.

Epsilon-greedy strategie

Exploreer met kans epsilon
Exploiteer met kans 1-epsilon
Blijft verkennen terwijl kennis wordt benut

Diagram dat laat zien dat met kans epsilon de agent verkent door een willekeurige actie te kiezen, en met kans 1 - epsilon exploiteert door de beste bekende actie te kiezen.

Epsilon-greedy met afname

Verlaag epsilon in de tijd
Eerst meer exploratie
Later meer exploitatie
Agent vertrouwt steeds meer op opgebouwde kennis

Afbeelding die laat zien hoe epsilon in de tijd afneemt.

Implementatie met 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

Afbeelding met een snapshot van de Frozen Lake-omgeving.

epsilon_greedy() implementeren

def epsilon_greedy(state):

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

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

Epsilon-greedy trainen

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)

Afnemende epsilon-greedy trainen

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)

Strategieën vergelijken

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

Staafdiagram dat laat zien dat de gemiddelde beloning met epsilon-greedy rond 0,02 ligt, terwijl die met afnemende epsilon-greedy rond 0,55 ligt.

Laten we oefenen!

Reinforcement Learning met Gymnasium in Python