David Silver强化学习公开课自学笔记——Lec5不基于模型的控制

本笔记摘自知乎博主旺财的搬砖历险记和叶强，仅用于自学

1.介绍

（1）概述

• 上节：Model-free prediction
  • 评估一个给定的策略，即确定一个给定策略下的状态/状态行为对的价值函数
• 本节：Model-free Control
  • 在模型未知的条件下如何优化价值函数
  • 也称作模型无关的控制

🧡预测和控制的区别

• predict

input：MDP$⟨\mathcal{S},\mathcal{A},\mathcal{P},\mathcal{R},\gamma ⟩$➕策略$\pi$或者MRP$⟨\mathcal{S},{\mathcal{P}}^{\pi },{\mathcal{R}}^{\pi },\gamma ⟩$
output：基于当前策略$\pi$的价值函数$V_{\pi }$

• control

input：MDP$⟨\mathcal{S},\mathcal{A},\mathcal{P},\mathcal{R},\gamma ⟩$
output：最优价值函数$V_{\ast }$和最优策略${\pi }_{\ast }$

🧡预测的方法
在给定的策略下去估计价值函数$V(s)$

• MC learning➡需要得到一个完整的Episode才能进行一次 $v$ 值更新
• TD learning➡可以每走一步就更新一次 $v$ 值
• $TD(\lambda )$➡利用多个步的V值取加权和

🧡控制的目的
通过价值函数，反过来改进策略➡两者互相迭代改进，最终收敛到最优策略与最优价值函数➡得到最优策略

（2）本节内容引入——MDP问题

🧡有很多问题可以建模为MDP

• 控制一个大厦内的多个电梯使得效率最高
• 控制直升机的特技飞行
• 机器人足球世界杯上控制机器人球员
• 围棋游戏
• ……

🧡问题

• MDP模型运行机制未知，但可以通过尝试和采样得到经验
• MDP模型已知，但问题规模太大，计算机无法高效计算，除非采样来计算

🧡解决
不基于模型的控制：Model-free control

（3）On and Off-Policy Learning

🧡两种策略

• 采样策略：agent与环境交互时使用的策略
• 目标策略：我们通过学习得到的策略

🧡两种学习

主要区别：更新值函数时是否只使用当前策略产生的样本

• On-policy learning
  • “learn on the job”
  • 采样策略 $\mu$ 和目标策略 $\pi$ 一致，
    • 根据目标策略 $\pi$ 产生的一系列行为去获得奖励
    • 更新状态函数，根据该更新的价值函数来优化策略得到较优的策略
• Off-Policy learning
  • “Look over someones’ shoulder”
  • 采样策略 $\mu$ 和目标策略 $\pi$ 不一致
    • 基于采样策略$\mu$产生行为获得奖励，即对 $\mu$ 进行采样
    • 根据目标策略$\pi$更新价值函数，即在自己的策略形成的价值函数的基础上观察别的策略产生的行为

On-policy	Off-Policy
直接使用样本统计属性去估计总体	结合重要性采样才能使用样本估计总体
更简单，且收敛性更好	方差更大，收敛性更差
数据利用性更差	数据利用性更好（可以使用其他智能体交互的样本）
限定了学习过程中的策略是随机性策略	一般采样策略 $\mu$ 选用随机性策略，目标策略 $\pi$ 选用确定性策略
	采样策略需要比目标策略更具备探索性。即，在每个状态下，目标策略的可行动作是采样策略可行动作的子集

2. On-Policy Monte-Carlo Control

（1）广义策略迭代 Generalized Policy iteration(GPI)

🧡核心：在策略评估和策略改善的交互过程中进行策略优化

• 从一个策略$\pi$和一个价值函数$V$开始➡左图的左上角
• 上方的线代表目标$V=V^{\pi }$，下方的线代表目标$\pi =greedy(V)$
  • 箭头向上➡利用当前策略进行的价值函数更新
  • 箭头向下➡根据更新的价值函数贪婪地选择新的策略

（2）广义策略迭代的实现

🧡使用动态规划算法

• 策略评估使用贝尔曼方程
• 策略改进使用greedy方法
• 最优价值函数和最优策略对应的贝尔曼方程$$v_{\ast }(s)=\underset{a}{\max }\mathbb{E}(R_{t+1}+\gamma v_{\ast }(S_{t+1}|S_t=s,A_t=a)=\underset{a}{\max }\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\ast }(s^{\prime })]$$
  💗注💗：
  使用动态规划算法来改善策略是需要知道某一状态的所有后续状态及状态间转移概率：$${\pi }^{\prime }(s)=\arg \underset{a\in \mathcal{A}}{\max }{\mathcal{R}}_s^a+{\mathcal{P}}_{S{S}^{\prime }}^{a}V(S^{\prime })$$

🧡问题
基于采样的强化学习时，我们无法事先知道这些状态之间在不同行为下的转移概率，因而无法基于状态价值来改善我们的贪婪策略

🧡解决
策略估计中就不能使用贝尔曼期望方程，而是变为sample方法➡MC方法、TD方法……

（3）使用动作价值函数进行不基于模型的策略迭代

🧡模型已知时
对$V(s)$的贪婪策略改善需要使用MDP的模型$${\pi }^{\prime }(s)=\arg \underset{a\in \mathcal{A}}{\max }{\mathcal{R}}_s^a+{\mathcal{P}}_{S{S}^{\prime }}^{a}V(S^{\prime })$$
🧡问题

• 在模型未知的条件下无法知道当前状态的所有后续状态
• 从而无法确定在当前状态下采取怎样的行为更合适

🧡模型未知时

• 使用状态价值对的价值$Q(s,a)$来代替状态价值 *$${\pi }^{\prime }(s)=\arg \underset{a\in \mathcal{A}}{\max }Q(s,a)$$
• 优点
  • 不用知道整个模型也可以改善策略
  • 只需要知道在某个状态下采取什么样的行为价值最大即可
• 具体做法
  • 从一个策略$\pi$和一个动作价值函数$Q$开始
  • 箭头向上➡利用当前策略进行状态行为对 q 值的更新
  • 箭头向下➡根据更新的动作价值函数贪婪地选择新的策略
  • 最后收敛到最优动作价值函数$Q_{\ast }$和最优策略${\pi }_{\ast }$
• 问题
  • 每次都使用贪婪算法来改善策略的时候，将很有可能由于没有足够的采样经验而导致产生一个并不是最优的策略
  • 需要不时的尝试一些新的行为，这就是探索（Exploration）

（4）示例——Greedy Action Selection

条件：面前有两扇门，考虑如下的行为、奖励并使用贪婪算法改善策略：

• 你打开左侧门得到即时奖励为 0 ： V(left)=0
• 打开右侧门得到即时奖励＋1：V(right)=+1
  在使用贪婪算法时，接下来你将会继续打开右侧的门，而不会尝试打开左侧门：
• 打开右侧门得到即时奖励＋3：V(right)=(1+3)/2=+2
• 打开右侧门得到即时奖励＋2：V(right)=(1+3+2)/3=+2

🧡打开右侧门是否就一定是最好的选择呢？
显然不是。完全使用贪婪算法改善策略通常不能得到最优策略。为了解决这一问题，我们需要引入一个随机机制，以一定的概率选择当前最好的策略，同时给其它可能的行为一定的几率，这就是 $ϵ-Greedy$ 探索

（5）$ϵ-Greedy$探索

1)定义

