from flask import Flaskapp = Flask(__name__)@app.route('/')def hello():    return 'Hello, Flask!'if __name__ == '__main__':    app.run(debug=True, host='0.0.0.0')

Flask==3.0.3Flask_Cors==4.0.1flask_restx==1.3.0flask_sqlalchemy==3.1.1numpy==1.24.4opencv_python==4.8.1.78Werkzeug==3.0.4pandas==2.0.3Pillow==11.0.0ultralytics==8.0.208Werkzeug==3.0.4pymysql==1.0.2

pip install pipreqs

pipreqs . --encoding=utf8 --force

# 使用Python作为基础镜像FROM python:3.9# 设置工作目录WORKDIR /app# 复制应用代码到容器中COPY . /app# 安装依赖项RUN apt-get update && apt-get install -y libgl1-mesa-glxRUN pip install -i https://mirrors.aliyun.com/pypi/simple/ --no-cache-dir -r requirements.txt# 暴露应用端口EXPOSE 5000# 设置启动命令CMD ["python", "run.py"]

docker build -t flask-app .

docker run -p 8888:8888 flask-app

原文发布于 CSDN：https://blog.csdn.net/m0_49683806/article/details/139443499

参考引用

【强化学习的数学原理-赵世钰】课程笔记（六）随机近似与随机梯度下降

一.内容概述

背景：

• 本次课学习随机近似理论（Stochastic Approximation）和随机梯度下降（Stochastic Gradient Descent）。因为下节课我们要介绍 Temporal-Difference learning，这是一个无模型的强化学习算法，下节课与上节课介绍的有一个知识的鸿沟，比较难理解。实际上，Temporal-Difference learning 是 Stochastic Approximation 的一个特殊情况。因此，这节课先介绍背景知识
• 在上一讲中，我们介绍了蒙特卡洛学习法（Monte-Carlo learning）。
• 在下一讲中，我们将介绍时差（TD）学习（temporal-difference (TD) learning）。
• 在本讲座中，我们将按下暂停键，以便做好更充分的准备。

为什么？

• TD算法（temporal-difference (TD) learning）的思想和表达方式与我们目前学习的算法截然不同。
• 第一次看到 TD 算法时，都会疑惑为什么当初要设计这些算法，为什么它们能有效地工作。

在本次课中：

• 我们将通过介绍基本的随机逼近（SA）算法，填补上一讲和下一讲之间的知识空白。通过介绍基本的随机近似（SA）算法（basic stochastic approximation (SA) algorithms），我们将填补上一讲和下一讲之间的知识空白。
• 我们将在下一讲中看到，时差算法是一种特殊的 SA 算法（temporal-difference algorithms are special SA algorithms）。因此，理解这些算法会容易得多。

本节课内容：

• 1.激励性实例（Motivating examples）：首先介绍 mean estimation，也就是估计一个随机变量的 expectation，因为我们想用这个例子说明什么是 non-incremental（非增量式），什么是 incremental（增量式）。实际上要估计 $\mathbb{E}[X]$ 有两种方法：non-incremental 方法就是比如有一万个采样，要等所有采样都采到了再一次性求平均，得到 $\mathbb{E}[X]$ 的一个近似；incremental 的思想是开始的时候对他有一个估计，这个估计可能不准但是没关系，我得到一个采样我就用这个采样来更新我的估计，得到一个采样就更新一次，慢慢的估计会越来越准确，这就是增量式的思想，它的好处是不需要等全部样本全部集齐，在收集样本的过程中就可以有一些估计尽管不太准确，但可以使用，会越来越准确。
• 2.Robbins-Monro 算法（RM 算法）：是随机近似理论（Stochastic Approximation）中非常经典的一个算法，求解 $g(w) = 0$ 这样一个方程，求解 $w$ 使得这个方程成立。不需要知道 $g(w)$ 长什么样子，它的表达式，它的梯度导数全都不需要就可以被求出来。
• 3.随机梯度下降（Stochastic Gradient Descent）：是 RM 算法的一个特殊情况
• 4.batch gradient descent，mini-batch gradient descent 和 stochastic gradient descent（批量梯度下降，微型批量梯度下降和随机梯度下降）（BGD，MBGD 和 SGD）
• 5.总结

二.激励性实例（Motivating examples）

这部分介绍一个 mean estimation 的算法，如何通过迭代的方式去求一个期望（expectation）

重温上节课学过的平均值估计问题（Revisit the mean estimation problem）

• 考虑一个随机变量 $X$
• 我们的目标是估计它的期望 $\mathbb{E}[X]$
• 假设我们收集了一些独立同分布的采样
• 对采样求平均值，认为是 $\mathbb{E}[X]$ 的近似
• 上面这种近似方法就是蒙特卡罗估计的基本思想。
• 当有足够多的数据的时候，采样的平均值会逐渐收敛到它真实的期望 $\mathbb{E}[X]$

为什么我们如此在意平均值估计问题（mean estimation problem）？

强化学习（RL）中的许多量，如动作值和梯度（action values and gradients），都被定义为期望值，都需要用数据去估计。

新问题： 如何计算平均值 $\bar{x}$？
$$\mathbb{E}[x]\approx \bar{x}: = \frac{1}{N}\sum^{N}_{i = 1}x_i$$
有两种方法：

第一种方法： 很简单，就是收集所有样本，然后计算平均值。

• 这种方法的缺点是，如果要在一段时间内逐个（one by one）收集样本，我们就必须等到所有样本都收集完毕。我们必须等到所有样本都收集完毕再求平均。

第二种方法： 可以避免这一缺点，因为它是以递增（增量式的）（incremental）和迭代（iterative）的方式计算平均值的。基本思路就是来几个就先计算几个，这样效率更高。

下面详细介绍第二种方法

关于该算法的说明：

• 这种算法的优势在于它是渐进式的。一旦收到样本，就可以立即获得平均值估计值。然后，平均估算值就可以立即用于其他目的。在第 $k$ 步的时候，我不需要把前面所有的 $x_i$ 全部加起来再求平均，只需要通过上式一步的计算就可以得到一个新的平均数
• 这个算法代表一种增量式的计算思想：在最开始的时候因为数据量比较小，$w_k$ 难以非常精确的逼近 $\mathbb{E}[X]$，即由于样本不足，平均值估计在开始时并不准确（即 $w_k \neq \mathbb{E}[X]$。不过，有总比没有好，总比一直等到最后才能有一个数来得到一个平均数要强。在这个过程中 $w_k$ 就算不精确，也可以用到其它任务中。随着样本的增多，数据越来越大，$w_k$ 也会越来越精确的逼近 $\mathbb{E}[X]$，估计值会逐渐提高（即当 $k \rightarrow \infty$ 时，$w_k \rightarrow \mathbb{E}[X]$）。

此外，这个算法也可以进一步推广：

还可以考虑一种表达式更一般的算法：

• 这种算法还能收敛到平均值 $\mathbb{E}[X]$ 吗？ 我们之后将证明，如果 {αk} 满足一些温和的条件（satisfy some mild conditions），答案是可以的。
• 我们还将证明，这种算法是一种特殊的 SA 算法（Stochastic Approximation algorithm），也是一种特殊的随机梯度下降算法（stochastic gradient descent algorithm）。
• 在下一讲中，我们将看到时差算法(the temporal-difference algorithms)有类似（但更复杂）的表达式。

三.Robbins-Monro 算法（RM 算法）：

是随机近似理论（Stochastic Approximation）中非常经典的一个算法

1.算法描述

随机近似（Stochastic approximation，SA）究竟是什么：

• SA 指的是 解决寻根（方程求解）或优化问题 的一大类随机迭代算法。SA refers to a broad class of stochastic iterative algorithms solving root finding or optimization problems.（随机算法就是里面会涉及到对随机变量的采样）
• 与许多其他寻根（方程求解）算法（如基于梯度的方法gradient-based methods，梯度下降或梯度上升）相比，SA 的强大之处在于它不需要知道目标函数的表达式或其导数或者梯度的表达式。

Robbins-Monro (RM) 算法:

• 这是随机逼近领域（in the field of stochastic approximation）的一项开创性工作。
• 著名的随机梯度下降算法（stochastic gradient descent algorithm）是 RM 算法的一种特殊形式。
• 它可以用来分析开头介绍的均值估计（mean estimation）算法。我们前面介绍的 mean estimation 算法也是一种特殊的 RM 算法。

问题陈述： 假设我们想找出方程的根
$$g(w) = 0$$
其中 $w \in R$ 是待解变量，$g:\mathbb{R}\rightarrow \mathbb{R}$ 是一个函数。$w$ 和 $g$ 全都是标量

