第三章、基于表格方法求RL(2)-Q-learning

主要内容为题主在学习机器学习时记录的内容

文章目录

• 第三章、基于表格方法求RL(2)-Q-learning
• 一、On-Policy与Off-Policy
• • 1.1 On-Policy
  • 1.2 Off-Policy
  • 1.3 对比
• 二、Q-learning
• • 2.1 Q-learning介绍
  • 2.2 概念
  • • 2.2.1 更新公式
    • 2.2.2 Target
    • 2.2.3 算法流程
  • 2.3 代码
  • • 2.3.1 agent
    • 2.3.2 learn函数
• 三、代码样例
• • 3.1 情景描述
  • 3.1 代码
  • 3.2 运行结果

一、On-Policy与Off-Policy

1.1 On-Policy

即行为策略与目标策略相同，它的特点是：the target and the behavior polices are the same。 Sarsa 就是一种典型的 On-Policy，他优化的是他实际上执行的策略，直接拿下一步一定会执行的action来优化表格。
所以只用一种策略来做action选取和优化。
它最终的结果为，即使下一步会有随机动作，但仍然在安全范围内。

1.2 Off-Policy

与 On-Policy 不同的是，Off-Policy保留了两种策略，一个为希望得到的目标策略：Target policy，另外一个为探索环境的行为策略：Behavior policy，它可以大胆的探索数据，且将结果喂给目标策略进行学习。
注意，这里返回的数据为（St,At,Rt+1,St+1），没有A。即目标策略优化时，不管下一步的操作是什么。

行为策略就像一个天不怕地不怕的调查展示，无所畏惧的对每一种操作进行调查，然后将结果反馈给军师-目标策略。军师可以根据经验进行学习，不需要与环境进行交互。

1.3 对比

因为 Off-Policy 使用了目标策略和行为策略，所以他可以大胆地使用行为策略去探索，而使用目标策略来学习择优。

二、Q-learning

2.1 Q-learning介绍

Q-learning 是一种典型的 On-policy 策略。Q-learning也是采用Q表格的方式存储Q值（状态动作价值），决策部分与Sarsa是一样的，采用ε-greedy方式增加探索。
Q-learning跟Sarsa不一样的地方是更新Q表格的方式。Sarsa是on-policy的更新方式，先做出动作再更新。Q-learning是off-policy的更新方式，更新learn()时无需获取下一步实际做出的动作next_action，并假设下一步动作是取最大Q值的动作。

2.2 概念

2.2.1 更新公式

更新公式与Sarsa的更新公式并没有太大的区别。

2.2.2 Target

他们的区别主要在 Target 的计算上。

Sarsa使用自己的策略来产生 S-A-R-S’-A’ 这条道路，然后用Q去更新Q值。
而Q-learning 则默认下一个动作为Q最大的动作，即使可能有几率选择其他的动作。
即Q-learning其实更大胆，更贪心。

2.2.3 算法流程

2.3 代码

2.3.1 agent

如Sarsa，sample函数用来采样，predict用来预测。

class QLearningAgent(object):
    def __init__(self, obs_n, act_n, learning_rate=0.01, gamma=0.9, e_greed=0.1):
        self.act_n = act_n      # 动作维度，有几个动作可选
        self.lr = learning_rate # 学习率
        self.gamma = gamma      # reward的衰减率
        self.epsilon = e_greed  # 按一定概率随机选动作
        self.Q = np.zeros((obs_n, act_n))

    # 根据输入观察值，采样输出的动作值，带探索
    def sample(self, obs):
        if np.random.uniform(0, 1) < (1.0 - self.epsilon): #根据table的Q值选动作
            action = self.predict(obs)
        else:
            action = np.random.choice(self.act_n) #有一定概率随机探索选取一个动作
        return action

    # 根据输入观察值，预测输出的动作值
    def predict(self, obs):
        Q_list = self.Q[obs, :]
        maxQ = np.max(Q_list)
        action_list = np.where(Q_list == maxQ)[0]  # maxQ可能对应多个action
        action = np.random.choice(action_list)
        return action

    

2.3.2 learn函数

与Sarsa 不同的是，learn函数直接选了max值。

# 学习方法，也就是更新Q-table的方法
    def learn(self, obs, action, reward, next_obs, done):
        """ off-policy
            obs: 交互前的obs, s_t
            action: 本次交互选择的action, a_t
            reward: 本次动作获得的奖励r
            next_obs: 本次交互后的obs, s_t+1
            done: episode是否结束
        """
        predict_Q = self.Q[obs, action]
        if done:
            target_Q = reward # 没有下一个状态了
        else:
            target_Q = reward + self.gamma * np.max(self.Q[next_obs, :]) # Q-learning
        self.Q[obs, action] += self.lr * (target_Q - predict_Q) # 修正q

    # 把 Q表格 的数据保存到文件中
    def save(self):
        npy_file = './q_table.npy'
        np.save(npy_file, self.Q)
        print(npy_file + ' saved.')
    
    # 从文件中读取数据到 Q表格
    def restore(self, npy_file='./q_table.npy'):
        self.Q = np.load(npy_file)
        print(npy_file + ' loaded.')