🧡定义
设定一个 $ϵ$ 值，用来指导到底是Explore还是Exploit（Exploration and Exploitation问题，简称EE问题）
🧡原因&目标
因为$ϵ-Greedy$探索的目标是使得某一状态下所有可能的行为都有一定非零几率被选中执行，也就保证了持续的探索
🧡实现
利用：$1-ϵ$ 的概率下选择当前最好的行为
探索：$ϵ$ 的概率下在所有的可能行为中进行选择（包括最好的行为）
🧡数学表达式：
KaTeX parse error: No such environment: equation at position 22: …vert s)= \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \left\{ …
这里：

• $m$代表全部可选的行为
• $1/m$代表从$m$个可选行为中选中某行为$a$的概率
• $ϵ/m$代表以$ϵ$ 的概率从$m$个可选行为中选中某行为$a$的概率
• 解释：选择最优行为的概率=有$ϵ/m$的概率在探索阶段被选中➕有$1-ϵ$ 的概率在开发阶段被选中

2)$ϵ-Greedy$贪婪提升定理

对于任意 $ϵ-Greedy$ 策略 $\pi$ ，使用相应的 $q_{\pi }$ 得到的 $ϵ-Greedy$ 策略 ${\pi }^{\prime }$ 是在策略 $\pi$ 上的一次策略提升，即 $v_{{\pi }^{\prime }}(s)\ge v_{\pi }(s)$

证明$q_{\pi }(s,{\pi }^{\prime }(s))\ge v_{\pi }(s)$过程如[[Lec5_不基于模型的控制#（1）$ epsilon$ - Greedy贪婪提升定理证明]]

假设$\pi$和${\pi }^{\prime }$是一对确定性的策略，对于所有的$s\in \mathcal{S}$，有$$q_{\pi }(s,{\pi }^{\prime }(s))\ge v_{\pi }(s)$$
那么这个新的策略${\pi }^{\prime }$就不会比原来的策略差$\pi$，即$v_{{\pi }^{\prime }}(s)\ge v_{\pi }(s)$

即使用 $ϵ-Greedy$ 策略 ${\pi }^{\prime }$ 进行后续动作的价值$v_{{\pi }^{\prime }}(s)\ge q_{\pi }(s,{\pi }^{\prime }(s))$，因此$v_{{\pi }^{\prime }}(s)\ge v_{\pi }(s)$

（6）蒙特卡洛控制

🧡蒙特卡洛策略迭代方法

🧡与DP方法的策略迭代不同
这里，MC策略迭代方法➡蒙特卡洛控制

• 在策略估计中使用的是**Q函数**
• 在策略改进中使用的是**$ϵ-Greedy$方法**

🧡在实际应用中的蒙特卡洛控制

• 每一个向上、向下的箭头都对应着多个Episode➡我们一般在经历了多个Episode后才能依据Q函数进行更新或策略改善
• 实际上也可以在每经历一个Episode之后就更新Ｑ函数或改善策略
• 不论是应用一个Episode还是多个
  • 在 $ϵ-Greedy$ 探索下我们始终只能得到基于某一策略下的近似Ｑ函数💓💓💓💓$$Q\approx q_{\pi }$$
  • 该算法没有一个终止条件，因为它一直在进行探索

🧡希望的情况

• 在学习开始时有足够的探索
• 最终得到的策略没有探索，是一个确定性的策略
  引入一个新的理论概念➡GLIE

（7）无限探索下的极限贪婪GLIE（Greedy in the Limit with Infinite Exploration）

1)定义

在有限的时间内进行无限可能的探索

🧡具体表现

• 所有已经经历的状态行为对（state-action pair）会被无限次探索$$\underset{k\to \infty }{\lim }{N}_k(s,a)=\infty$$
• 策略最终收敛到一个贪心算法。即随着探索的无限延伸，贪婪算法中 $ϵ$ 值趋向于０$$\underset{k\to \infty }{\lim }{\pi }_k(a|s)=\text{1}(a=\arg \underset{a^{\prime }\in \mathcal{A}}{\max }{Q}_k(s,a^{\prime }))$$
  🧡举例来说
  如果取 ${ϵ}_k=\frac{1}{k}$ ，$k$为探索的Episode数目，随着探索的无限延伸，贪婪算法中$ϵ$ 值趋向于０，那么这个 $ϵ-Greedy$ 蒙特卡洛控制就具备GLIE特性

2)基于GLIE的蒙特卡洛控制

🧡控制流程

• 对于给定策略 $\pi$，采样第 $k$ 个Episode： { S 1 , A 1 , R 2 , … , S T } ∼ π \{S_1,A_1,R_2,\ldots,S_T\}\sim\pi {S1​,A1​,R2​,…,ST​}∼π
• 对于该Episode里出现的每一个状态行为对$S_t$和$A_t$，更新计数和Q函数：$$N(S_t,A_t)\leftarrow N(S_t,A_t)+1$$$$Q(S_t,A_t)\leftarrow Q(S_t,A_t)+\frac{1}{N(S_t,A_t)}(G_t-Q(S_t,A_t))$$
• 基于新的Ｑ函数，以如下方式改善策略：$${ϵ}_k\leftarrow \frac{1}{k}$$$$\pi \leftarrow ϵ-greedy(Q)$$

💗注意💗：

GLIE蒙特卡洛控制能收敛到最优的状态动作价值函数：$$Q(s,a)\to q_{\ast }(s,a)$$

（8）示例——21点的最优策略

最优策略是这样：

当你手上有可用Ａ时，大多数情况下当你的牌面和达到17或18时停止要牌，如果庄家可见的牌面在2-9之间，你选择17，其它条件选择18；
当你手上没有Ａ时，最优策略提示大多数情况下牌面和达到16就要停止叫牌，当庄家可见的牌面在2-7时，这一数字更小至13甚至12。这种极端情况下，宁愿停止叫牌等待让庄家的牌爆掉。

（9）MC和TD控制的对比

🧡预测方面，TD learning 相比 MC有很多优点：

• 低方差
• 可以在线实时学习
• 可以学习不完整的Episode

🧡控制方面，TD也比MC好很多——SARSA

• 将TD应用于$Q(S,A)$
• 使用$ϵ-greedy(Q)$进行策略改善
• 在每一步都进行更新

3. On-Policy TD learning——$Sarsa(\lambda )$

（1）$Sarsa$

1)定义

🧡SARSA名称的来源：

• 一个Agent处在某个状态$S$，根据当前策略选择某一个行为$A$产生一个状态行为对➡SA（个体执行该动作）
• 个体执行后，与环境交互，环境会告诉个体即时奖励$R$和后续进入的状态$S^{\prime }$➡RS
• 个体再次遵循现有策略产生一个行为$A^{\prime }$➡A（个体不执行该动作，只是为了得到Q值）
• 根据当前的状态行为价值函数得到后一个状态行为对$S^{\prime }{A}^{\prime }$的价值Q，利用这个Q值更新前一个状态行为对$SA$的价值

🧡公式$$Q(S,A)\leftarrow Q(S,A)+\alpha (R+\gamma Q(S^{\prime },A^{\prime })-Q(S,A))$$
这里，$\gamma$是衰减因子，$\alpha$是迭代步长

🧡与MC控制的区别

• 收获$G_t$的表达式不同：TD控制里，收获为$R+\gamma Q(S^{\prime },A^{\prime })$
• 也就是说，每一个时间步，也就是在单个Episode内，每一次个体在当前状态采取一个行为后，都要更新Q值
• 其余SARSA与MC在线控制算法基本类似

2)On-Policy Control with Sarsa

🧡与（6）中的MC控制相比的修改

• 策略估计的方法改成了SARSA
• 每个episode更新一次变成了每个time step更新一次
  

🧡现时策略控制的SARSA算法

🧡算法流程

