Q-learning

Reinforcement Learning med Gymnasium i Python

Fouad Trad

Machine Learning Engineer

Introduktion till Q-learning

Står för quality learning
Modellfri teknik
Lär sig optimal Q-tabell via interaktion

Diagram som visar stegen i Q-learning: initiering av en Q-tabell, val av åtgärd, mottagande av belöning från miljön och uppdatering av tabellen. Agenten fortsätter denna loop tills konvergens uppnås efter ett visst antal episoder.

Q-learning vs. SARSA

SARSA

Bild som visar den matematiska formeln för SARSA:s uppdateringsregel.

Uppdaterar baserat på utförd åtgärd
On-policy-inlärning

Q-learning

Bild som visar den matematiska formeln för Q-learnings uppdateringsregel.

Uppdaterar oberoende av utförda åtgärder
Off-policy-inlärning

Implementering av Q-learning

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


num_episodes = 1000
alpha = 0.1
gamma = 1


num_states, num_actions = env.observation_space.n, env.action_space.n
Q = np.zeros((num_states, num_actions))


reward_per_random_episode = []

Implementering av Q-learning

for episode in range(num_episodes):
    state, info = env.reset()
    terminated = False
    episode_reward = 0

    while not terminated:

        # Random action selection
        action = env.action_space.sample()

        # Take action and observe new state and reward
        new_state, reward, terminated, truncated, info = env.step(action)

        # Update Q-table
        update_q_table(state, action, new_state)

        episode_reward += reward
        state = new_state

    reward_per_random_episode.append(episode_reward)

Uppdatering av Q-learning

Bild som visar den matematiska formeln för Q-learnings uppdateringsregel.

def update_q_table(state, action, reward, new_state):

  old_value = Q[state, action]

  next_max = max(Q[new_state])

  Q[state, action] = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)

Använda policyn

reward_per_learned_episode = []

policy = get_policy()

for episode in range(num_episodes):
    state, info = env.reset()
    terminated = False
    episode_reward = 0
    while not terminated:
        # Select the best action based on learned Q-table
        action = policy[state]
        # Take action and observe new state
        new_state, reward, terminated, truncated, info = env.step(action)
        state = new_state

        episode_reward += reward

    reward_per_learned_episode.append(episode_reward)

Utvärdering av Q-learning

import numpy as np
import matplotlib.pyplot as plt


avg_random_reward = np.mean(reward_per_random_episode)
avg_learned_reward = np.mean(reward_per_learned_episode)


plt.bar(['Random Policy', 'Learned Policy'],
        [avg_random_reward, avg_learned_reward],
        color=['blue', 'green'])

plt.title('Average Reward per Episode')
plt.ylabel('Average Reward')
plt.show()

Bild av ett stapeldiagram som visar att den inlärda policyn ger betydligt högre avkastning (cirka 0,26) än den slumpmässiga policyn (cirka 0,01).

Nu kör vi en övning!

Reinforcement Learning med Gymnasium i Python