• 这个问题看似很简单，但是很有用，因为它广泛的存在。许多问题最终都可以转化为这个寻根问题，比如优化问题：例如，假设 $J(w)$ 是一个需要最小化的目标函数，需要优化 $J(w)$ 那么方法就是求解下面的这个方程，就是 $J(w)$ 的梯度等于 0，这个梯度等于 0 是 $J(w)$ 达到最大或最小的一个必要条件，并不是充分条件，但我们可以找到一个局部的极值。或者当 $J(w)$ 只有一个极值的时候，这个就变成一个充分必要条件。
• 总之，优化问题可以写成 $g(w) = 0$ 的形式，这时候 $g(w)$ 指的就是梯度

$$g(w) = \triangledown _{w}J(w) = 0$$

• 请注意，$g(w) = c$ 这样的方程（c 为常数），也可以通过将 $g(w)-c$ 改写为一个新函数而转换为上式 $g(w)-c = 0$。

如何求解 g(w) = 0 的根？

有两种情况：

• 基于模型： 如果已知 $g$ 或者其导数的表达式，有很多数值算法可以解决这个问题。
• 无模型： 如果函数 $g$ 的表达式未知呢？
  • 例如，函数由人工神经元网络表示。可以通过神经网络求解，$y = g(w)$，这个神经网络的输入是 $w$，输出是 $y$，神经网络里面其实就是 $g(w)$。常见的全连接神经网络其实就是做一个函数的近似，神经网络中我是不知道表达式的，现在问题就是输入什么样的 $w$ 能得到一个 0 的输出？

求解 $g(w) = 0$ 这样的问题（求这个方程的根）可以用 RM 算法来求解，下面正式介绍 RM 算法：

目标是求解 $g(w) = 0$，假设最优解是 $w^*$

RM算法是个迭代式的算法，对 $w^*$ 第 $k$ 次的估计是 $w_k$

原文发布于 CSDN：https://blog.csdn.net/m0_49683806/article/details/139253975

一.内容概述

• 上节课介绍了 model-base 的方法，这节课将介绍 model-free 的方法，上节课的 policy iteration 的方法是这节课的基础，我们把 policy iteration 当中基于模型的部分替换成不需要模型的部分就得到了今天的算法。
• 在这门课中，把 value iteration 和 policy iteration 统称为 model-base reinforcement learning，但是更准确来说，它们应该称为动态规划（dynamic programming）的方法。model-base reinforcement learning 简称 MBRL，这个研究的是我用数据估计出一个模型，再基于这个模型进行强化学习。
• 这节课介绍没有模型的强化学习方法，首先我们要学习随机变量的期望值，因为之前提到的 state value 和 action value 全都是随机变量的期望值，对随机变量采样的平均值可以作为 E[X] 的一个很好的近似。所以没有模型要有数据，没有数据要有模型才能学习。

课程大纲：

1.激励性实例（Motivating examples）：介绍蒙特卡洛估计（Mento Carlo Estimation）的基本思想

2.介绍三个基于蒙特卡洛（MC）强化学习的算法（这三个算法环环相扣，前一个是后一个的基础）

（1）最简单的基于 MC 的 RL 算法：MC basic（我们把上节课介绍的 policy iteration 方法当中基于模型的部分替换成不需要模型的部分（依赖于数据的）就得到了这个算法。是最简单的基于蒙特卡洛强化学习的算法，简单到这个算法在实际中不能用，因为效率很低，但他有利于揭示怎么样把模型给去掉，不基于模型来实现强化学习的这样一个核心idea，即它可以帮助理解之后的，因为强化学习是一环扣一环的）

（2）更高效地使用数据：MC Exploring Starts（把 MC basic 复杂化）

（3）MC 没有探索就启动：Algorithm: MC ε-Greedy（去除掉 exploring starts 这样的 assumption）

二.激励性实例（Motivating examples）

从 model-based 强化学习过渡到 model-free 的强化学习，最难以理解的就是我们如何在没有模型的情况下去估计一些量？（How can we estimate something without models）

最简单的方法：蒙特卡洛估算（Monte Carlo estimation）。

下面通过一个例子说明蒙特卡洛估算： 投掷硬币

投掷硬币后的结果（正面或背面朝上）用随机变量（random variable） X 表示

• 如果结果为正面朝上，则 X = +1
• 如果结果是背面朝上，则 X = -1

目的是计算 $\mathbb{E}[X]$（X 的平均数，X 的期望）。

这里有两种方法计算期望

• 方法 1 ：基于模型的（model-based）

假设概率模型为（我们知道随机变量（random variable） X 的概率分布（probability distribution））：正面朝上和背面朝上的概率都是 0.5
$$\qquad \qquad p(X = -1) = 0.5$$

那么随机变量（random variable） X 它的期望（expectation）就可以简单的通过定义计算：
$$\mathbb{E}[X] = \sum_{x}xp(x) = 1 \times 0.5+(-1)\times 0.5 = 0$$
**问题：**可能无法知道精确的概率分布情况（precise distribution）！！

• 方法 2 ：无模型的（model-free）

基本思想：多次掷硬币，做很多次实验，得到很多的采样，然后计算所有采样的平均结果。

假设我们做了 N 次实验，这 N 次的实验结果分别是 $x_1,x_2,…,x_N$，得到一个样本序列： $\dots,x_N}$。那么，均值可以近似为：
$$\mathbb{E}[X]\approx \bar{x} = \frac{1}{N}\sum_{j = 1}^N x_j$$
期望（expectation）用 $\bar{x}$ 来近似，认为 $\bar{x}$ 是 $\mathbb{E}[X]$

这就是蒙特卡洛估计的基本思想！

**问题：**用蒙特卡洛估计（Mento Carlo Estimation）是否精确？

• 当 N 较小时，近似值不准确。
• 随着 N 的增大，近似值会越来越精确。

如上图所示，我们已知真实的期望（expectation）是 0，随着做平均的样本数越多，样本的平均值（expectation）越接近真实的期望（expectation）0

上面这样直观的解释有数学理论做支撑（大数定律 Law of large Numbers）

iid：独立同分布样本（independent and identically distributed sample）

总结：

• 蒙特卡罗估计是指依靠重复随机抽样来解决近似问题的一大类技术。凡是需要做大量的采样实验，最后用实验的结果近似的的方法，都可以称为蒙特卡洛估计的方法。
• 我们为什么要关注蒙特卡罗估计？因为它不需要模型！
• 为什么要关注均值估计（mean estimation）？为什么用蒙特卡洛来估计期望（expectation）？
  • 因为状态值（state value）和行动值（action value）被定义为随机变量的期望值（expectation）！

三.最简单的基于 MC 的 RL 算法：MC basic

1.将策略迭代转换为无模型迭代（Convert policy iteration to be model-free）

理解算法的关键是理解如何将策略迭代算法（policy iteration algorithm）转换为无模型算法（model-free）。我们知道策略迭代算法（policy iteration algorithm）是依赖于模型的，但是实际上我们可以把它依赖于模型的那部分给替换掉，替换成 model-free 的模块

• 应充分理解策略迭代（policy iteration algorithm）。
• 应理解蒙特卡罗均值估计（Monte Carlo mean estimation）的思想。

接下来看策略迭代算法（policy iteration algorithm）如何转换为无模型（model-free）的：

策略迭代（policy iteration algorithm）的每一次迭代都有两个步骤：

• 1.策略评估：我有一个策略 $\pi_k$，通过求解贝尔曼公式，我要求出来它的状态值（state value）$v_{\pi_k}$
• 2.策略改进：知道 $v_{\pi_k}$ 之后就可以做改进，求解一个最优化问题得到一个新的策略 $\pi_{k+1}$。（通过选择最大的 $q_{\pi_k}$ 得到新的策略 $\pi_{k+1}$）

这里面非常核心的量是 $q_{\pi_k}(s,a)$

要计算动作值（action value） $q_{\pi_k}(s,a)$ 有两种算法：