• 算法输入：迭代Episode数$T$，状态集合$S$，动作集合$A$，步长$\alpha$，衰减因子$\gamma$，探索率$ϵ$
• 算法输出：所有状态和动作对应的价值Q
• 步骤
  • 初始化Q值
    • 随机初始化所有的状态和动作对应的价值Q
    • 对于终止状态Q值初始化为0
  • 从1到T进行迭代
    • 初始化$S$为当前状态序列的第一个状态
    • 用 $ϵ-Greedy$方法，在当前状态$S$选择的动作为$A$
    • 在状态$S$执行动作$A$，得到新状态$S^{\prime }$和奖励$R$
    • 用 $ϵ-Greedy$方法，在新的状态$S^{\prime }$选择的动作为$A^{\prime }$
    • 使用上述公式更新价值函数$Q(S,A)$
    • 更新状态和动作：$S=S^{\prime },A=A^{\prime }$
    • 如果$S^{\prime }$是终止状态，则当前轮迭代完毕，否则转到迭代的第二步继续执行

💗注意💗：

• 步长$\alpha$一般随着迭代的进行而变小，这才保证动作价值函数$Q$收敛，从而保证 $ϵ-Greedy$方法收敛
• 算法中的价值函数$Q(S,A)$是以一张大表格存储的，不适用于解决规模很大的问题
• 对于每一个Episode
  • 在状态$S$采用的动作$A$是基于当前策略的，该动作实际发生了
  • 在更新价值函数$Q(S,A)$时，针对状态$S^{\prime }$生成的动作$A^{\prime }$并没有马上执行，二是在下一个循环内执行

3)Sarsa算法的收敛性

在满足如下条件时，Sarsa算法将收敛至最优行为价值函数$Q(s,a)\to q_{\ast }(s,a)$
💡任何时候的策略$\pi (a|s)$都满足GLIE特性
💡步长系数$\alpha$满足${\sum }_{t=1}^{\infty }{\alpha }_t=\infty$，且${\sum }_{t=1}^{\infty }{\alpha }_t^2<\infty$（前者保证执行次数足够多，最终克服任何初始条件或者随机起伏，后者保证了最终收敛所用的次数足够少）

4)示例——有风的方格世界

🧡条件描述
如图所示，环境是一个 10×7 的长方形格子世界，同时有一个起始位置 S 和一个终止目标位置 G ，水平下方的数字表示对应的列中有一定强度的风，当该数字是 1 时，个体进入该列的某个格子时，会按图中箭头所示的方向自动移动一格，当数字为 2 时，表示顺风移动 2 格，以此类推模拟风的作用。任何试图离开格子世界的行为都会使得个体停留在移动前的位置。对于个体来说，它不清楚整个格子世界的构造，即它不知道格子是长方形的，也不知道边界在哪里。也不清楚起始位置、终止目标位置的具体位置。对于它来说，每一个格子就相当于一个封闭的房间，在没推开门离开当前房间之前它无法知道会进入哪个房间。个体具备记住曾经去过的格子的能力。格子可以执行的行为是朝上、下、左、右移动一步。

🧡问题
个体如何才能找到最短从起始格子 S 到终止目标格子 G 的最短路线？

🧡解答
首先将这个问题用强化学习常用的语言重新描述下。

• 这是一个不基于模型的控制问题，即个体在不清楚模型机制条件下试图寻找最优策略
• 环境信息
  • 环境信息包括格子世界的形状是 10×7 的长方形；起始和终止格子的位置，可以用二维或一维的坐标描述，同时还包括个体在任何时候所在的格子位置
  • 风的设置是环境动力学的一部分，它与长方形的边界共同及个体的行为共同决定了个体下一步的状态。
• 交互过程
  • 个体从环境观测不到自身位置、起始位置以及终止位置信息的坐标描述，个体在与环境进行交互的过程中学习到自身及其它格子的位置关系
• 个体的行为空间是离散的四个方向
• 参数设置
  • 可以设置个体每行走一步获得即时奖励为 −1 ，直到到达终止目标位置的即时奖励为 0 ，借此希望找到最优策略
  • 衰减系数 γ 可设为 1

🧡代码

import numpy as np  
import matplotlib matplotlib.use('Agg')  
import matplotlib.pyplot as plt  
import numpy as np  
import matplotlib  
matplotlib.use('Agg')  
import matplotlib.pyplot as plt  
  
# world height  
WORLD_HEIGHT = 7  
  
# world width  
WORLD_WIDTH = 10  
  
# wind strength for each column  
WIND = [0, 0, 0, 1, 1, 1, 2, 2, 1, 0]  
  
# possible actions  
ACTION_UP = 0  
ACTION_DOWN = 1  
ACTION_LEFT = 2  
ACTION_RIGHT = 3  
  
# probability for exploration  
EPSILON = 0.1  
  
# Sarsa step size  
ALPHA = 0.5  
  
# reward for each step  
REWARD = -1.0  
  
START = [3, 0]  
GOAL = [3, 7]  
ACTIONS = [ACTION_UP, ACTION_DOWN, ACTION_LEFT, ACTION_RIGHT]  
  
def step(state, action):  
    i, j = state  
    if action == ACTION_UP:  
        return [max(i - 1 - WIND[j], 0), j]  
    elif action == ACTION_DOWN:  
        return [max(min(i + 1 - WIND[j], WORLD_HEIGHT - 1), 0), j]  
    elif action == ACTION_LEFT:  
        return [max(i - WIND[j], 0), max(j - 1, 0)]  
    elif action == ACTION_RIGHT:  
        return [max(i - WIND[j], 0), min(j + 1, WORLD_WIDTH - 1)]  
    else:  
        assert False  
  
# play for an episode  
def episode(q_value):  
    # track the total time steps in this episode  
    time = 0  
  
    # initialize state  
    state = START  
  
    # choose an action based on epsilon-greedy algorithm  
    if np.random.binomial(1, EPSILON) == 1:  
        action = np.random.choice(ACTIONS)  
    else:  
        values_ = q_value[state[0], state[1], :]  
        action = np.random.choice([action_ for action_, value_ in enumerate(values_) if value_ == np.max(values_)])  
  
    # keep going until get to the goal state  
    while state != GOAL:  
        next_state = step(state, action)  
        if np.random.binomial(1, EPSILON) == 1:  
            next_action = np.random.choice(ACTIONS)  
        else:  
            values_ = q_value[next_state[0], next_state[1], :]  
            next_action = np.random.choice([action_ for action_, value_ in enumerate(values_) if value_ == np.max(values_)])  
  
        # Sarsa update  
        q_value[state[0], state[1], action] += \  
            ALPHA * (REWARD + q_value[next_state[0], next_state[1], next_action] -  
                     q_value[state[0], state[1], action])  
        state = next_state  
        action = next_action  
        time += 1  
    return time  
  
def sarsa():  
    q_value = np.zeros((WORLD_HEIGHT, WORLD_WIDTH, 4))  
    episode_limit = 500  
  
    steps = []  
    ep = 0  
    while ep < episode_limit:  
        steps.append(episode(q_value))  
        # time = episode(q_value)  
        # episodes.extend([ep] * time)        ep += 1  
  
    steps = np.add.accumulate(steps)  
  
    plt.plot(steps, np.arange(1, len(steps) + 1))  
    plt.xlabel('Time steps')  
    plt.ylabel('Episodes')  
  
    plt.savefig('./sarsa.png')  
    plt.close()  
  
    # display the optimal policy  
    optimal_policy = []  
    for i in range(0, WORLD_HEIGHT):  
        optimal_policy.append([])  
        for j in range(0, WORLD_WIDTH):  
            if [i, j] == GOAL:  
                optimal_policy[-1].append('G')  
                continue  
            bestAction = np.argmax(q_value[i, j, :])  
            if bestAction == ACTION_UP:  
                optimal_policy[-1].append('U')  
            elif bestAction == ACTION_DOWN:  
                optimal_policy[-1].append('D')  
            elif bestAction == ACTION_LEFT:  
                optimal_policy[-1].append('L')  
            elif bestAction == ACTION_RIGHT:  
                optimal_policy[-1].append('R')  
    print('Optimal policy is:')  
    for row in optimal_policy:  
        print(row)  
    print('Wind strength for each column:\n{}'.format([str(w) for w in WIND]))  
  
