强化学习Q-learning实践

1. 引言

前篇文章介绍了强化学习系统红的基本概念和重要组成部分,并解释了Q-learning算法相关的理论知识。本文的目标是在Python3中实现该算法,并将其应用于实际的实验中。
闲话少说,我们直接开始吧!

2. Taxi-v3 Env

为了使本文具有实际具体的意义,特意选择了一个简单而基本的环境,可以让大家充分欣赏Q-learning算法的优雅。我们选择的环境是OpenAI GymTaxi-v3,该环境简单明了,是强化学习RL领域的优秀入门样例。实际上Taxi-v3由一个grid map组成,如下图示:
强化学习Q-learning实践_第1张图片

其中,该环境下的agent是一名出租车司机,他必须接客户(红色小人)并将其送到目的地(图中的小房子)。

3. States

一版来说,States的作用如下 (1) 确定action(2)计算执行action的奖励reward(3)计算到下一状态的转换所需的信息。

观察上图,我们的网格grid map的大小为5x5,所以出租车所有可能的选择有25个。除此之外,等待接车的乘客可以在四个可能的接车点(标记为Y、R、G、B)处等待当然也可以在出租车里,所以乘客所有可能的选择有(4+1)个;最后,乘客的目的地在(Y、R、G、B)四个中的一个,所以乘客的目的地共有4个选择,图示如下:
强化学习Q-learning实践_第2张图片

综上,我们用以下向量表示States

State = [x_pos_taxi, y_pos_taxi, pos_passenger, dest_passenger]

进而,我们agentStates一共有5X5X5X4=500个,可以被编码为0到499之间的整数。其实,实际可用的状态的数量略小于500,例如,乘客将永远不会有相同的乘车点和目的地。由于建模的复杂性,我们通常关注完整的状态空间。

4. 举个栗子

上述文字讲完后,有些同学还是有很多不理解的东东,那我们来找个中间过程来看看,如下:
强化学习Q-learning实践_第3张图片
上图中,STATE:(2,1,0,1)表示,当前出租车在grid map中的第二行第一列,同时乘客的状态选择为0表示位于乘客位于红色格子里等待乘车,同时乘客的目的地状态选择为1表示乘客的目的地为绿色格子。
进而,下图中的STATE:(3,4,4,0)表示,当前出租车在grid map中的第三行第四列,同时乘客的状态选择为4表示此时乘客位于出租车里,同时乘客的目的地状态选择为0 ,表示乘客的目的地为红色格子。

看到这里的童鞋,请仔细理解上述两个例子。

5. Action space

至于该环境Envagent的动作空间Action space,我们可以想象,代理agent可以使用以下离散动作来与环境交互:向前、向后、向右、向左、接乘客和送乘客。这使得总共有6个可能的动作,这些动作依次以0到5的数字编码,以便于编程。动作和数字之间的对应关系如图1所示。
强化学习Q-learning实践_第4张图片

6. Rewards

至于agent执行的每一步action所获得的奖励reward,做如下约定:

  • 移动:-1, 表示每一步都会受到一点惩罚,以鼓励从出发地到目的地走最短的路。
  • 错误运送:-10, 表示当乘客被送到到错误的位置时,乘客自然会不高兴,所以惩罚大一些是合适的。
  • 成功送达:20,表示出租车司机成功完成了任务,鼓励相应的行为,因此产生了正向的reward

7. Initialization

在数学上定义了这个问题之后,我们接着将着手用代码实现。首先,我们安装必要的库,然后导入它们。显然,我们需要安装gym 环境。除此之外,我们只需要一些可视化的东西和常见的数据处理库。

"""install libraries"""
!pip install cmake 'gym[atari]' scipy pygame

"""Import libraries"""
import gym
import numpy as np
import matplotlib.pyplot as plt
import random
from IPython.display import clear_output
from time import sleep
from matplotlib import animation

接着,我们使用以下代码来创建和渲染Taxi-v3环境。

"""Initialize and validate the environment"""
env = gym.make("Taxi-v3", render_mode="rgb_array").env
state, _ = env.reset()

# Print dimensions of state and action space
print("State space: {}".format(env.observation_space))
print("Action space: {}".format(env.action_space))

# Sample random action
action = env.action_space.sample(env.action_mask(state))
next_state, reward, done, _, _ = env.step(action)

# Print output
print("State: {}".format(state))
print("Action: {}".format(action))
print("Action mask: {}".format(env.action_mask(state)))
print("Reward: {}".format(reward))

# Render and plot an environment frame
frame = env.render()
plt.imshow(frame)
plt.axis("off")
plt.show()

结果如下:
强化学习Q-learning实践_第5张图片

8. 测试随机agent

在上述环境Env按照预期开始工作后,此时我们可以随机让代理疯狂运行了。我们不妨让我们的agent在任何时刻都会采取随机行动,来看看会产生怎样的效果。

"""Simulation with random agent"""
epoch = 0
num_failed_dropoffs = 0
experience_buffer = []
cum_reward = 0

done = False

state, _ = env.reset()

while not done:
    # Sample random action
    "Action selection without action mask"
    action = env.action_space.sample()

    "Action selection with action mask"
    #action = env.action_space.sample(env.action_mask(state))

    state, reward, done, _, _ = env.step(action)
    cum_reward += reward

    # Store experience in dictionary
    experience_buffer.append({
        "frame": env.render(),
        "episode": 1,
        "epoch": epoch,
        "state": state,
        "action": action,
        "reward": cum_reward,
        }
    )

    if reward == -10:
        num_failed_dropoffs += 1

    epoch += 1