三、代码样例

3.1 情景描述

小乌龟自学习的从左下角走到右下角。黑色是悬崖，掉落则重新开始。

3.1 代码

没有可视化的界面。

import gym
import time
import numpy as np 
class QLearningAgent(object):
    def __init__(self, obs_n, act_n, learning_rate=0.01, gamma=0.9, e_greed=0.1):
        self.act_n = act_n      # 动作维度，有几个动作可选
        self.lr = learning_rate # 学习率
        self.gamma = gamma      # reward的衰减率
        self.epsilon = e_greed  # 按一定概率随机选动作
        self.Q = np.zeros((obs_n, act_n))

    # 根据输入观察值，采样输出的动作值，带探索
    def sample(self, obs):
        if np.random.uniform(0, 1) < (1.0 - self.epsilon): #根据table的Q值选动作
            action = self.predict(obs)
        else:
            action = np.random.choice(self.act_n) #有一定概率随机探索选取一个动作
        return action

    # 根据输入观察值，预测输出的动作值
    def predict(self, obs):
        Q_list = self.Q[obs, :]
        maxQ = np.max(Q_list)
        action_list = np.where(Q_list == maxQ)[0]  # maxQ可能对应多个action
        action = np.random.choice(action_list)
        return action

    # 学习方法，也就是更新Q-table的方法
    def learn(self, obs, action, reward, next_obs, done):
        """ off-policy
            obs: 交互前的obs, s_t
            action: 本次交互选择的action, a_t
            reward: 本次动作获得的奖励r
            next_obs: 本次交互后的obs, s_t+1
            done: episode是否结束
        """
        predict_Q = self.Q[obs, action]
        if done:
            target_Q = reward # 没有下一个状态了
        else:
            target_Q = reward + self.gamma * np.max(self.Q[next_obs, :]) # Q-learning
        self.Q[obs, action] += self.lr * (target_Q - predict_Q) # 修正q

    # 把 Q表格 的数据保存到文件中
    def save(self):
        npy_file = './q_table.npy'
        np.save(npy_file, self.Q)
        print(npy_file + ' saved.')
    
    # 从文件中读取数据到 Q表格
    def restore(self, npy_file='./q_table.npy'):
        self.Q = np.load(npy_file)
        print(npy_file + ' loaded.')

def run_episode(env, agent, render=False):
    total_steps = 0 # 记录每个episode走了多少step
    total_reward = 0

    obs = env.reset() # 重置环境, 重新开一局（即开始新的一个episode）

    while True:
        action = agent.sample(obs) # 根据算法选择一个动作
        next_obs, reward, done, _ = env.step(action) # 与环境进行一个交互
        # 训练 Q-learning算法
        agent.learn(obs, action, reward, next_obs, done)

        obs = next_obs  # 存储上一个观察值
        total_reward += reward
        total_steps += 1 # 计算step数
        if render:
            env.render() #渲染新的一帧图形
        if done:
            break
    return total_reward, total_steps

def test_episode(env, agent):
    total_reward = 0
    obs = env.reset()
    while True:
        action = agent.predict(obs) # greedy
        next_obs, reward, done, _ = env.step(action)
        total_reward += reward
        obs = next_obs
        # time.sleep(0.5)
        # env.render()
        if done:
            break
    return total_reward

# 使用gym创建悬崖环境
env = gym.make("CliffWalking-v0")  # 0 up, 1 right, 2 down, 3 left

# 创建一个agent实例，输入超参数
agent = QLearningAgent(
    obs_n=env.observation_space.n,
    act_n=env.action_space.n,
    learning_rate=0.1,
    gamma=0.9,
    e_greed=0.1)


# 训练500个episode，打印每个episode的分数
for episode in range(500):
    ep_reward, ep_steps = run_episode(env, agent, False)
    print('Episode %s: steps = %s , reward = %.1f' % (episode, ep_steps, ep_reward))

# 全部训练结束，查看算法效果
test_reward = test_episode(env, agent)
print('test reward = %.1f' % (test_reward))

3.2 运行结果

最终的结果为

与sarsa不同的是，Q学习只考虑最优的结果，所以尽管下一步有可能掉落悬崖，但他仍会选择收益最大的。