if __name__ == '__main__':  
    sarsa()

🧡最优路线图

🧡结果
个体通过学习发现下面的行为序列（共15步）能够得到最大程度的奖励： -14。
R,R,R,R,R,R,R,R,R,D,D,D,D,L,L

• 在个体找到这个最优行为序列的早期，由于个体对环境一无所知， SARSA 算法需要尝试许多不同的行为，因此在一开始的2000多步里，个体只能完成少数几个完整的episode
• 但随着个体找到一条链接起点到终点的路径，其快速优化策略的能力就显现的很明显了，因为它不需要走完一个episode才能更新行为价值，而是每走一步就根据下一个状态能够得到的最好价值来更新当前状态的价值。

5)期望Sarsa

$$Q(S_t,A_t)\leftarrow Q(S_t,A_t)+\alpha [R_{t+1}+\gamma \mathbb{E}[Q(S_{t+1},A_{t+1})]-Q(S_t,A_t)]$$
$$Q(S_t,A_t)\leftarrow Q(S_t,A_t)+\alpha [R_{t+1}+\gamma \sum _a\pi (a|S_{t+1})Q(S_{t+1},a)-Q(S_t,A_t)]$$
💗注意💗：

• $S_{t+1}$是环境采样得到的
• 求TD目标值时，按之前的方法，动作$A_{t+1}$是通过策略采样得来的，但这里策略已知，不采样直接求期望即可

🧡特点

• 减少了由于$A^{\prime }$的选择带来的方差
• 在更新相同的步数时，期望Sarsa比Sarsa的通用性更好
• 可以在On-Policy和Off-Policy中切换
  • On-Policy
    • TD目标值中的 $R_{t+1}+\gamma {\sum }_a\pi (a|S_{t+1})Q(S_{t+1},a)$中的策略 $\pi$ 和采样的策略是同一个策略
  • Off-Policy
    • TD目标值中的 $R_{t+1}+\gamma {\sum }_a\pi (a|S_{t+1})Q(S_{t+1},a)$中的策略 $\pi$ 和采样的策略是不同的策略
• 特殊情况下，TD目标值中的策略选择贪婪策略，采样的策略选用 $ϵ-Greedy$ 策略 —— Q learning

（2）$n$-Step $Sarsa$

🧡考虑$n=1,2,\dots ,\infty$的 n-step 回报

• $n=1,q_t^{(1)}=R_{t+1}+\gamma Q(S_{t+1})$➡️Sarsa
• $n=2,q_t^{(2)}=R_{t+1}+\gamma R_{t+1}+{\gamma }^{2}Q(S_{t+2})$
• $n=\infty ,q_t^{\infty }=R_{t+1}+\gamma R_{t+1}+{\gamma }^2{Q}_{S_{t+2}}+\dots +{\gamma }^{T-1}{R}_T$➡️MC

🧡解释

• 这里的 $q_t$ 对应的是一个状态行为对 $⟨s_t,a_t⟩$ ，表示的是在某个状态下采取某个行为的价值大小
• 如果 $n=1$ ，则表示状态行为对$⟨s_t,a_t⟩$的 Q 价值可以用两部分表示
  • 一部分是离开状态 st 得到的即时奖励 Rt+1 ，即时奖励只与状态有关，与该状态下采取的行为无关
  • 另一部分是新状态行为对 $⟨s_{t+1},a_{t+1}⟩$ 的 Q 价值：
    • 环境给了个体一个新状态 $s_{t+1}$，观察在 $s_{t+1}$ 状态时基于当前策略得到的行为 $a_{t+1}$ 时的 $Q(s_{t+1},a_{t+1})$ ，后续的 Q 价值考虑衰减系数。
• 当 n=2 时，就向前 2 步的即时奖励，然后再用新状态的 Q 价值代替
• 如果 n=∞ ，则表示一直用即时奖励计算 Q 值，直至episode结束，个体进入终止状态，获得终止状态的即时奖励。

🧡定义 n-Step Q-return
$$q_t^{(n)}=R_{t+1}+\gamma R_{t+2}+\dots +{\gamma }^{n-1}{R}_{t+n}+{\gamma }^{n}Q(S_{t+n})$$
💗注意💗：这里的Q值是包含动作的，是当前策略下基于某一状态产生的行为，与n-Step G-return不同

🧡用 n-Step Q-return 表示 n-Step Sarsa
$$Q(S_t,A_t)\leftarrow Q(S_t,A_t)+\alpha [q_t^{(n)}-Q(S_t,A_t)]$$

（3）$Sarsa(\lambda )$的两种视角

1)前向认识$Sarsa(\lambda )$——Forward View $Sarsa(\lambda )$

🧡假设给每一个 n-Step Q-return 的每一个收获分配一个权重

• 引入权重$(1-\lambda ){\lambda }^{n-1}$
• 按照权重对每一步Q-return求和，将得到$q^{\lambda }$收获，结合了所有的 n-Step Q-return：$$q_t^{\lambda }=(1-\lambda )\sum _{n=1}^{\infty }{\lambda }^{n-1}{q}_t^{(n)}$$
• 则 n-Step Sarsa 可表示成：$$Q(S_t,A_t)\leftarrow Q(S_t,A_t)+\alpha [q_t^{\lambda }-Q(S_t,A_t)]$$
  

🧡特点

• 前向认识$Sarsa(\lambda )$，更新Q价值需要遍历完整的Episode

2)后向认识$Sarsa(\lambda )$——Backward View $Sarsa(\lambda )$

🧡类比$TD(\lambda )$
同样引入效用追踪（ES）概念，不过这次ES不针对单独的状态，而是针对一个状态行为对：$$E_0(s,a)=0$$
$$E_t(s,a)=\lambda E_{t-1}(s,a)+\text{1}(S_t=s,A_t=a)$$
💗注意💗：

• 这里体现了一个结果与某一个状态行为对的因果关系，与得到结果最近的状态行为对、及之前频繁发生的状态行为对，哪一个对得到这个的结果影响最大
• $Q(s,a)$对每一个状态$s$➕动作$a$都会更新

🧡引入效用追踪后的$Sarsa(\lambda )$的Q值更新
$${\delta }_t=R_{t+1}+\gamma Q(S_{t+1},A_{t+1})-Q(S_t,A_t)$$
$$Q(s,a)\leftarrow Q(s,a)+\alpha {\delta }_t{E}_t(s,a)$$

（4）$Sarsa(\lambda )$算法

1)定义

🧡算法流程

• 算法输入：迭代Episode数$T$，状态集合$S$，动作集合$A$，步长$\alpha$，衰减因子$\gamma$，探索率$ϵ$，多步参数$\lambda$
• 算法输出：所有状态和动作对应的价值Q
• 步骤
  • 初始化Q值
    • 随机初始化所有的状态和动作对应的价值Q
    • 对于终止状态Q值初始化为0
  • 从1到T进行迭代
    • 初始化所有状态动作的效用追踪E为0
    • 初始化$S$为当前状态序列的第一个状态
    • 用 $ϵ-Greedy$方法，在当前状态$S$选择的动作为$A$
    • 在状态$S$执行动作$A$，得到新状态$S^{\prime }$和奖励$R$
    • 用 $ϵ-Greedy$方法，在新的状态$S^{\prime }$选择的动作为$A^{\prime }$
    • 更新效用追踪函数$E(s,a)$和TD误差$\delta$：$$E(S,A)=E(S,A)+\text{1}$$$$\delta =R_{t+1}+\gamma Q(S_{t+1},A_{t+1})-Q(S_t,A_t)$$
    • 更新价值函数$Q(S,A)$和效用追踪函数$E(s,a)$：$$Q(s,a)=Q(s,a)+\alpha \delta E(s,a)$$$$E(s,a)=\gamma \lambda E(s,a)$$
    • 更新状态和动作：$S=S^{\prime },A=A^{\prime }$
    • 如果$S^{\prime }$是终止状态，则当前轮迭代完毕，否则转到迭代的第二步继续执行