**方法 1 需要模型：**这就是 value iteration 这个算法所使用的，第一步得到了 $v_{\pi_k}$，第二步这些概率模型都是知道的，所以就可以求出来 $q_{\pi_k}(s,a)$ （这些概率代表系统的模型）
$$q_{\pi_k}(s,a) = \sum_r p(r|s,a)r+\gamma \sum_{s'}p(s'|s,a)v_{\pi_k}(s')$$

原文发布于 CSDN：https://blog.csdn.net/m0_49683806/article/details/139234757

参考引用

【强化学习的数学原理-赵世钰】课程笔记（四）值迭代与策略迭代

一.内容概述

本节课讲的是 model base 的算法，下节课将会介绍 model-free 算法。值迭代和策略迭代和截断策略迭代都是求解最优状态值和最优策略的办法

• 值迭代算法（value iteration algorithm）：第三章的贝尔曼最优公式中，提到了有一个算法能求解贝尔曼最优公式，这个算法实际上就是值迭代算法。
• 策略迭代算法（policy iteration algorithm）：在第五章，不需要模型的蒙特卡洛方法中有重要应用。是下节课，蒙特卡洛学习（Mente Carlo learning）的一个基础
• 截断策略迭代算法（Truncated policy iteration algorithm）

值迭代算法和策略算法是截断策略迭代算法的极端情况

• 上面三个算法都有两个子步骤：policy update 和 value update
• 在当前时刻我有一个不太好的策略，我估计一下这个策略它的值，也就是做一下策略评价，我得到值之后就根据这个值改进一下策略，改进完了策略得到新的策略再估计它的值然后再改进策略，所以 policy update 和 value update 这两个步骤会不断迭代，最后就能找到最优的策略。
• 这样一个思想不只用在第四章当中，后面所有强化学习算法都是这样做的，都是值和策略，值和策略不断地迭代，只不过具体算法形式可能不同。

二.值迭代算法（value iteration algorithm）

这是上一节课由收缩映射定理（Contraction mapping theorem）给出的一个算法，这节课给它一个名字，给它两个步骤，正式的介绍出来：

贝尔曼最优公式（矩阵向量形式）：
$$f(v) = \max \limits_{\pi}(r_{\pi}+\gamma P_{\pi}v)$$
如何求解贝尔曼最优公式？ 在上一讲中，我们知道收缩映射定理提出了一种迭代算法：只要用下面这个算法就可以求出它的最优策略（optimal policy）和最优的状态值（optimal state value）
$$f(v_k) = \max \limits_{\pi}(r_{\pi}+\gamma P_{\pi}v_k),\qquad k = 1,2,3 \dots$$
其中 $v_0$ 可以是任意值。

• 这种算法最终能找到最优状态值和最优策略。
• 这种算法称为值迭代（value iteration）！
• 我们将看到，我们所学的关于 BOE 的数学知识终于得到了回报！

算法的矩阵向量形式如下：
$$f(v_k) = \max \limits_{\pi}(r_{\pi}+\gamma P_{\pi}v_k),\qquad k = 1,2,3 \dots$$
可以分解为（be decomposed）两个步骤：

• 第 1 步：在 vk 给定的情况下进行策略更新（policy update），求解 π，可以得到 πk+1 。这一步是处理方程右边的优化问题：
  $$\pi_{k+1} = arg \ \max \limits_{\pi}(r_{\pi}+\gamma P_{\pi}v_k)$$

​ 其中 $v_k$ 是给定的。

• 第 2 步：价值更新（value update）。把上一步求解出的 $\pi_{k+1}$ 带入第一个式子，第一个式子中下标的 $\pi$ 全部变成 $\pi_{k+1}$，然后根据 $v_k$ 可以求解出来 $v_{k+1}$
  $$v_{k+1} = r_{\pi_{k+1}}+\gamma P_{\pi_{k+1}}v_k$$

问题：$v_k$ 是状态值（state value）吗？

不是，因为不能确保 $v_k$ 满足贝尔曼方程。如果上式中，左边是 $v_k$，那它确实是一个贝尔曼公式，那么 $v_k$ 就是一个状态值（state value），但是左边并不是 $v_k$，而是 $v_{k+1}$。所以这里的 $v_k$ 就是一个向量，就是一个值，可以是任意的值，并不是状态值（state value）

理解：

• $v_k$ 只是某次迭代过程中没有收敛的一个值
• 是估计的state value,后面可以求解出最优的state value
• 因为不在在同一个policy下的 $v_k$迭代，所以没有收敛到当前policy下的state value
• 这就是我们胡乱假设的一个state value吧，老师说不算的意思大概是它还没迭代到位
• 其实是state value只是还没收敛
• 只能说 $v_k$ k无穷时，$v_k$ 的物理意义为state的估计。否则只是估计过程中的一个参数，没有意义
• 意思是最后无穷/有限多步收敛到的值才是state value吗？

接下来，我们需要研究元素形式（elementwise form），以便实现算法。

• 矩阵向量形式（Matrix-vector form）有助于理论分析（theoretical analysis）。
• 元素形式（elementwise form）有助于实现（implementation）。

1.第 1 步：策略更新（policy update）

• 如果有多个action有相同的 $q_k(s,a)$，那么可以任意选取一个，数学上都能达到最优
• 压缩映射定理 $v^*$ 存在且唯一
• $v^*$唯一，但策略不一定唯一，有两个最优策略，一般随机选一个

2.第 2 步：价值更新（value update）

3.流程总结，程序概要，并写成伪代码

对每一个 s，一开始有个 $v_k(s)$，$v_k$ 最开始可以从 $v_0$ 或者 $v_1$ 开始——>从 $v_k$ 可以计算得到 $q_k$——>得到 $q_k$ 后我知道哪个 $q_k$ 是最大的，然后知道它对应的 action 是什么，就可以得到贪婪策略（greedy policy）$πk+1$——>然后得到 $v_{k+1}$，$v_{k+1}$就对应最大的 $q_k$

这个过程可以写成下面的伪代码：

4.举例

用值迭代算法（value iteration algorithm）为下面的 a 图求解出一个最优的策略，图 b,c 是我们在使用算法进行迭代的过程中，每次我们都会得到一个策略 $\pi_{k+1}$，图 b,c 就是得到的策略 $\pi_{k+1}$，把它画在图中。

q 表（q-table）：$q(s,a)$ 的表达式（当给出 $v$ 的时候，能求出 $q$）

$k = 0$，先选取 $v_0$，可以任意选取，简单起见全选0，然后把 $v_0$ 带入刚才的 q-table 当中去：

先进行策略更新，针对每一个状态，我们去看哪个 $q_k$ 是最大的，那么它对应的新的策略就可以求出。对 $s_1$ 而言，选取动作 $a_3$ 和 $a_5$ 对应的 $q$ 最大，所以 policy 可以在最大的 $q$ 里面随便选一个（第 $k$ 步是对所有 $s$ 进行更新）

再进行价值更新，上面选出的最大的 $q_k$，作为新的 $v_1$ 进行下一步的使用

这个策略绘制出图片就是上面的 b 图，可以看出在 $s_2$ ，$s_3$ 和 $s_4$ 上都已经达到了最优，可以到达目标。但是在 $s_1$ 上还没有达到最优，因为当前策略是原地不动，但是最优策略需要到达目标。再进行下一步迭代：

$k = 1$，把上次迭代得到的 $v_1$ 带入刚才的 q-table 当中去：

这个策略绘制出图片就是上面的 c 图，可以看出在 $s_1，s_2 ，s_3 和 s_4$ 上都已经达到了最优，可以到达目标，已经求出来了最优策略。还可以进行下一步迭代，直到达到迭代终止条件：

三.策略迭代算法（policy iteration algorithm）

1.算法介绍

这是这节课新介绍的一个算法，下节课会在这个算法的基础上，得到一个 model free 的 reinforcement learning 的算法

算法描述：

给定随机初始策略 $π_0$（任意给定，可能是不好的策略，之后会迭代找到好的策略）

每次迭代分为两个步骤：

• 步骤 1：策略评估（PE）（Step 1: policy evaluation (PE)）

之前提过，policy evaluation 就是我给定一个策略 $π_k$（最开始是 $π_0$），可以求解它对应的贝尔曼公式，得到 $π_k$ 对应的 state value $v_{π_k}$，这样的过程就叫策略评估（policy evaluation）

• 步骤 2：策略改进 (PI)（Step 2: policy improvement (PI)）

上一步求出来了 $v_{π_k}$，我求解优化问题得到一个新的策略 $π_{k+1}$，$π_{k+1}$ 比 $π_k$ 更好

最大化是分量式的！

理解：

• policy iter 相当于比value iter提前了一步，从pi到v然后再经历完整的value iter到pi
• Policy iteration algorithm和Value iteration algorithm的区别就是你以policy为主体还是以state value为主体。
• PE里面包含了一层value iteration
• 其实在这两个iteration都会更新policy和valuie，只是先后的问题而已

该算法可以得到一个序列，用下面的过程来表示：最开始猜的 $π_0$ 肯定是不好的，然后我做 policy evaluation 得到 $v_{π_0}$，然后做 policy improvement 得到 $π_1$…

问题

• 问题 1：在策略评估（policy evaluation）步骤中，如何通过求解贝尔曼方程得到状态值（state value） $v_{π_k}$？
• 问题 2: 在策略改进（policy improvement）步骤中，为什么新策略 $π_{k+1}$ 比 $π_k$ 更好？
• 问题 3：为什么这种迭代算法能最终找到最优的策略？
• 问题 4: 这种策略迭代算法（policy iteration algorithm）与前一种值迭代算法（value iteration algorithm）之间的关系是什么？

问题 1： 在策略评估（policy evaluation）步骤中，如何通过求解贝尔曼方程得到状态值（state value） $v_{π_k}$？

假设给定一个策略（policy）$π_k$，我们可以列出来它的贝尔曼公式（ Bellman equation）如下：
$$v_{\pi_k} = r_{\pi_k}+\gamma P_{\pi_k}v_{\pi_k}$$
有两种方法可以求解这个贝尔曼公式得到状态值（state value）：

（1）闭式解为（The closed-form solution is），即状态值（state value）的解析表达式为：
$$v_{\pi_k} = (I-\gamma P_{\pi_k})^{-1}r_{\pi_k}$$
这个方法我们不太用，因为要求逆矩阵，经常用的是下面的方法

（2）迭代解决（iterative solution）方案是：（ $v_{π_k}$ 和 $v_{π_{k+1}}$ 都是向量，包含了不同时刻的所有状态值）最开始对 $v_{π_k}$ 有一个猜测，不断迭代就可以得到 $v_{π_k}$​
$$v_{\pi_k}^{(j+1)} = r_{\pi_k}+\gamma P_{\pi_k}v_{\pi_k}^{(j)},\qquad j = 0,1,2,\dots$$

• 已在贝尔曼方程中学习过。
• policy evaluation 是 policy iteration 这个算法的一步，这一步又依赖于一个迭代的算法（即上面的迭代解决（iterative solution）方案）。
• 策略迭代算法（policy iteration algorithm）是一种迭代算法，在策略迭代算法的策略评估（policy evaluation）步骤中嵌入了另一种迭代算法（iterative solution）（相当于有一个大的迭代算法，里面有一步又嵌入了一个小的迭代算法）

问题 2: 在策略改进（policy improvement）步骤中，为什么新策略 $π_{k+1}$ 比 $π_k$ 更好？

$π_{k+1}$ 是求解下面这个（$v_{π_k}$给定的）式子所得到的，可以证明 $v_{π_{k+1}}$ 一定大于等于 $v_{π_k}$，所以 $π_{k+1}$ 比$π_k$ 更好

问题 3： 为什么这种迭代算法能最终找到最优的策略？

由于每次迭代都会改进策略，我们知道：最优的状态值（state value）是 $v^$v∗
$$v_{\pi_0}\le v_{\pi_1}\le v_{\pi_2}\le \dots \le v_{\pi_k}\le \dots \le v^$$
因此，$v_{π_k}$ 会不断增加并收敛（keeps increasing and will converge）。仍需证明它收敛于 v*：

• 个人的理解是，PI是多轮的VI，VI只为了达成目的，但策略不一定最好，Pi相当于BFS算法一样，把最好的策略都完完全全走了一遍流程（因为只有求出贝尔曼才能说明他最好）

问题 4: 这种策略迭代算法（policy iteration algorithm）与前一种值迭代算法（value iteration algorithm）之间的关系是什么？

问题 3 给出的那个定理的证明（就是上面那个定理），即若要证明 policy iteration 的算法是收敛的，实际上用到了 value iteration 算法是收敛的这样的一个结果，所以它是基于 value iteration 算法的一个结果。

另外 policy iteration 和 value iteration 实际上是两个极端，是一个更 general 的截断策略迭代算法（Truncated policy iteration algorithm）的两个极端，稍后会介绍。

2.policy iteration algorithm 的具体实现

为了实现，我们要研究它的元素形式（Elementwise form）

步骤 1：策略评估（PE）（Step 1: policy evaluation (PE)）

步骤 2：策略改进 (PI)（Step 2: policy improvement (PI)）

流程伪代码：

值迭代和策略迭代的区别：

• 有差别，值迭代每一步得到的value是虚假的，但策略迭代每一步得到的value是真实的
• 区别是先求策略还是先求state value的问题
• 策略迭代里面包含值迭代，策略迭代时间复杂度更大
• 其实不同在于值迭代不同迭代次数间的state value是严格根据不动点迭代运算得到的
• policy iteration的终点应该是policy收敛不变，这比value收敛快很多
• 确实，值迭代是严格遵守不动点迭代的
• 这里对比值迭代算法，策略迭代算法实际就是多了一块策略评估。如果策略评估直接给定v0那么这个算法就是值迭代
• 可以把值迭代的value update看成一次策略评估，只不过评估的效果不是很好。补充一下，不好的原因是因为没有加入最好策略的计算
• Policy iteration先通过策略评估选取V_k，而不是随机初始化一个直接用了
• value感觉虽然在更新pi，但是实际上没有用pi，policy实际上是用了pi来计算v的

3.例子

（1）例子1

图 b 是最优策略，在 s1 的时候往右走，在 s2 的时候静止不动。图 a 是初始策略，都往左走是不合适的，我们用 policy iteration 的算法得到图 b 这样一个最优策略

k=0

该例子比较简单，该策略在一次迭代后达到最优！在您的程序设计中，应该继续运行，直到满足停止标准为止。
现在你知道了另一种搜索最优策略（optimal policies）的强大算法！现在，让我们应用它，看看能发现什么。

（2）例子2

例子的基本设置：

现在要做的是对这样一个 5×5 的网格，求一个最优策略。下面这些图画的是，我从最开始随便给定的一个策略 $π_0$，求出 $v_{π_0}$，policy improvement 得到 $π_0$，然后policy evaluation 得到 $v_{π_1}$，一直下去直到得到 $π_{10}$ 和 $v_{π_{10}}$

让我们来看看中间策略和状态值。

策略和状态值的有趣模式

• 可以看到，中间的策略不好，但是策略 $π_{10}$ 已经是一个最优的策略了，从任何一点（图中任何一个状态）出发都能到达目标区域。我们设置的 $r_{forbidden}$ 比较大，所以会避开障碍。
• 从图中还能看出一个现象，比较接近目标的状态的策略会先变好（从图中绿色的箭头可以看出），远离目标的状态的策略会后变好。从直观上这是因为，在某一个状态，我选择它的 greedy action，也就是 action 对应的最大的动作值（action value）$q_π(s,a)$的时候，严重依赖于其他状态的策略，如果其他状态的策略是不好的乱七八糟的，这时候虽然选一个最大的动作值（action value）$q_π(s,a)$ ，但是可能也是没有意义的。
• 当这个状态周围没有状态能到达目标区域时，它也不会到达目标区域，当有状态有能够到达目标区域的策略时，这个状态新的策略也能到达目标区域。

四.截断策略迭代算法（Truncated policy iteration algorithm）

这是前两个值迭代算法（value iteration algorithm）和策略迭代算法（policy iteration algorithm）的一般化推广；值迭代算法（value iteration algorithm）和策略迭代算法（policy iteration algorithm）是截断策略迭代算法（Truncated policy iteration algorithm）的特殊情况

针对Policy iteration ，它是从一个初始的策略 $\pi_0$ 出发，这个策略可能是非常不好的，任意猜测的这样一个策略，然后在第 k 个 iteration 当中，它包含两个步骤：

• 第一个是Policy evaluation(PE)，也就是在第 k 步当中，我又一个策略 $\pi_k$ , 然后这一步我要求解这个 $v_{\pi_k}$ ，从这个贝尔曼公式当中。
• 第二个是Policy improvement(PI)：根据刚才求出的 $v_{\pi_k}$ ，然后再求解一个这样优化的式子，我可以得到一个新的策略 $\pi_{k+1}$​ ，然后再不断地迭代下去。

针对Value iteration ，它不是从一个初始的策略 $\pi_0$ 出发 ，它是从一个值 $v_0$ 出发，这个值 $v_0$ 可以是任意的一个值，然后通过值迭代算法它最后能收敛到 $v^*$​ （最优状态值：Optimal state value），然后在第 k 个 iteration 当中，它包含两个步骤：

• Policy update（PU）：在第 k 步当中，已知 $v_k$ ，求解优化的式子得到 $\pi_{k+1}$ 。一个新的策略。
• Value update（VU）：我刚才知道了 $\pi_{k+1}$，还有 $v_k$，根据其他几个已知量，就可以求出这个 $v_{k+1}$ 。然后再这样不断地迭代下去。

这两种算法非常相似：

理解：

• $u$ 不是真实的状态价值
• $u_0$ 可以看成未收敛的state value，就是一个中间值
• 这个前面提到过了，状态价值（state value）是需要贝尔曼方程求解得到的，而这里 u0 只是由策略求出来的一个值，并不是状态价值

让我们仔细比较一下这些步骤：

理解：

• 值迭代的状态值 $v$ 经过一步计算获得 策略迭代的状态值 $v$ 需要迭代计算获得
• 开始一个需要policy一个不要。value更新时Policy iteration每一个value的求解都得Bellman公式求解，Value iteration直接一步带入
• policy iteration直接一步到位，value iteration 还在迭代
• 太妙了，这里 $v$ 的下标是 $\pi$ 的时候，表示一个值函数；是数字的时候，不表示值函数了，只是一个迭代中的变量
• 确实，值迭代中外框架是用一个序列逼近真实的 $v$，所以值迭代里的v你可以理解为v的估计\中间计算步骤，而策略迭代里的v是通过PE评估一个确定的策略得到的
• value iteration: v-p-v-p-v-p-v-p-…；policy iteration: p-vvvvv…-p-vvvvv…-p-vvvvv.
• 值迭代算法只迭代一次，策略迭代算法迭代无穷多次

• 由上图可知，在第四步中 value iteration 只计算了一步，就得到 $v_1$，而 policy iteration 要计算无穷多步才能得到 $v_{\pi_1}$。那么自然能想象到有没有一个中间步，只计算 $j$ 次，把 $v_{\pi_1}^{(j)}$ 作为一个新的量，把它作为新的值放到下一步计算策略，这样的算法叫截断策略迭代算法（Truncated policy iteration algorithm），之所以是 Truncated，因为从 $j$ 到 $\infty$ 的这些步骤全都被截断了。
• 所以截断策略迭代算法（Truncated policy iteration algorithm）是前两个值迭代算法（value iteration algorithm）和策略迭代算法（policy iteration algorithm）的一般化推广。
  • 当 $j = 1$，截断策略迭代算法（Truncated policy iteration algo rithm）变成了值迭代算法（value iteration algorithm）；
  • 当 $j = \infty$，截断策略迭代算法（Truncated policy iteration algorithm）变成了策略迭代算法（policy iteration algorithm）
• 在实际当中策略迭代算法（policy iteration algorithm）不存在，因为不可能计算无穷多步，我们经常做的是判断 $v_{\pi_1}^{(j)}$ 和 $v_{\pi_1}^{(j-1)}$ 这两个它们之间的 error 是否足够小，足够小就停止迭代，这样的话它仍然是计算了有限步。所以在实际当中即使我们要计算策略迭代算法（policy iteration algorithm）它也仍然是一个截断策略迭代算法（Truncated policy iteration algorithm）

伪代码：

收敛的意思就是，收敛到一个怎么迭代都不太会改变的值

因为没有计算无穷多步，所以此时的 $\ne v_{\pi_k}$，那么此时的截断是否会带来一些问题呢？比如是否会使整个算法不再收敛？

截断是否会削弱收敛性？下面给出一个定理：

考虑Policy iteration在策略评估步骤(PE)求解贝尔曼公式时的迭代算法

如果这个迭代算法的初始值比较特殊如 $v_{\pi_{k-1}}$，可以证明在这个迭代算法中，$v_{\pi_{k+1}}$ 一定是 比 $v_{\pi_k}$ 大的，所以计算1 次也会增大，计算 j 次也会增大，计算 $\infty$ 也会增大 ($\infty$ 次 代价太大，用有限步即可)

刚才这个结果可以通过下图比较好的展示出来，这个图的横轴是 $k$，即 policy iteration 算法中的迭代次数 iteration 的索引（index） ，纵轴是值，简单起见，state value 只有一维。红线 $v^$v∗ 代表最优状态值（optimal state value），其他曲线是上面三种算法，通过迭代都最终收敛到 $v^$

PI 的收敛证明基于 VI 的收敛证明。既然 VI 收敛，我们就知道 PI 收敛。

例子：

设置： 与上一示例相同。以下是初始策略，目标是找一个最优策略

• “截断策略迭代（Truncated policy iteration）-x”，其中 x = 1、3、6、100 指的是截断策略迭代算法，其中策略评估步骤（the policy evaluation step）运行 x 次迭代。
• 每个小图右上角标签上的数字意思是，每次在大的 Truncated policy iteration 中有一个嵌套的迭代的次数（在策略评估那一步 policy evaluation），如果是 value iteration 只迭代一次，如果是 policy iteration 则迭代无穷多次，把那个次数设为 x。
  • 当 x=1 时，就是 value iteration，最上面一幅图，要到50多步的时候 $v_k$ 与 $v^*$ 的误差才小于 0.01；
  • 如果 x=3，那么它20多步就小于 0.01 了，可以加快收敛速度；
  • x=6，x=100的时候也可以加快收敛，但是效果越来越不明显。
• 上图横坐标是最外面的迭代次数，这里迭代的步数应该是外面PE，PI的步数

结论：

• x 值越大，估计值收敛得越快。
• 但是，当 x 值越大时，增加 x 值的好处就会迅速减少。
• 在实际操作中，在策略评估步骤中运行少量的迭代，尽量不要每次计算一步，也不要计算很多步，尽量稍微多计算几步就能有很大收获。
• 外层循环相比内层循环要多计算很多东西，每一次迭代花费的时间不一样，所以找一个折中方案。让外层尽量少，内层又不至于过多

五.总结

原文发布于 CSDN：https://blog.csdn.net/m0_49683806/article/details/139198327

学习引用

【强化学习的数学原理-赵世钰】课程笔记（三）贝尔曼最优公式
【强化学习的数学原理】课程：从零开始到透彻理解（完结）

内容梗概

1. 第三章主要有两个内容

（1）核心概念：最优状态值（optimal state value）和最优策略（optimal policy）。强化学习的目的就是寻找最优策略。

• 最优策略定义：我沿着这个策略能得到最大的状态值，沿着其他所有策略得到的状态值都没他大。

（2）基本工具：贝尔曼最优方程/公式（Bellman optimality equation）（BOE）：贝尔曼最优公式和最优策略有关系，使用贝尔曼最优公式分析最优策略，贝尔曼最优公式可以求解出最优策略和最优的 state value。

• 使用不动点原理分析，这个不动点原理告诉我们这个式子两个方面的性质：
• 第一个方面是我要求解最优策略，最优 state value，那么它们到底是否存在呢，这种存在性非常重要。虽然存在但是最优的策略不一定是唯一的，但是最优的状态值是唯一的，最优的策略可能是确定性的 deterministic，也可能是随机性的 stochastic；
• 另外一个方面是他能给出一个算法求解贝尔曼最优公式，把这个公式求解出来了自然就得到了最优的策略和最优的 state value，强化学习的目标也就达到了

2. 第二章大纲

（1）激励性实例（Motivating examples）

（2）最优状态值（optimal state value）和最优策略（optimal policy）的定义

（3）贝尔曼最优公式（BOE）：简介

（4）贝尔曼最优公式（BOE）：右侧最大化

（5）贝尔曼最优公式（BOE）：改写为 $v = f(v)$

（6）收缩映射定理（Contraction mapping theorem）

（7）贝尔曼最优公式（BOE）：解决方案

（8）贝尔曼最优公式（BOE）：解的最优性

（9）分析最优策略（Analyzing optimal policies）

二.激励性实例（Motivating examples）

绿色箭头代表策略 $\pi$

贝尔曼公式：

状态值（state value）： 设 $\gamma = 0.9$。那么可以计算出：
$$v_\pi(s_4) = v_{\pi}(s_3) = v_{\pi}(s_2) = 10 \qquad \qquad v_{\pi}(s_1) = 8$$
动作值（action value）可以通过状态值计算，或者根据第二章公式计算：考虑 $s_1$，$s_1$共有 5 个 action ，每个 action 都有一个 state value 。

问题： 当前的策略（policy）不好，因为在 $s_1$ 的时候往右走了，进入禁区，那么如何改进？

答案： 我们可以根据动作值（action value）改进策略（policy）。

具体来说，当前策略 $\pi(a|s_1)$ 是：
$$\pi(a|s_1) = \left{\begin{matrix}1& & a = a_2\\ 0& & a\ne a_2 \end{matrix}\right.$$
在这个策略下我们已经计算出来了 action value，观察我们刚才获得的动作值（action value）：

我们发现 $a_3$ 对应的动作值（action value）最大，那么能不能选择 $a_3$​ 作为一个新的策略呢。如果我们选择最大的动作值（action value）呢？那么，新策略（policy）就是：
$$\pi_{new}(a|s_1) = \left{\begin{matrix}1& & a = a^$$\\ 0& & a\ne a^ \end{matrix}\right.
其中：$q_\pi(s_1,a)$ 在 $a = a_3$ 时最大

其中，$a^*$ 对应 action value 最大的那个 action，在这个例子里面是 $a_3$

问题： 为什么选择 action value 最大的 action 这样做能改进策略？

• 直觉：动作值（action value）可用于评估动作，动作值本身就代表了 action 的价值，如果选择一个 action ，他的 action value 很大，意味着之后能得到更多的 reward，相应策略也比较好。
• 数学：并不复杂，将在本讲座中介绍。

​ 只要我们一遍一遍去做，不断迭代，最后一定会得到一个最优策略。也就是说，首先对每个状态都选择 action value 最大的 action，选择完了一次，然后再来一次迭代得到一个新的策略，再迭代得到一个新的策略，最后那个策略一定会趋向一个最优的策略

三.最优策略（optimal policy）的定义

状态值（state value）可用于评估策略好或者不好：如果有两个策略 $\pi_1$ 和 $\pi_2$，它们在每个状态都有自己的状态值（state value），如果对所有的状态 $s$ ，$\pi_1$ 得到的 state value 都大于 $\pi_2$ 得到的 state value，则 $\pi_1$ 比 $\pi_2$ “更好”。
$$v_{\pi_1}(s)\ge v_{\pi_2}(s)\qquad for \ \ all \ \ s \in S$$

原文发布于 CSDN：https://blog.csdn.net/m0_49683806/article/details/137464758

一. 内容概述

1. 第二章主要有两个内容

（1）一个核心概念：状态值（state value）：从一个状态出发，沿着一个策略我所得到的奖励回报的平均值。状态值越高，说明对应的策略越好。之所以关注状态值，是因为它能评价一个策略的好坏。

（2）基本工具：贝尔曼公式（the Bellman equation）：

• 用于分析状态值，描述所有状态和状态值之间的关系，这个关系就是一个方程，一个等式。通过求解这个方程就可以求解出来一个给定策略的状态值，因此就可以评价这个策略的好坏。
• 求解贝尔曼公式进而得到一个策略所对应的状态值这样的一个过程被称为策略评价（policy evaluation），policy evaluation 在强化学习中是非常基础的一个概念，我评价了一个策略得到它的值，然后基于它的值再改进策略然后循环下去，最后就能得到一个最优的策略。

2. 第二章大纲

1. 激励性实例（Motivating examples）
2. 状态值（state value）
3. 贝尔曼公式（ Bellman equation）：推导
4. 贝尔曼公式（ Bellman equation）：矩阵向量形式
5. 贝尔曼公式（ Bellman equation）：求解状态值（state value）
6. 动作值：从 state value 过渡到 action value

二. 激励性实例（Motivating examples）

1. 例子1：为什么回报/收益（return）很重要？

（1）什么是回报（return） ？

​ 沿着轨迹获得的奖励（reward）的（折扣discounted）总和。

​ What is return? The (discounted) sum of the rewards obtained along a trajectory.

（2）为什么回报（return）很重要？

下图的第三个表示，这个策略在 s1 状态有百分之 50 的概率向右，有百分之 50 的概率向下。

​ 问题： 从起点 $s_1$ 出发，哪项策略（policy）是 “最好的”？哪项 “最差”？

​ 直觉： 第一个最好，第二个最差，因为第二个进入了forbidden area。第三个策略是不好也不差，它有一定的概率进入forbidden area。

​ 数学： 我们能用数学来描述这种直觉吗？

回报（return）可以用来评估策略（policy），return 可以告诉我们哪个策略好，哪个策略坏，这样才能不断地改进策略。请参阅下文。

• 根据策略 1（左图），从 $s_1$ 开始，折扣回报（discounted return）为

$$\begin{align}return_1 & = 0+\gamma 1+\gamma^2 1+\dots,\\ & = \gamma(1+\gamma+\gamma^2+\dots),\\ & = \frac{\gamma}{1-\gamma}\end{align}$$

• 根据策略 2（中图），从 $s_1$ 开始，折扣回报（discounted return）为

$$\begin{align}return_2 & = -1+\gamma 1+\gamma^2 1+\dots,\\ & = -1+\gamma(1+\gamma+\gamma^2+\dots),\\ & = -1+\frac{\gamma}{1-\gamma}\end{align}$$

• 根据策略 3（右图），从 $s_1$ 开始，折扣回报（discounted return）为（策略3是随机性的Policy 3 is stochastic!）

$$\begin{align}return_3 & = 0.5(-1+\frac{\gamma}{1-\gamma})+0.5(\frac{\gamma}{1-\gamma})\\ & = -0.5+\frac{\gamma}{1-\gamma}\end{align}$$

策略 3 这里其实是在计算期望。这里已经不是 return 的概念了，return 的概念是针对一个轨迹定义的，现在有两个轨迹，我们在做的是求平均值，即求期望。其实这里求的是状态值（state value）。

总之，从 $s_1$ 开始
$$return_1 > return_3 > return_2$$
上述不等式表明，第一种策略是最好的，第二种策略是最差的，这与我们的直觉完全相同。

计算回报（return）对于评估一项策略非常重要。

2. 例子2：如何计算回报（return）？

上图中四个状态（state）是 $s_1,s_2,s_3,s_4$，策略（policy）是绿色的箭头，奖励（reward）是 $r_1,r_2,r_3,r_4$。

（1）方法1：通过定义

让 $v_i$ 表示从 $s_i(i = 1,2,3,4)$出发得到的回报（return）。

注意，轨迹是无穷的，例如，从 $s_1$ 出发：$s_1 \rightarrow s_2 \rightarrow s_3 \rightarrow s_4 \rightarrow s_1 \rightarrow s_2\dots.$会一直走下去
$$\begin{align}v_1 & = r_1+\gamma r_2+\gamma^2 r_3+\dots \\ v_2 & = r_2+\gamma r_3+\gamma^2 r_4+\dots \\ v_3 & = r_3+\gamma r_4+\gamma^2 r_1+\dots \\ v_4 & = r_4+\gamma r_1+\gamma^2 r_2+\dots \\ \end{align}$$

（2）方法2：

$$\begin{align}v_1 & = r_1+\gamma(r_2+\gamma r_3+\dots) = r_1+\gamma v_2 \\ v_2 & = r_2+\gamma(r_3+\gamma r_4+\dots) = r_2+\gamma v_3 \\ v_3 & = r_3+\gamma(r_4+\gamma r_1+\dots) = r_3+\gamma v_4 \\ v_4 & = r_4+\gamma(r_1+\gamma r_2+\dots) = r_4+\gamma v_1 \\ \end{align}$$

​ 上面这一组式子告诉我们：从不同状态出发得到的 return 依赖于从其他状态出发得到的 return，回报（return）相互依赖。

​ 这一思想在强化学习中被称为 Bootstrapping !

现代的意思就是引申出来：我从自己出发，然后不断地迭代所得到的一些结果。

如何使用这些方程？把上面的一组式子写成矩阵向量的形式（matrix-vector form）：

​ 可被重写成一种更简化的形式：
$$\gamma Pv$$

$I$ (identity matrix)减去 $\gamma$ 然后乘以P 矩阵，然后乘以 $v$ 就等于 $\gamma$ ，把$(I − v P)(I-vP)$这个矩阵求逆，然后乘以 $\gamma$ ，就得到了 $v$ 。

从上面的方程可以解出从不同状态出发的价值（value） v ，这就是贝尔曼公式（针对这个特定的确定性 deterministic 问题）！

• 虽然简单，但它展示了核心概念：一个状态（state）的价值（value）依赖于其他状态（state）的价值（value）
• 矩阵向量形式更容易理解如何求解状态值（state value）。

​ 练习：

​ 考虑图中所示的策略（policy）。请写出回报（return）之间的关系（即写出贝尔曼方程）

​ 答案：（从 $s_1$ 出发，以奖励 0 到状态 $s_3$ ，从状态 $s_3$ 出发得到的 return 是 $v_3$；从 $s_2$ 出发，以奖励 1 到状态 $s_4$ ，从状态 $s_4$ 出发 得到的 return 是 $v_4$；…）
$$\begin{align}v_1 = 0+\gamma v_3 \\ v_2 = 1+\gamma v_4 \\ v_3 = 1+\gamma v_4 \\ v_4 = 1+\gamma v_4 \\ \end{align}$$
​ 如何求解？这是一个线性方程组，很好求解。 我们可以先计算 $v_4$，然后计算 $v_3,v_2,v_1$。

三. 状态值（state value）

​ 单步：

单步（single-step）流程： b
$$\xrightarrow{A_t}R_{t+1},S_{t+1}$$

• $t,t+1$：离散时间实例，$t$ 指当前的时刻，$t+1$ 指下一个时刻
• $S_t：t$ 时刻的状态
• $A_t$：在状态 $S_t$ 采取的动作
• $R_{t+1}$：在状态 $S_t$ 采取动作 $A_t$ 之后获得的奖励（reward）（有时也写成 $R_t$，写成什么都没有区别，只是一个习惯，但是一般都写成 $R_{t+1}$）
• $S_{t+1}$：采取动作 $A_t$ 后转换到的状态

​ 注意，$S_t、A_t、R_{t+1}$ 都是大写的，代表随机变量（random variables），就是我们可以对它进行一系列的操作，比如求期望（expectation）。

​ 每一步的所有跳跃（step）都由以下概率分布（probability distributions）所决定：

• 在 $S_t$ 要采取什么样的动作（action）由 策略 $\pi$ 来决定
• 在 $S_t$ 采取动作（take action）$A_t$，要得到什么样的奖励（Reward）由奖励概率（reward probability） 决定
• 在 $S_t$ 采取动作（take action）$A_t$，要跳到下一个什么状态（State）由状态转移概率（ state transition probability） 决定

​ governed：受约束的，所规管的

​ 多步：

​ 考虑以下多步骤轨迹（multi-step trajectory）：
$$\xrightarrow{A_t}R_{t+1},S_{t+1}\xrightarrow{A_{t+1}}R_{t+2},S_{t+2}\xrightarrow{A_{t+2}}R_{t+3},\dots$$
​ 折扣回报（discounted return） $G_t$ 是所有瞬时回报（immediate reward）与折扣因子（discount rate）乘积相加：
$$\gamma R_{t+2}+\gamma^2 R_{t+3}+\dots$$

• $\gamma \in[0,1)$ 是折扣率（discount rate）。
• $G_t$ 也是一个随机变量（random variables），因为 $\dots$都是随机变量（random variables）。

​ 正式定义状态值（state value）：

​ 折扣回报（discounted return）$G_t$ 的期望值（或称为期望值 expectation 或平均值 mean）被定义为状态值函数（state-value function），或简称为状态值（state value）：

​ 注意：

• 状态值（state value）它是 s 的函数， 是一种条件期望（conditional expectation），条件是状态从 s 开始。从不同的状态 s 出发，得到的轨迹不同，得到的折扣回报（discounted return）$G_t$ 也不同
• 状态值（state value）它是策略 $\pi$ 的函数， 对于不同的策略（policy） ，会得到不同的轨迹，不同的轨迹会得到不同的折扣回报（discounted return）$G_t$，就会得到不同的状态值（state value）
• 它代表一个状态的 “价值”。如果状态值（state value）越大，那么从这个状态出发的策略（policy）就更好，因为可以获得更大的累积回报（return）。

​ 问： 回报（return）与状态值（state value）之间的关系是什么？

​ 答：

回报（return）是针对单个轨迹（trajectory）求的 return；

状态值（state value）针对多个轨迹（trajectory）得到的 return 再求平均值。

如果从一个状态出发，有可能得到多个轨迹（trajectory），这时候回报（return）与状态值（state value）显然有区别；

但假如从一个状态出发，一切都是确定性的，只能得到一条轨迹（trajectory），这时候那个状态的回报（return）与那个状态的状态值（state value）是一样的。

例子：

​ 这三个例子分别对应三个策略 $\pi_1,\pi_2,\pi_3$，三个策略导致了三个轨迹（trajectory 理解为根据策略可能走出的轨迹），要计算在这三个不同策略下同一个状态 $s_1$ 的状态值（state value）

​ 策略 1 和 2 从 $s_1$ 出发，能得到唯一的一个 trajectory，这个 trajectory 的 return 就是它们分别的 state value

​ 策略 3 有两条轨迹，状态值（state value）是这两条轨迹分别得到的回报（return）的平均值。就是把 probability 乘到前面去，这实际上就是期望（expectation）的求法。

​ 比较三个策略导致的状态值（state value）的大小可知，第一种策略是最好的，第二种策略是最差的，这与我们的直觉完全相同。

四. 贝尔曼公式：推导

1. 推导

• 状态值（state value）固然重要，但如何计算呢？答案就在贝尔曼公式（Bellman equation）中。
• 总之，贝尔曼公式（Bellman equation）描述了不同状态的状态值（state value）之间的关系。

​ 考虑一个随机轨迹：
$$\xrightarrow{A_t}R_{t+1},S_{t+1}\xrightarrow{A_{t+1}}R_{t+2},S_{t+2}\xrightarrow{A_{t+2}}R_{t+3},\dots$$
​ 折扣回报（discounted return）$G_t$ 可写成
$$\begin{align}G_t & = R_{t+1}+\gamma R_{t+2}+\gamma^2 R_{t+3}+\dots \\ & = R_{t+1}+\gamma(R_{t+2}+\gamma R_{t+3}+\dots)\\ & = R_{t+1}+\gamma G_{t+1}\end{align}$$
​ 所以这个时刻我所得到的 return 等于我能立即得到的奖励（immediate reward）$R_{t+1}$ 加上到下一时刻从那出发能得到的 return （futrue reward）乘以 discount rate

​ 那么，根据状态值（state value）的定义可以得出
$$\begin{align}v_{\pi}(s)& = \mathbb{E}[G_t|S_t = s]\\ & = \mathbb{E}[R_{t+1}+\gamma G_{t+1}| S_t = s]\\ & = {\color{blue}\mathbb{E}[R_{t+1}|S_t = s]}+\gamma{\color{blue}\mathbb{E}[G_{t+1}|S_t = s]}\end{align}$$
​ 接下来，分别计算这两个项，求出他们的形式，就得到了贝尔曼公式

​ 首先，计算第一项 $\mathbb{E}[R_{t+1}|S_t = s]$：当前时刻我在状态 s ，我得到的立即奖励（immediate reward）是 $R_{t+1}$
$$\begin{align}\mathbb{E}[R_{t+1}|S_t = s]& = \sum_a \pi(a|s)\mathbb{E}[R_{t+1}|S_t = s,A_t = a]\\ & = \sum_a \pi(a|s)\sum_r p(r|s,a)r \end{align}$$
​ 理解：

这里的 $S_t,A_t,R_{t+1}$都是集合，所以对于任意时刻的 $t$ ，$s$ 是确定的，$A$ 可能有几种不同选择，而之前的例子是确定性奖励，所以对于 $R$ 是一个集合（变量）印象不深。最简单的就是抽奖，你每次执行同样的行为得到的奖励却不同，所以这里需要求和（或者是积分）。

​ 在状态 s ，我有多个 action 可以去选择，take action a 的概率是 $\pi(a|s)$，当我 take action a 我所得到的 value 是 $\mathbb{E}[R_{t+1}|S_t = s,A_t = a]$。$\mathbb{E}[R_{t+1}|S_t = s,A_t = a]$ 可以写成 $\sum\limits_r p(r|s,a)r$

​ 意思是，从 $s$ 出发，take action $a$，得到的奖励（reward）是 $r$ 的概率是 $p(r|s,a)$，根据期望的定义，取值为 $r$ 的概率乘以 $r$ 本身就是期望。

​ 注意： 第一项其实就是我能得到的立即奖励（immediate reward）的期望/平均

• 大写的 S 不确定，小写的 s 是确定的。在前面的 state value 定义时已说明，S、R 表示随机变量。
• 这里的大写 St，At，Rt+1都是集合，所以对于任意时刻 t，S 是确定的，A 可能有几种不同选择。 而之前的例子是确定性奖励，所以对于 R 是一个集合（变量）印象不深。最简单的就是抽奖，你每次执行同样的行为得到的奖励却不同
• 这里 Π（a|s) 是采取动作 a 的概率，后面一项是采取这个动作之后，到下一个不同状态的概率
• 比如我有 0.5 概率（pai）撞到墙，但是撞到墙之后有 0.1 概率原地不动，也有 0.9 概率后退一步，这部分内容就是后面的 p
• 这里就是枚举了所有动作下的概率和收益的成绩加起来算了期望
• 就是两次离散型随机变量计算期望

​ 其次，计算第二项 $\mathbb{E}[G_{t+1}|S_t = s]$：第二项是我从当前状态 $s$ 出发得到的下一个时刻的回报（return）的期望（mean）

• 第一行：从当前 $s$ 出发，有多个选择，可以跳到不同 $s'$，跳到不同 $s'$ 的概率是 $p(s'|s)$，跳到不同 $s'$ 所得到的值是 $\mathbb{E}[G_{t+1}|S_t = s,S_{t+1} = s']$，一相加就是 (expectation) $\mathbb{E}[G_{t+1}|S_t = s]$
• 从第一行到第二行：$\mathbb{E}[G_{t+1}|S_t = s,S_{t+1} = s']$ 意思是当前状态是 $s$，下一个状态是 $s'$，计算从下一个状态出发所得到回报（return）的期望（mean），第二行 $\mathbb{E}[G_{t+1}|S_{t+1} = s']$ 把第一行中那一项的 $S_t = s$ 去掉了，因为我已经知道了下一个状态是 $s'$，就不用关心我之前究竟是在什么状态了，这其实就是马尔可夫的性质，是无记忆的（memoryless Markov property）
• 从第二行到第三行：$\mathbb{E}[G_{t+1}| S_{t+1} = s']$ 意思是从下一个状态 s’ 出发计算我所能得到的回报（return）的平均值（mean），这个就是第三行写的一个状态值（state value）$v_\pi(s')$，只不过是针对 $s'$ 的状态值（state value）$v_\pi(s')$。——最开始的状态值（state value）的定义
• 从第三行到第四行：从 $s$ 到 $s'$ 的概率 $p(s'|s)$：从 $s$ 出发我有多种选择，可以选择不同的动作（action），选择 action a 的概率是 $\pi(a|s)$ ，选择这个 action 我跳到 $s'$ 的概率是 $p(s'|s,a)$，通过两者相乘相加可以得到 $p(s'|s)$。

注意：

• 第二项是 future reward 的平均（mean）
• $\mathbb{E}[G_{t+1}|S_t = s,S_{t+1} = s'] = \mathbb{E}[G_{t+1}|S_{t+1} = s']$ 是由于由于无记忆马尔可夫特性（memoryless Markov property）

​ 贝尔曼公式（Bellman equation）：此处 $\sigma$ 后面应该加一个左大括号 {，右大括号在式子的最后面 }

​ 强调，由方程中的符号可以得出以下重点：

• 上述方程称为贝尔曼方程（Bellman equation），它描述了不同状态（states）的状态值函数（state-value functions）之间的关系：因为看上面式子标红的地方，上面式子等式左边是 $s$ 的状态值（state value），等式右边是 $s'$ 的状态值（state value），他们的关系可以通过这样的一个式子表达出来。
• 它由两个项组成：即时奖励项（immediate reward term）和未来奖励项（future reward term）。
• 这是一组等式：每个状态（state）都有这样的等式！！！这不是一个式子，这个式子对状态空间中的所有状态都成立（等式后面的取值范围是 $\forall s \in S$），所以如果有 n 个状态，就有 n 个这样的式子，通过这 n 个式子可以求解出状态值（state value）。

• $v_\pi(s)$ 和 $v_\pi(s')$ 是我们要计算的状态值，计算的思想就是 Bootstrapping ! 直观上来讲，等式左边的状态值（state value）$v_\pi(s)$ 依赖于等式右边的状态值（state value）$v_\pi(s')$，看起来好像没法计算，其实我们有一组这样的式子，把这些式子连立就可以算出来。
• 公式中的 $\pi(a|s)$ 是给定的策略 policy（是一种概率 probability）。解方程称为策略评估（policy evaluation）：贝尔曼公式依赖于策略（policy），如果我们能计算出状态值（state value），其实我们在做的一件事就是评估这个策略（policy evaluation）究竟是好是坏 。
• 奖励概率 （Reward probability） $p(r|s,a)$ 和状态转换概率（State transition probability） $p(s'|s,a)$ 代表的是动态模型（dynamic model）或称为环境模型（environment model） ：分两种情况，一种是我们知道这个模型（model），在本节和下节当中我们都会假设知道这个 model，给出来相应的算法；一种是不知道模型（model），这种情况下我们仍然可以求出 state value，这就是 model free reinforcement learning 的算法。

2. 例子

（1）例子1：

​ 图中的策略 $\pi$ 由绿色的箭头表示

​ 根据一般表达式（general expression）写出贝尔曼方程：
$$v_\pi(s) = \sum_a \pi(a|s)\left[\sum_r p(r|s,a)r+\gamma \sum_{s'}p(s'|s,a)v_{\pi}(s')\right]$$
​ 这个例子很简单，因为策略（policy）是确定的（deterministic）。

​ 首先，考虑 $s_1$ 的状态值（state value）：
$$\pi(a = a_3|s_1) = 1 \ \ and \ \ \pi(a \ne a_3 | s_1) = 0 \\ p(s' = s_3|s_1,a_3) = 1 \ \ and p(s' \ne s_3 | s_1,a_3) = 0 \\ p(r = 0|s_1,a_3) = 1 \ \ and p(r \ne 0 | s_1,a_3) = 0$$
​ 将上面这些概率和值代入贝尔曼方程，得出：（下面这个式子和上面在 二.2 那部分用激励性例子 2 介绍的方法计算出的结果一样，即与上面直观计算出的结果是一样的，虽然此时是用复杂贝尔曼公式得到的，但从直观上来讲很容易理解）
$$v_\pi(s_1) = 0+\gamma v_{\pi}(s_3)$$
​ 类似地，可以得出
$$v_\pi(s_1) = 0+\gamma v_{\pi}(s_3)\\ v_{\pi}(s_2) = 1+\gamma v_{\pi}(s_4)\\ v_{\pi}(s_3) = 1+\gamma v_{\pi}(s_4)\\ v_{\pi}(s_4) = 1+\gamma v_{\pi}(s_4)$$
​ 从最后一个方程到第一个方程，逐一求解上述方程，得到：
$$v_\pi(s_4) = \frac{1}{1-\gamma}\\ v_{\pi}(s_3) = \frac{1}{1-\gamma}\\ v_{\pi}(s_2) = \frac{1}{1-\gamma}\\ v_{\pi}(s_1) = \frac{\gamma}{1-\gamma}\\$$
​ 如果 $\gamma = 0.9$，那么
$$v_\pi(s_4) = \frac{1}{1-0.9} = 10 \\ v_{\pi}(s_3) = \frac{1}{1-0.9} = 10\\ v_{\pi}(s_2) = \frac{1}{1-0.9} = 10\\ v_{\pi}(s_1) = \frac{0.9}{1-0.9} = 9\\$$
​ 计算出 $s_1$ 的状态值是 9，$s_2,s_3,s_4$ 的状态值是 10。状态值（state values）代表这个状态的价值，如果一个状态的价值高，说明这个状态是值得我们往那个方向走的，之所以 $s_2,s_3,s_4$ 的价值高，是因为它们距离 target area 比较近。

计算出状态值（state values）后干什么？

耐心等待（计算行动值（action value）并改进策略（improve policy）），慢慢的就会得到最优策略。

​ $s_2$ 不是陷阱吗？为什么状态值那么高？

• 前面提到过，reward 是给动作打分，现在的 $v$ 是状态的得分，所以虽然 $s_2$ 是陷阱，但是进入陷阱的惩罚是不体现在陷阱这个状态里面的
• 陷阱的负价值体现在 $s_1$ 的 value 是最小的上面，因为只有 $s_1$ 有可能往陷阱走
• $s_2$ 的策略是走向 $s_4$，这个是高价值的；如果 $s_1$ 还有一个策略是走向 $s_2$，那么 $s_1$ 的 value 还会进一步降低

（2）例子2

$$v_\pi(s) = \sum_a \pi(a|s)\left[\sum_r p(r|s,a)r+\gamma \sum_{s'}p(s'|s,a)v_{\pi}(s')\right]$$

• 写出每个状态的贝尔曼方程。
• 求解贝尔曼方程中的状态值。
• 与上一个示例中的策略进行比较。

在这个策略（policy）下，计算出 $s_1$ 的状态值（state value）是 8.5，$s_2,s_3,s_4$ 的状态值（state value）是 10。而在上一个策略（policy）下 $s_1$ 的状态值（state value）是 9。

所以这个策略没有刚才的策略好。

五.贝尔曼公式（ Bellman equation）：矩阵向量形式（Matrix-vector form）

为什么要考虑矩阵向量形式？因为我们需要从中求解状态值（state value）！

一个未知数依赖于另一个未知数。如何解决这些未知数？
$${\color{red}v_{\pi}(s)} = \sum_a \pi(a|s)\left[\sum_r p(r|s,a)+\gamma \sum_{s'}p(s'|s,a){\color{red}v_{\pi}(s')}\right]$$

• 元素形式（Elementwise form）： 上述元素形式的方程对每个状态 $s \in S$ 都成立，如果有 $n$ 个状态就有 $n$ 个这样的方程。这意味着有这样的 $|S|$ 方程！
• 矩阵向量形式（Matrix-vector form）： 如果我们把所有方程放在一起，就会得到一组线性方程，可以简洁地写成矩阵向量形式。矩阵向量形式非常优雅，也非常重要。

1. 推导出矩阵向量形式：

回顾一下：

$$v_\pi(s) = \sum_a \pi(a|s)\left[\sum_r p(r|s,a)+\gamma \sum_{s'}p(s'|s,a)v_{\pi}(s')\right]$$
将贝尔曼方程改写为（括号外的项往括号里面分配）
$$v_\pi(s) = r_{\pi}(s)+\gamma \sum_{s'}p_{\pi}(s'|s)v_{\pi}(s')$$
其中

• $r_\pi(s)$ 代表从当前状态出发，我所能得到的即时奖励（immediate reward）的平均值
• 这个式子其实与推导贝尔曼公式的时候计算第一项和第二项的时候写的中间过程的公式是一样的，是即时奖励加未来奖励
• 从当前 $s$ 出发，有多个选择，可以跳到不同 $s'$，跳到不同 $s'$ 的概率是 $p(s'|s)$