Exploration und Exploitation ausbalancieren

Reinforcement Learning mit Gymnasium in Python

Fouad Trad

Machine Learning Engineer

Training mit zufälligen Aktionen

Agent erkundet die Umgebung
Keine Strategieoptimierung aus gelerntem Wissen
Agent nutzt Wissen erst nach dem Training

Bild: Ein Agent in einer Umgebung

Exploration–Exploitation-Trade-off

Balanciert Exploration und Exploitation
Ständige Exploration verhindert Strategieverbesserung
Reine Exploitation verpasst unbekannte Chancen

Bild: Ein Agent versucht, neue Aktionen zu erkunden, um mehr Belohnungen zu finden, und sein Wissen auszunutzen, wobei er evtl. Belohnungen verpasst.

Essenswahl

Bild eines Restauranttischs.

Epsilon-gierige Strategie

Mit Wahrscheinlichkeit Epsilon: explorieren

Diagramm: Mit Wahrscheinlichkeit Epsilon exploriert der Agent und wählt eine zufällige Aktion.

Epsilon-gierige Strategie

Mit Wahrscheinlichkeit Epsilon: explorieren
Mit Wahrscheinlichkeit 1−Epsilon: ausnutzen
Sichert fortlaufende Exploration bei Wissensnutzung

Diagramm: Mit Wahrscheinlichkeit Epsilon wählt der Agent eine zufällige Aktion (exploriert), mit 1 − Epsilon wählt er die beste bekannte Aktion (nutzt aus).

Abnehmende Epsilon-gierige Strategie

Epsilon nimmt mit der Zeit ab
Anfangs mehr Exploration
Später mehr Exploitation
Agent stützt sich zunehmend auf gesammeltes Wissen

Bild zeigt, wie Epsilon über die Zeit sinkt.

Implementierung mit 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

Bild: Snapshot der Frozen-Lake-Umgebung.

epsilon_greedy() implementieren

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-gierig trainieren

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)

Abnehmend epsilon-gierig trainieren

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)

Strategien vergleichen

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

Balkendiagramm: Durchschnittliche Belohnung mit Epsilon-gierig ca. 0,02, mit abnehmend Epsilon-gierig ca. 0,55.

Lass uns üben!

Reinforcement Learning mit Gymnasium in Python