💗注意💗：

• 每经过一个Episode后都要将$E(s,a)$重置为0，因为ET仅在一个Episode中发挥作用
• 算法更新Q和E的时候不是针对某个Episode，而是针对整个状态行为空间内的Q和E
• 对于步长$\alpha$，和SARSA一样，也需要随着迭代的进行逐渐减小，保证动作价值函数Q收敛

2)示例——方格世界

• 最左侧的路线是agent采取Sarsa、n-step Sarsa 和 $Sarsa(\lambda )$中的一个得到的一个完整Episode的路径。
• 右侧三幅图中的箭头显示了对于各种算法，哪些动作值将在到达终点时增加，以及增加多少。

🧡假设

• 认定每一步的即时奖励为 0 ，直到终点处即时奖励为 1 ；
• 根据算法，除了终点以外的任何状态行为对的 Q 值可以是任意的，但我们设定所有的 Q 值均为 0 ；
• 该路线是第一次找到终点的路线。

🧡结果
💡one-step Sarsa

• 将仅增加最后一个动作值：
  • 由于是on-policy学习，一开始个体对环境一无所知，即 Q 值均为 0 ，它将随机选取移步行为
  • 在到达终点前的每一个位置 S ，个体依据当前策略，产生一个移步行为，执行该行为，环境会将其放置到一个新位置 S′，同时给以即时奖励 0 ，在新的位置 S′ 上，根据当前的策略它会产生新位置下的一个行为，个体不执行该行为，仅仅在表中查找新状态下新行为的 Q′ 值
  • 由于 Q=0 ，依据更新公式，它将把刚才离开的位置以及对应的行为的状态行为对价值 Q<S,A> 更新为0
  • 如此直到个体最到达终点位置 $S_G$ ，它获得一个即时奖励 1 ，此时个体会依据公式更新其到达终点位置前所在那个位置（暂用 $S_H$ 表示，也就是图中终点位置下方，向上的箭头所在的位置）时采取向上移步的那个状态行为对价值 Q<$S_H,A_{up}$> 值，它将不再是 0 ，这是个体在这个episode中唯一一次用非 0 数值来更新 Q 值。
  • 这样完成一个episode
    • 此时个体已经并且只进行了一次有意义的行为价值函数的更新
    • 同时依据新的价值函数产生了新的策略
    • 这个策略绝大多数与之前的相同，只是当个体处在某一个特殊位置时将会有一个确定的行为：直接向上移步，这个位置就是与终点相邻的下方的格子。
  • 注意：这里请不要误认为 Sarsa 算法只在经历一个完整的episode之后才更新，在这个例子中，由于我们的设定，它每走一步都会更新，只是多数时候更新的数据和原来一样罢了。
  • 此时如果要求个体继续学习，则环境将其放入起点。
  • 个体的第二次寻路过程一开始与首次一样都是盲目随机的，直到其进入终点位置下方的位置 $S_H$ ，在这个位置，个体更新的策略要求其选择向上的行为直接进入终点位置 $S_G$ 。同样，经过第二次的寻路，个体了解到到达终点下方的位置 $S_H$ 价值比较大，因为在这个位置直接采取向上移步的行为就可以拿到到达终点的即时奖励。因此它会将其通过移动一步可以到达 $S_H$ 的其它位置以及相应的到达 $S_H$ 位置所要采取的行为这一状态行为对的价值提升。
  • 如此反复，如果采用 greedy 策略更新，个体最终将得到一条到达终点的路径，不过这条路径的倒数第二步永远是在终点位置的下方。
  • 如果采用 $epsilon-Greedy$ 策略更新，那么个体还会尝试到终点位置的左上右等其它方向的相邻位置价值也比较大，此时个体每次完成的路径可能都不一样。
  • 通过重复多次搜索，这种 Q 值的实质性的更新将覆盖越来越多的状态行为对，个体在早期采取的随机行为的步数将越来越少，直至最终实质性的更新覆盖到起始位置。
  • 此时个体将能直接给出一条确定的从起点到终点的路径。

💡n-step Sarsa 将增加最后 n 个动作的值。

💡$Sarsa(\lambda )$ 算法将更新所有动作值，从episode开始，以不同的程度，并随着时间推移而衰减：

• $Sarsa(\lambda )$算法同时还针对每一次 Episode维护一个关于状态行为对 $⟨S,A⟩$ 的 E 表，初始时 E 表值均为 0 。
• 当个体首次在起点 $S_0$ 决定移动一步 $A_0$ （向右）时，它被环境告知新位置为 $S_1$ ，此时发生如下事情：
  • 首先个体会做一个标记，使 $E⟨S_0,A_0⟩$ 的值增加 1 ，表明个体刚刚经历过这个事件 $⟨S_0,A_0⟩$ ；
  • 其次它要估计这个事件对于解决整个问题的价值，也就是估计TD误差，此时依据公式结果为 0 ，说明个体认为在起点处向右走没什么价值，这个“没有什么价值”有两层含义：不仅说明在 $S_0$ 处往右目前对解决问题没有积极帮助，同时表明个体认为所有能够到达 $S_0$ 状态的状态行为对的价值没有任何积极或消极的变化。随后个体将要更新该Episode中所有已经经历的 $Q⟨S,A⟩$ 值，由于存在 E 值，那些在 $⟨S_0,A_0⟩$ 之前近期发生或频繁发生的 $⟨S,A⟩$ 的 Q 值将改变得比其他 Q 值明显些，此外个体还要更新其 E 值，以备下次使用。
  • 对于刚从起点出发的个体，这次更新没有使得任何 Q 值发生变化，仅仅在 $E⟨S_0,A_0⟩$ 处有了一个实质的变化。随后的过程类似，个体有意义的发现就是对路径有一个记忆，体现在 E 里，具体的 Q 值没发生变化。
  • 这一情况直到个体到达终点位置时发生改变。此时个体得到了一个即时奖励 1 ，它会发现这一次变化（从 $S_H$ 采取向上行为 $A_H$ 到达 $S_G$ ）价值明显，它会计算这个TD误差为 1 ，同时告诉整个经历过程中所有 $⟨s,a⟩$ ，根据其与 $⟨S_H,A_H⟩$ 的密切关系更新这些状态行为对的价值 Q （最右侧图所示），个体在这个Episode中经历的所有状态行为对的 Q 值都将得到一个非 0 的更新，但是那些在个体到达 $S_H$ 之前就近发生以及频繁发生的状态行为对的价值提升得更加明显。
  • 在图示的例子中没有显示某一状态行为频发的情况，如果个体在寻路的过程中绕过一些弯，多次到达同一个位置，并在该位置采取的相同的动作，最终个体到达终止状态时，就产生了多次发生的 $⟨s,a⟩$ ，这时的 $⟨s,a⟩$ 的价值也会得到提升。也就是说，个体每得到一个即时奖励，同时会对所有历史事件的价值进行依次更新，当然那些与该事件关系紧密的事件价值改变的较为明显。这里的事件指的就是状态行为对。在同一状态采取不同行为是不同的事件。当个体重新从起点第二次出发时，它会发现起点处向右走的价值不再是 0 。
  • 如果采用 greedy 策略更新，个体将根据上次经验得到的新策略直接选择右走，并且一直按照原路找到终点。
  • 如果采用 $ϵ-greedy$ 策略更新，那么个体还会尝试新的路线。

（5）小结