# Run animation and print console output
run_animation(experience_buffer)

print("# epochs: {}".format(epoch))
print("# failed drop-offs: {}".format(num_failed_dropoffs))

运行上述代码后,得到结果如下:
强化学习Q-learning实践_第6张图片
为什么要看完上述冗长的动画?好吧,这确实给人一种印象,一个未经训练的RL模型下的agent是如何表现的,以及需要多长时间才能获得有意义的reward

9. 训练agent

接着,我们来尝试训练我们的agent,我们知道Q值是在进行观测之后使用以下等式进行更新的。
在这里插入图片描述

请注意,对于500个状态和6个动作,我们必须填写一个大小为500*6=3000的Q表,每个状态-动作二元组需要多次观察才能学到有用的知识。相应的训练代码如下:

"""Training the agent"""
q_table = np.zeros([env.observation_space.n, env.action_space.n])

# Hyperparameters
alpha = 0.1  # Learning rate
gamma = 1.0  # Discount rate
epsilon = 0.1  # Exploration rate
num_episodes = 10000  # Number of episodes

# Output for plots
cum_rewards = np.zeros([num_episodes])
total_epochs = np.zeros([num_episodes])

for episode in range(1, num_episodes+1):
    # Reset environment
    state, info = env.reset()
    epoch = 0 
    num_failed_dropoffs = 0
    done = False
    cum_reward = 0

    while not done:
        
        if random.uniform(0, 1) < epsilon:
            "Basic exploration [~0.47m]"
            action = env.action_space.sample() # Sample random action (exploration)
            
            "Exploration with action mask [~1.52m]"
          # action = env.action_space.sample(env.action_mask(state)) "Exploration with action mask"
        else:      
            "Exploitation with action mask [~1m52s]"
           # action_mask = np.where(info["action_mask"]==1,0,1) # invert
           # masked_q_values = np.ma.array(q_table[state], mask=action_mask, dtype=np.float32)
           # action = np.ma.argmax(masked_q_values, axis=0)

            "Exploitation with random tie breaker [~1m19s]"
          #  action = np.random.choice(np.flatnonzero(q_table[state] == q_table[state].max()))
            
            "Basic exploitation [~47s]"
            action = np.argmax(q_table[state]) # Select best known action (exploitation)
 
        next_state, reward, done, _ , info = env.step(action) 

        cum_reward += reward
        
        old_q_value = q_table[state, action]
        next_max = np.max(q_table[next_state])
        
        new_q_value = (1 - alpha) * old_q_value + alpha * (reward + gamma * next_max)
        
        q_table[state, action] = new_q_value
        
        if reward == -10:
            num_failed_dropoffs += 1

        state = next_state
        epoch += 1
        
        total_epochs[episode-1] = epoch
        cum_rewards[episode-1] = cum_reward

    if episode % 100 == 0:
        clear_output(wait=True)
        print(f"Episode #: {episode}")

print("\n")
print("===Training completed.===\n")

# Plot reward convergence
plt.title("Cumulative reward per episode")
plt.xlabel("Episode")
plt.ylabel("Cumulative reward")
plt.plot(cum_rewards)
plt.show()

# Plot epoch convergence
plt.title("# epochs per episode")
plt.xlabel("Episode")
plt.ylabel("# epochs")
plt.plot(total_epochs)
plt.show()

在2000个episode 之后,我们似乎学到了一个相当好的模型,如下:
强化学习Q-learning实践_第7张图片
上图图像中,横坐标表示我们一共训练了10000Episode,纵坐标表示每一个Episode下,出租车司机将乘客送达目的地所需要的移动步数epochs

10. 验证训练效果

最后,让我们看看我们的模型学到了什么。根据我们所处的状态,我们在Q表中查找相应的Q值(即,每个状态对应于动作的六个值),并选择具有最高相关Q值的动作。代码如下:

"""Test policy performance after training"""

num_epochs = 0
total_failed_deliveries = 0
num_episodes = 1
experience_buffer = []
store_gif = True

for episode in range(1, num_episodes+1):
    # Initialize experience buffer

    my_env = env.reset()
    state = my_env[0]
    epoch = 1 
    num_failed_deliveries =0
    cum_reward = 0
    done = False

    while not done:
        action = np.argmax(q_table[state])
        state, reward, done, _, _ = env.step(action)
        cum_reward += reward

        if reward == -10:
            num_failed_deliveries += 1

        # Store rendered frame in animation dictionary
        experience_buffer.append({
            'frame': env.render(),
            'episode': episode,
            'epoch': epoch,
            'state': state,
            'action': action,
            'reward': cum_reward
            }
        )

        epoch += 1

    total_failed_deliveries += num_failed_deliveries
    num_epochs += epoch

    if store_gif:
        store_episode_as_gif(experience_buffer)

# Run animation and print output
run_animation(experience_buffer)

# Print final results
print("\n") 
print(f"Test results after {num_episodes} episodes:")
print(f"Mean # epochs per episode: {num_epochs / num_episodes}")
print(f"Mean # failed drop-offs per episode: {total_failed_deliveries / num_episodes}")

结果如下:
强化学习Q-learning实践_第8张图片

可以看到,在执行了足够多的迭代之后,我们可以发现出租车总是直接驶向乘客,走最短的路到达目的地,并成功地将乘客放下。

11. 总结

本文通过具体的应用,来对前篇Q-learning的理论知识用代码进行了详细的说明,主要通过业内知名的Taxi-v3环境进行了讲解,并给出了完整的代码示例。

您学废了嘛?

你可能感兴趣的:(人工智能,算法,强化学习,Q-learning)