🧡优点
SARSA 算法和动态规划法比起来，不需要环境的状态转换模型，和MC法比起来，不需要完整的状态序列，因此比较灵活。在传统的强化学习方法中使用比较广泛。
🧡问题
SARSA 算法无法求解太复杂的问题。在 SARSA 算法中， Q(S,A) 的值使用一张大表来存储的，如果我们的状态和动作都达到百万乃至千万级，需要在内存里保存的这张大表会超级大，甚至溢出，因此不是很适合解决规模很大的问题。

4.Off-Policy Learning

（1）定义

🧡在线、离线策略学习对比
现时策略学习——当前遵循的策略就是个体学习改善的策略
离线策略学习——在遵循一个策略 $\mu (a|s)$ 的同时评估另一个策略 $\pi (a|s)$ ➡️计算确定策略 $\pi$ 的状态价值函数 $v_{\pi }(s)$ 或状态行为价值函数 $q_{\pi }(s,a)$

🧡优点

• 可以较容易的从其他个体经验中学习
• 可以从旧策略中学习，比较两个策略的优劣
• 遵循一个探索式策略的基础上优化现有的策略
• 可以用一个策略进行采样，然后同时学习多个策略

🧡根据是否经历完整的Episode可以分为

• 基于蒙特卡洛的离线策略学习
  • 仅有理论上的研究价值，没有实际意义
• 基于TD的离线策略学习

（2）重要性采样

🧡采样的目的
求得函数 $f(x)$ 在 $p(x)$ 分布下的期望：${\mathbb{E}}_{x\sim p(x)}[f(x)]={\int }_{x}f(x)p(x)dx$

🧡问题
如果符合 $p(x)$ 分布的样本不好生成

🧡解决
引入另一个容易生成样本的分布 $q(x)$，将问题转化为求 $g(x)$ 在 $q(x)$ 分布下的期望，即：$$\mathbb{E}[f(x)]={\int }_{x}f(x)p(x)dx={\int }_x\frac{p(x)}{q(x)}f(x)q(x)dx={\int }_{x}w(x)f(x)q(x)dx={\int }_{x}wg(x)q(x)dx$$ 称 $w(x)=\frac{p(x)}{q(x)}$ 为重要性权重
因此，可以将期望转化为$${\mathbb{E}}_{x\sim p(x)}[f(x)]={\mathbb{E}}_{x\sim q(x)}[\frac{p(x)}{q(x)}f(x)]$$

如果根据 $q(x)$ 取 { x i } i = 1 N \{x_i\}_{i=1}^N {xi​}i=1N​ ，并估计 $w(x)$，则蒙特卡洛估计就是 $\mathbb{E}[f(x)]=\frac{1}{N}{\sum }_{i=1}^{N}w(x_i)f(x_i)$

（3）离线策略中的重要性采样

1)理论基础

🧡理论公式
$t$ 时刻之后的动作状态轨迹 ${\rho }_t=A_t,S_{t+1},A_{t+1},\dots ,S_T$

• 该轨迹出现的频率为 $\mathbb{P}={\prod }_{k=t}^{T-1}\pi (A_k|S_k)\mathbb{P}(S_{k+1}|S_k,A_k)$ （所有状态下执行对应动作概率的乘积）
• 相应的重要性权重为${\eta }_t^T=\frac{{\prod }_{k=t}^{T-1}\pi (A_k|S_k)}{{\prod }_{k=t}^{T-1}\mu (A_k|S_k)}={\prod }_{k=t}^{T-1}\frac{\pi (A_k|S_k)}{\mu (A_k|S_k)}$

🧡意义
即使是未知模型，也可以得到重要性权重

2)离线策略MC学习中的重要性采样

🧡对 Off-Policy Monte-Carlo 使用 importance sampling

• 使用面向MC的策略 $\mu$ 产生的回报 return 来估计策略 $\pi$
• 公式：$$G_t^{\pi /\mu }=\frac{\pi (A_t|S_t)}{\mu (A_t|S_t)}\frac{\pi (A_{t+1}|S_{t+1})}{\mu (A_{t+1}|S_{t+1})}\dots \frac{\pi (A_T|S_T)}{\mu (A_T|S_T)}{G}_t$$
• 更新价值：$$V(S_t)\leftarrow V(S_t)+\alpha (G_t^{\pi /\mu }-V(S_t))$$

💗注意💗：

• 如果 $\mu$为 0 ，不能用该公式
• MC的方差本来就大，使用重要性采样会使方差急剧增大➡️结合重要性采样的MC方法较难用

3)离线策略TD学习中的重要性采样

🧡任务目标
使用TD方法在遵循一个策略 $\mu (a|s)$ 的同时评估另一个策略 $\pi (a|s)$

🧡数学表达
$$V(S_t)\leftarrow V(S_t)+\alpha (\frac{\pi (A_t|S_t)}{\mu (A_t|S_t)}(R_{t+1}+\gamma V(S_{t+1}))-V(S_t))$$
🧡解释
个体处在状态 $S_t$ 中，基于策略 $\mu$ 产生了一个行为 $A_t$ ，执行该行为后进入新的状态 $S_{t+1}$ ➡️在当前策略下如何使用离策略的方法，根据新状态的价值调整原来状态的价值？

• 在状态 $S_t$ 时比较另一个策略 $\pi$ 和当前策略 $\mu$ 产生行为 $A_t$ 的概率大小
  • 策略 $\pi$ 得到的概率值与当前策略 $\mu$ 得到的概率值接近➡️根据状态 $S_{t+1}$ 的价值来更新 $S_t$ 的价值同时得到两个策略的支持，两个策略有接近的概率选择行为 $A_t$ ，更新操作比较有说服力。
  • 策略 $\pi$ 得到的概率值与当前策略 $\mu$ 得到的概率值比值很小➡️如果依照被评估策略，选择 $A_t$ 的机会很小，这时候我们在更新 $S_t$ 价值的时候就不能过多的考虑基于当前策略 $\mu$ 得到的状态 $S_{t+1}$ 的价值。
  • 策略 $\pi$ 得到的概率值与当前策略 $\mu$ 得到的概率值比值大于 1 ➡️类似地，这借鉴被评估策略的经验来更新我们自己的策略

➡️➡️使用基于 TD(0) 的 Q - learning 算法

（4）Q - learning

1)原理

🧡要点：更新一个状态行为对的Q价值时，采用的不是遵循当前策略 $\mu$ 的下一个状态行为对Q的价值，而是遵循待评估策略 $\pi$ 产生的下一个状态行为对Q的价值

• 在 $t$ 时刻，与环境进行实际交互的行为 $A_t$ 由 $ϵ-Greedy$ 的策略 $\mu$ 产生：$A_t\sim \mu (\cdot |S_t)$
• 在 $t+1$ 时刻，用来更新Q值的行为 $A_{t+1}^{\prime }$ 由贪婪的策略 $\pi$ 产生：$A_{t+1}^{\prime }\sim \pi (\cdot |S_{t+1})$
• 重要性采样的因子 $\frac{\pi }{\mu }$
  • 对于某个状态 $s$ ，使用贪婪策略 $\pi$ 时，选择某个动作 $a$ 的概率只有两种情况
    • 概率为 1 ，策略 $\mu$ 选择该动作的概率也很大（因为 $ϵ$ 一般很小），则因子 $\frac{\pi }{\mu }\approx 1$
    • 概率为 0 ，因子 $\frac{\pi }{\mu }=0$
• 更新Q值$$Q(S_t,A_t)\leftarrow Q(S_t,A_t)+\alpha (R_{t+1}+\gamma Q(S_{t+1},A^{\prime })-Q(S_t,A_t)$$
  • 注意，这里 $A^{\prime }$ 没有实际执行
  • TD target $R_{t+1}+\gamma Q(S_{t+1},A^{\prime })$ 是基于待评估策略 $\pi$ 产生的行为 $A^{\prime }$ 得到的Q价值

🧡特点
Q - learning 虽然是一种离线策略算法，但是不需要重要性采样因子，即不需要引入重要性采样！

2)Q - learning 进行离线策略控制

🧡Q - learning 的表现形式
采样策略 $\mu$ 是一个 $ϵ-Greedy$ 策略
目标策略 $\pi$ 是一个完全贪婪策略

🧡因此 Q - learning 的 TD target 可以被大幅度简化：$$R_{t+1}+\gamma Q(S_{t+1},A^{\prime })=R_{t+1}+\gamma Q(S_{t+1},\arg \underset{a^{\prime }}{\max }Q(S_{t+1},a^{\prime }))=R_{t+1}+\arg \underset{a^{\prime }}{\max }\gamma Q(S_{t+1},a^{\prime })$$
🧡收敛性
采用简化后的 TD target，Q - learning 的价值更新方式会保证，状态 $S_t$ 执行 $ϵ-Greedy$ 策略 $\mu$ 产生的行为 $A_t$ 后，得到的Q价值会朝着 $S_{t+1}$ 状态最大Q价值的方向做一定比例的更新
➡️沿着这种算法，目标策略 $\pi$ 最终会收敛到最佳策略和最优动作价值函数
➡️由于个体与环境实际交互的时候遵循的是 $ϵ-Greedy$ 策略，也能保证经历足够丰富的新状态

3)Q - learning 控制算法

Q - learning 将收敛到最优状态行为价值函数 $Q(s,a)\to q_{\ast }(s,a)$

基于状态 $S$ ，用 $ϵ-Greedy$ 法选择到动作 $A$ ，然后执行动作 $A$ ，得到奖励 $R$ ，并进入状态 $S^{\prime }$

• SARSA ，继续基于状态 $S^{\prime }$ ，用 $ϵ-Greedy$ 法选择 $A^{\prime }$ ，然后更新价值函数，虽然价值函数更新使用的 $A^{\prime }$ 不实际执行，但 A′ 会作为下一阶段开始时候的执行动作
• Q-learning ，基于状态 $S^{\prime }$ ，使用贪婪法选择 $A^{\prime }$ ，也就是说，选择使 $Q(S^{\prime },a)$ 最大的动作作为 $A^{\prime }$ 来更新价值函数。此时选择的动作只会参与价值函数的更新，不会真正的执行。价值函数更新后，新的执行动作需要基于状态 $S^{\prime }$ ，用 $ϵ-Greedy$ 法重新选择得到。

🧡算法流程

• 算法输入：迭代Episode数$T$，状态集合$S$，动作集合$A$，步长$\alpha$，衰减因子$\gamma$，探索率$ϵ$
• 算法输出：所有状态和动作对应的价值Q
• 步骤
  • 初始化Q值
    • 随机初始化所有的状态和动作对应的价值Q
    • 对于终止状态Q值初始化为0
  • 从1到T进行迭代
    • 初始化$S$为当前状态序列的第一个状态
    • 用 $ϵ-Greedy$ 方法，在当前状态$S$选择的动作为$A$
    • 在状态$S$执行动作$A$，得到新状态$S^{\prime }$和奖励$R$
    • 更新价值函数$Q(S,A)$：$Q(S,A)=Q(S,A)+\alpha (R+\gamma {\max }_{a}Q(S^{\prime },a)-Q(S,A))$
    • 更新状态和动作：$S=S^{\prime }$
    • 如果$S^{\prime }$是终止状态，则当前轮迭代完毕，否则转到迭代的第二步继续执行
      
      

🧡Windy GridWorld 代码

import numpy as np  
import matplotlib  
matplotlib.use('Agg')  
import matplotlib.pyplot as plt  
  
# world height  
WORLD_HEIGHT = 7  
  
# world width  
WORLD_WIDTH = 10  
  
# wind strength for each column  
WIND = [0, 0, 0, 1, 1, 1, 2, 2, 1, 0]  
  
# possible actions  
ACTION_UP = 0  
ACTION_DOWN = 1  
ACTION_LEFT = 2  
ACTION_RIGHT = 3  
  
# probability for exploration  
EPSILON = 0.1  
  
# Sarsa step size  
ALPHA = 0.5  
  
# reward for each step  
REWARD = -1.0  
  
START = [3, 0]  
GOAL = [3, 7]  
ACTIONS = [ACTION_UP, ACTION_DOWN, ACTION_LEFT, ACTION_RIGHT]  
  
def step(state, action):  
    i, j = state  
    if action == ACTION_UP:  
        return [max(i - 1 - WIND[j], 0), j]  
    elif action == ACTION_DOWN:  
        return [max(min(i + 1 - WIND[j], WORLD_HEIGHT - 1), 0), j]  
    elif action == ACTION_LEFT:  
        return [max(i - WIND[j], 0), max(j - 1, 0)]  
    elif action == ACTION_RIGHT:  
        return [max(i - WIND[j], 0), min(j + 1, WORLD_WIDTH - 1)]  
    else:  
        assert False  
  
# play for an episode  
def episode(q_value):  
    # track the total time steps in this episode  
    time = 0  
  
    # initialize state  
    state = START  
  
    while state != GOAL:  
    # choose an action based on epsilon-greedy algorithm  
        if np.random.binomial(1, EPSILON) == 1:  
            action = np.random.choice(ACTIONS)  
        else:  
            values_ = q_value[state[0], state[1], :]  
            action = np.random.choice([action_ for action_, value_ in enumerate(values_) if value_ == np.max(values_)])  
  
    # keep going until get to the goal state  
  
        next_state = step(state, action)  
        #if np.random.binomial(1, EPSILON) == 1:  
        #    next_action = np.random.choice(ACTIONS)        #else:        values_ = q_value[next_state[0], next_state[1], :]  
        next_action = np.random.choice([action_ for action_, value_ in enumerate(values_) if value_ == np.max(values_)])  
  
        # Sarsa update  
        q_value[state[0], state[1], action] += \  
            ALPHA * (REWARD + q_value[next_state[0], next_state[1], next_action] -  
                     q_value[state[0], state[1], action])  
        state = next_state  
        #action = next_action  
        time += 1  
    return time  
  
def q_learning():  
    q_value = np.zeros((WORLD_HEIGHT, WORLD_WIDTH, 4))  
    episode_limit = 500  
  
    steps = []  
    ep = 0  
    while ep < episode_limit:  
        steps.append(episode(q_value))  
        # time = episode(q_value)  
        # episodes.extend([ep] * time)        ep += 1  
  
    steps = np.add.accumulate(steps)  
  
    plt.plot(steps, np.arange(1, len(steps) + 1))  
    plt.xlabel('Time steps')  
    plt.ylabel('Episodes')  
  
    plt.savefig('./q-learning.png')  
    plt.close()  
  
    # display the optimal policy  
    optimal_policy = []  
    for i in range(0, WORLD_HEIGHT):  
        optimal_policy.append([])  
        for j in range(0, WORLD_WIDTH):  
            if [i, j] == GOAL:  
                optimal_policy[-1].append('G')  
                continue  
            bestAction = np.argmax(q_value[i, j, :])  
            if bestAction == ACTION_UP:  
                optimal_policy[-1].append('U')  
            elif bestAction == ACTION_DOWN:  
                optimal_policy[-1].append('D')  
            elif bestAction == ACTION_LEFT:  
                optimal_policy[-1].append('L')  
            elif bestAction == ACTION_RIGHT:  
                optimal_policy[-1].append('R')  
    print('Optimal policy is:')  
    for row in optimal_policy:  
        print(row)  
    print('Wind strength for each column:\n{}'.format([str(w) for w in WIND]))  
  
if __name__ == '__main__':  
    q_learning()

4)示例——悬崖行走

🧡已知条件
图中悬崖用灰色的长方形表示，在其两端一个是起点，一个是目标终点。从悬崖指向起点的箭头提示悬崖是终止状态。可以看出最优路线是贴着悬崖上方行走。

🧡结果

• 早期 Q-learning 得到的策略要比 SARSA 要差一些，但后期总能找到最优策略。
• 两者的曲线都有一定的起伏，说明两者都有一定的探索，即遵循的策略都是 $ϵ-Greedy$ 执行的，但 Q-learning 在进行价值评估时采用的是 greedy 而不是再是 $ϵ-Greedy$ 方法确定要观察的状态 $S^{\prime }$

5)计算示例——大门

🧡已知条件
假设一幢建筑里面有5个房间，房间之间通过门相连。我们将这5个房间按照0、1、2、3、4进行编号，且建筑的外围可认为是一个大的房间，编号为5。上图的房间也可通过一个图来表示，房间作为图的节点，两个房间若有门相连，则相应节点间对应一条边。

🧡分析

• 将 agent 任意房间，从该房间开始准备行走，目标房间是编号为5的房间。
• 为每一扇门（即相应的边）关联一个reward值：直接连接到目标房间的门的reward值为100，其他门的reward值为0。
• 每一扇门都有两个方向，每一个房间上指定两个箭头（一个指进一个指出），且每个箭头上带有一个reward值。注意，编号为5的房间有一个指向自己的箭头，其reward值为100，其他直接指向目标房间的边的reward值也为100。
• Q-learning 的目标是达到reward值最大的state，因此，当agent到达目标房间后将永远停留在那里。这种目标也称为“吸收目标”。

🧡解决
对agent从建筑里的任意房间的简单撤离进行建模。

• 假定现在agent位于2号房间，我们希望agent通过学习到达5号房间。将每个房间（包括5号房间）称为一个“状态”➡️一个节点，将agent从一个房间走到另外一个房间称为一个“行为”➡️一个箭头。

• 假设agent当前处于状态2。从状态2，它可以转至状态3，但不能转至状态1

• 以状态为行，行为为列，构建一个如下图所示的关于reward值的矩阵 R ，其中的 −1 表示空值（相应节点之间没有边相连）
  

• 构建一个矩阵 Q ，它用来表示agent已经从经验中学到的知识。矩阵 Q 与 R 是同阶的，其行表示状态，列表示行为。 由于刚开始时agent对外界环境一无所知，因此矩阵 Q 应初始化为零矩阵

• 在本例中我们假设状态的数目是已知的（等于 6）。对于状态数目未知的情形，我们可以让 Q 从一个元素出发，每次发现一个新的状态时就可以在 Q 中增加相应的行列

🧡计算过程（令 $\gamma =0.8$）

• R 的第二行（对应房间1或状态1），它包含两个非负值，即当前状态1的下一步行为有两种可能：转至状态3或转至状态5。随机地，我们选取转至状态5，它对应三个可能的行为：转至状态1、4或5。
• 现在状态5变成了当前状态。因为状态5即为目标状态，故一次Episode便完成了，至此，agent的 Q 矩阵刷新为：
  
• 进行下一次episode的迭代。若我们继续执行更多的episode，矩阵 Q 将最终收敛成
  
• 一旦矩阵 Q 足够接近于收敛状态，我们的agent便学习到了转移至目标状态的最佳路径
  

5.总结

（1）SARSA 与 Q - learning 对比

🧡最优策略的获得
Q - learning 直接学习的是最优策略，而 SARSA 在学习最优策略的同时还在做探索，这导致我们在学习最优策略的时候

• 如果用 SARSA ，为了保证收敛，需要制定一个策略，使 ϵ−greedy 法的超参数 ϵ 在迭代的过程中逐渐变小。
• Q-learning 没有这个烦恼。
  🧡 方差问题
• Q-learning 直接学习最优策略，但是最优策略会依赖于训练中产生的一系列数据，所以受样本数据的影响较大，因此受到训练数据方差的影响很大，甚至会影响 Q 函数的收敛。
• Q-learning 的深度强化学习版 Deep Q-Learning 也有这个问题。
• 在学习过程中， SARSA 在收敛的过程中鼓励探索，这样学习过程会比较平滑，不至于过于激进，导致出现像 Q-learning 可能遇到一些特殊的最优“陷阱”。
  🧡 实际应用
• 在模拟环境中训练强化学习模型，推荐使用 Q-learning
• 如果是在线生产环境中训练模型，则推荐使用 SARSA

（2）DP和TD的关系

🧡 采样与全宽
TD是采样+有数据引导（bootstrap）
DP是全宽度+实际数据

🧡 Bellman期望方程

• 聚焦于状态本身价值的是迭代法策略评估（DP）和TD学习
• 聚焦于状态行为对价值函数的则是Q-策略迭代（DP）和SARSA

🧡针对状态行为价值函数的Bellman优化方程
Q-价值迭代（DP）和Q学习

6.证明

（1）$ϵ-Greedy$ 贪婪提升定理证明

🧡定理：

对于任意 $ϵ-Greedy$ 策略 $\pi$ ，使用相应的 $q_{\pi }$ 得到的 $ϵ-Greedy$ 策略 ${\pi }^{\prime }$ 是在策略 $\pi$ 上的一次策略提升，即 $v_{{\pi }^{\prime }}(s)\ge v_{\pi }(s)$

🧡已知

🧡提前推导：
💡对于所有的状态和动作，$0<ϵ<1$

• 因为已知的$ϵ-Greedy$探索
  • 在取最优（利用）时${\pi }^{\prime }(a|s)=ϵ/m+1-ϵ\ge ϵ/m$
  • 在随便取（探索）时${\pi }^{\prime }(a|s)=ϵ/m\ge ϵ/m$
• 因此有$$\pi (a|s)\ge ϵ/m$$

💡根据$ϵ$ - soft的特点，定义一个变量$\Delta$，使得$$\pi (a|s)=ϵ/m+\Delta$$
💡继续研究$ϵ-Greedy$探索公式

• 探索阶段，$\pi (a|s)=ϵ/m+\Delta$
• 利用阶段，剩下$1-\pi (a|s)m=1-ϵ-\Delta m$
• 因此，最优探索阶段的概率为探索➕利用=
  

💡 化简greedy action有：$$1-ϵ-\Delta m+ϵ/m+\Delta =1-(m-1)(ϵ/m+\Delta )$$

• 可以理解为：假设non-greedy action有$m-1$个，greedy action有$1$个，所有的概率$\pi (a|s)$加和为1

💡推导一个经验定义的式子${\sum }_{a\in \mathcal{A}}\frac{\pi (a|s)-\frac{ϵ}{m}}{1-ϵ}{q}_{\pi }(s,a)$：

• 将求和项拆成 greedy action 和 non-greedy action
• 令${\max }_{a\in \mathcal{A}}{q}_{\pi }(s,a)=q_m$
• 因为non-greedy action有$m-1$个，所以它们所有的动作价值都等于除了唯一1个greedy action对应的值以外的次大值：$q_{\pi }(s,a)=q_s$
• greedy action 的动作价值肯定不小于 non-greedy action 的动作价值：$$q_s-q_m\le 0$$

💡将上述的经验式子与${\max }_{a\in \mathcal{A}}{q}_{\pi }(s,a)$比较：$$\sum _{a\in \mathcal{A}}\frac{\pi (a|s)-\frac{ϵ}{m}}{1-ϵ}{q}_{\pi }(s,a)\le q_m=\underset{a\in \mathcal{A}}{\max }{q}_{\pi }(s,a)$$

🧡则带入得：

🧡得证：$$q_{\pi }(s,{\pi }^{\prime }(s))\ge v_{\pi }(s)$$