深度强化学习总结[1]

引言

根据前面分析的对于一个函数可以用连续和非连续的函数来对其进行逼近，而上述逼近往往是用无限的函数的和来逼近，这在编程中不可实现，所以我们需要进行截断。对于连续多项式函数，截断就是取前几项，并用最小二乘法确定相关系数。例如，对于单变量的函数来说，多项式逼近函数为：
$$f(x)=a_0+a_1(x-x_0)+\cdots +a_n(x-x_0{)}^n+\cdots$$

截取前$3$项后的函数为：
$$f(x)=a_0+a_1\times (x-x_0)+a_2\times (x-x_0{)}^2$$

深度学习基础

这里的逻辑斯蒂回归只能算是最低水平上的逻辑斯蒂分类函数，因为她本质上还是一个线性函数用于分类，而不是一个窗口函数。根据我对阶跃函数逼近任意函数的理论分析，采用这种形式：$ϵ(\omega x+b)$能够大大减轻参数估计量，不用以无穷多项相加的形式描述原函数，直观且易理解。所以大部分都是采用这种边界曲线形成的阶跃函数来逼近的。
参考链接：

• 阶跃函数类总结

马尔可夫决策过程

策略函数是随机策略函数，因为基于当前状态采取何种动作是具有随机性的。同时状态转移函数也是随机的，基于同样的状态和动作，也会有不同的状态转移函数。

动作价值函数

马尔可夫决策过程中的动作价值函数就是在当前状态和采取的动作都已经确定的情况下收到的回报。
我们知道，对于任意状态$S_t$和动作$A_t$，所产生的奖励为：$R_t$，奖励的期望就是：
$$E(R_t)={\int }_{(S_t,A_t)\in \Omega }{R}_t\times P(S_t,A_t)d(S_t,A_t)$$

而在当前时刻的状态和动作与之前时刻的状态和动作有关也就是：
$$(S_t,A_t)\sim (S_{t-1},A_{t-1})$$

所以：
$$P(S_t,A_t)=P(S_t,A_t|s_{t-1},a_{t-1})$$

所以对于已知$t$时刻的状态$s_t$和采取的动作$a_t$的情况下，下一时刻的奖励$R_{t+1}$是具有随机性的，而他的均值就是：
$$\begin{array}{rl}E(R_{t+1})& ={\int }_{(S_{t+1},A_{t+1})\in \Omega }^{}{R}_{t+1}P(S_{t+1},A_{t+1}|s_t,a_t)d(S_{t+1},A_{t+1})\\ & =\sum _{S_{t+1}}\sum _{A_{t+1}}{R}_{t+1}(S_{t+1},A_{t+1})P(S_{t+1}|S_t,A_t)P(A_{t+1}|S_{t+1})\end{array}$$

$$\begin{array}{rl}E(R_{t+2})& ={\int }_{(S_{t+2},A_{t+2})\in \Omega }{\int }_{(S_{t+1},A_{t+1})\in \Omega }{R}_{t+2}P(S_{t+2},A_{t+2},S_{t+1},A_{t+1}|s_t,a_t)d(S_{t+1},A_{t+1})d(S_{t+2},A_{t+2})\\ & ={\int }_{(S_{t+2},A_{t+2})\in \Omega }{R}_{t+2}P(S_{t+2},A_{t+2}|s_t,a_t)d(S_{t+2},A_{t+2})\\ & =\sum _{S_{t+1}}\sum _{A_{t+1}}\sum _{S_{t+2}}\sum _{A_{t+2}}{R}_{t+2}(S_{t+2},A_{t+2})P(S_{t+1}|s_t,a_t)P(A_{t+1}|S_{t+1})P(S_{t+2}|S_{t+1},A_{t+1})P(A_{t+2}|S_{t+2})\end{array}$$

之前一直的困惑就是：$P(S_{t+2},A_{t+2},S_{t+1},A_{t+1}|s_t,a_t)$怎么化为乘积的形式。所以上面的中间一步应该是错误的。即：
$$!={\int }_{(S_{t+2},A_{t+2})\in \Omega }{R}_{t+2}P(S_{t+2},A_{t+2}|s_t,a_t)d(S_{t+2},A_{t+2})$$

或者说这个表达式的意义是：
$$P(S_{t+2},A_{t+2}|s_t,a_t)=\sum _{S_{t+1}}\sum _{A_{t+1}}P(S_{t+1}|s_t,a_t)P(A_{t+1}|S_{t+1})P(S_{t+2}|S_{t+1},A_{t+1})P(A_{t+2}|S_{t+2})$$

这个表达式显然不能把$S_{t+1},A_{t+1}$消去，或者说不等于：$P(S_{t+2}|s_t,a_t)P(A_{t+2}|S_{t+2})$
更远的也是如此：
$$E(R_{t+n})={\int }_{(S_{t+n},A_{t+n})\in \Omega }^{}{R}_{t+n}P(S_{t+n},A_{t+n}|s_t,a_t)d(S_{t+n},A_{t+n})$$

也就是条件概率中的条件只能是已知的内容，然后求出对应的均值。所以对于$U(t)$整个回报进行求均值就是：
$$\begin{array}{rl}E(U_t|S_t=s_t,A_t=a_t)& =E(R_t+\gamma R_{t+1}+\cdots +{\gamma }^n{R}_{t+n}|S_t=s_t,A_t=a_t)\\ & =E(R_t|S_t=s_t,A_t=a_t)+E(\gamma R_{t+1}|S_t=s_t,A_t=a_t)\\ & +E({\gamma }^n{R}_{t+n}|S_t=s_t,A_t=a_t)\\ & =r_t+\gamma {\int }_{(S_{t+1},A_{t+1})\in \Omega }^{}{R}_{t+1}P(S_{t+1},A_{t+1}|s_t,a_t)d(S_{t+1},A_{t+1})\\ & +{\gamma }^2{\int }_{(S_{t+2},A_{t+2})\in \Omega }{\int }_{(S_{t+1},A_{t+1})\in \Omega }{R}_{t+2}P(S_{t+2},A_{t+2},S_{t+1},A_{t+1}|s_t,a_t)d(S_{t+1},A_{t+1})d(S_{t+2},A_{t+2})\\ & +\cdots +{\gamma }^n{\int }_{(S_{t+n},A_{t+n})\in \Omega }\cdots {\int }_{(S_{t+1},A_{t+1})\in \Omega }{R}_{t+n}P(S_{t+n},A_{t+n},\cdots ,S_{t+1},A_{t+1}|s_t,a_t)d(S_{t+1},A_{t+1})\cdots d(S_{t+n},A_{t+n})\\ & =r_t+{\int }_{(S_{t+n},A_{t+n})\in \Omega }\cdots {\int }_{(S_{t+1},A_{t+1})\in \Omega }(\gamma R_{t+1}+\cdots +{\gamma }^n{R}_{t+n})P(S_{t+n},A_{t+n},\cdots ,S_{t+1},A_{t+1}|s_t,a_t)d(S_{t+1},A_{t+1})\cdots d(S_{t+n},A_{t+n})\end{array}$$

也就是说求回报的期望就是在当前状态和动作的联合条件概率分布下求期望。注意上面的公式中忘记写了：$R_{t+1}=R_{t+1}(S_{t+1},A_{t+1})$也就是对应的是对应状态和动作的函数。上面这个分析垃圾就垃圾在概率表达式不清楚，从状态动作轨迹出发分析概率回报就很清晰。

动作价值函数推导

从图中我们可以看出以下一些关系式：
$$R_t=R(S_t,A_t)$$

$$A_t\sim P(A_t|S_t)$$

$$S_{t+1}\sim P(S_{t+1}|S_t,A_t)$$

$$U_t=R_t+\gamma R_{t+1}+\cdots +{\gamma }^n{R}_{t+n}$$

所以当我们给定起始时刻$t$的状态$s_t$和动作$a_t$之后他随后的状态和动作序列是不确定的，可以表示为如下形式：
$$s_t,a_t,S_{t+1}\sim P(S_{t+1}|S_t,A_t),R(S_t,A_t),A_{t+1}\sim P(A_{t+1}|S_{t+1}),\cdots ,S_{t+n}\sim P(S_{t+n}|S_{t+n-1},A_{t+n-1}),R(S_{t+n-1},A_{t+n-1}),A_{t+n}\sim P(A_{t+n}|S_{t+n}),R(S_{t+n},A_{t+n})$$
所以对于一个特定的序列：
$$s_t,a_t,r_t,s_{t+1},a_{t+1},r_{t+1},\cdots ,s_{t+n},a_{t+n},r_{t+n}$$

这个序列产生的概率为：
$$P(s_{t+1}|s_t,a_t)\times P(a_{t+1}|s_{t+1})\times P(s_{t+2}|s_{t+1},a_{t+1})\times P(a_{t+2}|s_{t+2})\times \cdots \times P(s_{t+n}|s_{t+n-1},a_{t+n-1})\times P(a_{t+n}|s_{t+n})$$

这个序列对应的回报为：
$$U(t)=r(s_t,a_t)+{\gamma }^{1}r(s_{t+1},a_{t+1})+\cdots +{\gamma }^{n}r(s_{t+n},a_{t+n})$$

然后对所有可能的排列进行求加权平均也就是期望：
$$\sum _{s_{t+1}}\sum _{a_{t+1}}\sum _{s_{t+2}}\sum _{a_{t+2}}\cdots \sum _{s_{t+n}}\sum _{a_{t+n}}[r(s_t,a_t)+{\gamma }^{1}r(s_{t+1},a_{t+1})+\cdots +{\gamma }^{n}r(s_{t+n},a_{t+n})][P(s_{t+1}|s_t,a_t)\times P(a_{t+1}|s_{t+1})\times P(s_{t+2}|s_{t+1},a_{t+1})\times P(a_{t+2}|s_{t+2})\times \cdots \times P(s_{t+n}|s_{t+n-1},a_{t+n-1})\times P(a_{t+n}|s_{t+n})]$$

要判定上式是不是回报的期望就要看上面有没有考虑到所有的可能的回报函数以及对应的概率，首先就是单个动作变化的情况下的回报与概率，假定是$a_{t+1}$，那么对应的序列变为了：
$$s_t,a_t,r(s_t,a_t),s_{t+1},a_{t+1}^{\ast },r(s_{t+1},a_{t+1}^{\ast }),s_{t+2},a_{t+2},\cdots ,s_{t+n},a_{t+n},r(s_{t+n},a_{t+n})$$

这个序列产生的概率为：
$$P(s_{t+1}|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1})\times P(s_{t+2}|s_{t+1},a_{t+1}^{\ast })\times P(a_{t+2}|s_{t+2})\times \cdots \times P(s_{t+n}|s_{t+n-1},a_{t+n-1})\times P(a_{t+n}|s_{t+n})$$

相比于原始的来看，改变一个动作会导致两个乘子发生改变，一个是状态动作函数也就是策略函数$P(a_{t+1}^{\ast }|s_{t+1})$，另一个就是状态转移函数也会发生改变$P(s_{t+2}|s_{t+1},a_{t+1}^{\ast })$。
回报函数变为了：
$$U(t)=r(s_t,a_t)+\gamma r(s_{t+1},a_{t+1}^{\ast })+\cdots +{\gamma }^{n}r(s_{t+n},a_{t+n})$$

回报函数中只有一个项变化了，而对应个概率中有两个因子都变化了。因此这个回报期望中至少有这两项：
$$[r(s_t,a_t)+\gamma r(s_{t+1},a_{t+1}^{\ast })+\cdots +{\gamma }^{n}r(s_{t+n},a_{t+n})]\times [P(s_{t+1}|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1})\times P(s_{t+2}|s_{t+1},a_{t+1}^{\ast })\times P(a_{t+2}|s_{t+2})\times \cdots \times P(s_{t+n}|s_{t+n-1},a_{t+n-1})\times P(a_{t+n}|s_{t+n})]+[r(s_t,a_t)+{\gamma }^{1}r(s_{t+1},a_{t+1})+\cdots +{\gamma }^{n}r(s_{t+n},a_{t+n})]\times [P(s_{t+1}|s_t,a_t)\times P(a_{t+1}|s_{t+1})\times P(s_{t+2}|s_{t+1},a_{t+1})\times P(a_{t+2}|s_{t+2})\times \cdots \times P(s_{t+n}|s_{t+n-1},a_{t+n-1})\times P(a_{t+n}|s_{t+n})]$$

而我们在均值的表达式中可以找到这一项。同时对于动作空间内的所有的$a_{t+1}$都有这个表达式，均值也必定包含所有的$a_{t+1}$的情况，也就是
$$\sum _{a_{t+1}^{\ast }}[r(s_t,a_t)+\gamma r(s_{t+1},a_{t+1}^{\ast })+\cdots +{\gamma }^{n}r(s_{t+n},a_{t+n})]\times [P(s_{t+1}|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1})\times P(s_{t+2}|s_{t+1},a_{t+1}^{\ast })\times P(a_{t+2}|s_{t+2})\times \cdots \times P(s_{t+n}|s_{t+n-1},a_{t+n-1})\times P(a_{t+n}|s_{t+n})]$$

对于其他位置处的动作发生变化也是类似的表达式：
$$\sum _{a_{t+k}^{\ast }}[r(s_t,a_t)+\cdots +{\gamma }^{k}r(s_{t+k},a_{t+k})+\cdots +{\gamma }^{n}r(s_{t+n},a_{t+n})]\times [P(s_{t+1}|s_t,a_t)\times P(a_{t+1}|s_{t+1})\times P(s_{t+2}|s_{t+1},a_{t+1})\times P(a_{t+2}|s_{t+2})\times \cdots P(a_{t+k}^{\ast }|s_{t+k})\times P(s_{t+k+1}|s_{t+k},a_{t+k}^{\ast })\cdots \times P(s_{t+n}|s_{t+n-1},a_{t+n-1})\times P(a_{t+n}|s_{t+n})]$$

接下来对于状态发生变化进行分析。假设中间某个位置状态发生变化，轨迹序列变为：
$$s_t,a_t,r(s_t,a_t),s_{t+1}^{\ast },a_{t+1},r(s_{t+1}^{\ast },a_{t+1}),\cdots ,s_{t+n},a_{t+n},r(s_{t+n},a_{t+n})$$

此时回报函数为：
$$U(t)=r(s_t,a_t)+\gamma r(s_{t+1}^{\ast },a_{t+1})+\cdots +{\gamma }^{n}r(s_{t+n},a_{t+n})$$

对应的概率为：
$$P(s_{t+1}^{\ast }|s_t,a_t)\times P(a_{t+1}|s_{t+1}^{\ast })\times P(s_{t+2}|s_{t+1}^{\ast },a_{t+1})\times \cdots \times P(a_{t+n}|s_{t+n})$$

可以看出状态发生改变会影响三个因子，这与之前的分析图也是一致的，也就是状态会影响动作，会影响下一个状态，也会影响收到的奖励。而动作只会影响两个，影响收到的奖励与下一个状态。所以对应的概率上来说，生成动作的概率和生成下一个状态的概率以及由先前的状态生成当前状态的概率都会发生改变。而动作的改变只会带来状态到动作的概率和状态动作到下一个状态的概率的改变。
当状态和动作同时发生改变：
$$s_t,a_t,r(s_t,a_t),s_{t+1}^{\ast },a_{t+1}^{\ast },r(s_{t+1}^{\ast },a_{t+1}^{\ast }),s_{t+2},a_{t+2},r(s_{t+2},a_{t+2}),\cdots ,r(s_{t+n},a_{t+n})$$

回报为：
$$U(t)=r(s_t,a_t)+\gamma r(s_{t+1}^{\ast },a_{t+1}^{\ast })+\cdots +{\gamma }^{n}r(s_{t+n},a_{t+n})$$

对应的概率为：
$$P(s_{t+1}^{\ast }|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1}^{\ast })\times P(s_{t+2}|s_{t+1}^{\ast },a_{t+1}^{\ast })\times P(a_{t+2}|s_{t+2})\times \cdots \times P(a_{t+n}|s_{t+n})$$

可以看出在概率的乘积因子的变化上与状态发生变化时类似。当所有的都是变化的时：
$$s_t,a_t,r(s_t,a_t),s_{t+1}^{\ast },a_{t+1}^{\ast },r(s_{t+1}^{\ast },a_{t+1}^{\ast }),\cdots ,s_{t+n}^{\ast },a_{t+n}^{\ast },r(s_{t+n}^{\ast },a_{t+n}^{\ast })$$

回报函数为：
$$U(t)=r(s_t,a_t)+\gamma r(s_{t+1}^{\ast },a_{t+1}^{\ast })+\cdots +{\gamma }^{n}r(s_{t+n}^{\ast },a_{t+n}^{\ast })$$

对应的概率为：
$$P(s_{t+1}^{\ast }|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1}^{\ast })\times P(s_{t+2}^{\ast }|s_{t+1}^{\ast },a_{t+1}^{\ast })\times P(a_{t+2}^{\ast }|s_{t+2}^{\ast })\times \cdots \times P(a_{t+n}^{\ast }|s_{t+n}^{\ast })$$

所以对应的期望就是所有的$s$与$a$对应的回报与对应的概率乘积的和：
$$\sum _{s_{t+1}^{\ast }}\cdots \sum _{s_{t+n}^{\ast }}\cdots \sum _{a_{t+1}^{\ast }}\cdots \sum _{a_{t+n}^{\ast }}[r(s_t,a_t)+\gamma r(s_{t+1}^{\ast },a_{t+1}^{\ast })+\cdots +{\gamma }^{n}r(s_{t+n}^{\ast },a_{t+n}^{\ast })]\times [P(s_{t+1}^{\ast }|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1}^{\ast })\times P(s_{t+2}^{\ast }|s_{t+1}^{\ast },a_{t+1}^{\ast })\times P(a_{t+2}^{\ast }|s_{t+2}^{\ast })\times \cdots \times P(a_{t+n}^{\ast }|s_{t+n}^{\ast })]$$

其实也可以正向分析，已知轨迹序列包括状态和动作序列，而经过分析容易发现存在仅有一个动作发生变化而其他不变的情况，同样也存在仅有一个状态发生变化其他不变的情况，也就是每个位置处的状态和动作都是可以任意变化的。所以序列的总数量为：${\sum }_{s_{t+1}^{\ast }}\cdots {\sum }_{s_{t+n}^{\ast }}\cdots {\sum }_{a_{t+1}^{\ast }}\cdots {\sum }_{a_{t+n}^{\ast }}$，中间是乘积的形式。所以期望就是所有的回报与对应的概率成绩的和，也就是前面所给的形式。而上面的公式：
$$\sum _{s_{t+1}^{\ast }}\cdots \sum _{s_{t+n}^{\ast }}\cdots \sum _{a_{t+1}^{\ast }}\cdots \sum _{a_{t+n}^{\ast }}[r(s_t,a_t)+\gamma r(s_{t+1}^{\ast },a_{t+1}^{\ast })+\cdots +{\gamma }^{n}r(s_{t+n}^{\ast },a_{t+n}^{\ast })]\times [P(s_{t+1}^{\ast }|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1}^{\ast })\times P(s_{t+2}^{\ast }|s_{t+1}^{\ast },a_{t+1}^{\ast })\times P(a_{t+2}^{\ast }|s_{t+2}^{\ast })\times \cdots \times P(a_{t+n}^{\ast }|s_{t+n}^{\ast })]$$

还可以进行变化，将奖励函数带入并分别求积分：
$$E[U(t)]=r(s_t,a_t)+\sum _{s_{t+1}^{\ast }}\sum _{a_{t+1}^{\ast }}\gamma r(s_{t+1}^{\ast },a_{t+1}^{\ast })\times P(s_{t+1}^{\ast }|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1}^{\ast })+\sum _{s_{t+1}^{\ast }}\sum _{s_{t+2}^{\ast }}\sum _{a_{t+1}^{\ast }}\sum _{a_{t+2}^{\ast }}{\gamma }^{2}r(s_{t+2}^{\ast },a_{t+2}^{\ast })P(s_{t+1}^{\ast }|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1}^{\ast })\times P(s_{t+2}^{\ast }|s_{t+1}^{\ast },a_{t+1}^{\ast })\times P(a_{t+2}^{\ast }|s_{t+2}^{\ast })+\cdots +\sum _{s_{t+1}^{\ast }}\cdots \sum _{s_{t+n}^{\ast }}\cdots \sum _{a_{t+1}^{\ast }}\cdots \sum _{a_{t+n}^{\ast }}{\gamma }^{n}r(s_{t+n}^{\ast },a_{t+n}^{\ast })\times [P(s_{t+1}^{\ast }|s_t,a_t)\times P(a_{t+1}^{\ast }|s_{t+1}^{\ast })\times P(s_{t+2}^{\ast }|s_{t+1}^{\ast },a_{t+1}^{\ast })\times P(a_{t+2}^{\ast }|s_{t+2}^{\ast })\times \cdots \times P(a_{t+n}^{\ast }|s_{t+n}^{\ast })]$$

我们可以把它写为递推形式：
$$E[U(t+1)]=r(s_{t+1},a_{t+1})+\sum _{s_{t+2}^{\ast }}\cdots \sum _{s_{t+n}^{\ast }}\sum _{a_{t+1}^{\ast }}\cdots \sum _{a_{t+n}^{\ast }}[\gamma r(s_{t+2}^{\ast },a_{t+2}^{\ast })+\cdots +{\gamma }^{n}r(s_{t+n}^{\ast },a_{t+n}^{\ast })]\times [P(s_{t+2}^{\ast }|s_{t+1},a_{t+1})\times P(a_{t+2}^{\ast }|s_{t+2}^{\ast })\times \cdots \times P(a_{t+n}^{\ast }|s_{t+n}^{\ast })]$$

所以有递推形式：
$$E[U(t)]=r(s_t,a_t)+\sum _{s_{t+1}}\sum _{a_{t+1}}\gamma E[U(t+1)]\times P(s_{t+1}|s_t,a_t)\times P(a_{t+1}|s_{t+1})$$

当我们的策略函数也就是状态到动作的函数能够使得$E[U(t)]$最大化，那么势必有${\sum }_{s_{t+1}^{\ast }}{\sum }_{a_{t+1}^{\ast }}\gamma E[U(t+1)]\times P(s_{t+1}|s_t,a_t)\times P(a_{t+1}|s_{t+1})$最大化，也就是有${\sum }_{s_{t+1}^{\ast }}{\sum }_{a_{t+1}^{\ast }}E[U(t+1)]\times P(s_{t+1}|s_t,a_t)\times P(a_{t+1}|s_{t+1})$最大化。以上就是贝尔曼方程的分解。如果再把状态价值函数引进来，可以得到贝尔曼方程其他形式。

状态价值函数

接下来是状态确定但是动作不确定情况下的回报函数。
假设状态动作轨迹为：
$$s_t,a_t^{\ast },s_{t+1}^{\ast },\cdots ,s_{t+n}^{\ast },a_{t+n}^{\ast }$$

同样单独的动作变化是允许的，就是某个动作变化但其它不变，也就是每个位置都是独立的变化量。所以均值为：
$$E=\sum _{a_t^{\ast }}\sum _{s_{t+1}^{\ast }}\sum _{a_{t+1}^{\ast }}\cdots \sum _{a_{t+n}^{\ast }}[r(s_t,a_t^{\ast })+\gamma r(s_{t+1}^{\ast },a_{t+1}^{\ast })+\cdots +{\gamma }^{n}r(s_{t+n}^{\ast },s_{t+n}^{\ast })]P(a_t^{\ast }|s_t)P(s_{t+1}^{\ast }|s_t,a_t^{\ast })\cdots P(a_{t+n}^{\ast }|s_{t+n}^{\ast })$$

$$E=\sum _{a_t^{\ast }}r(s_t,a_t^{\ast })P(a_t^{\ast }|s_t)+\sum _{a_t^{\ast }}\sum _{s_{t+1}^{\ast }}\sum _{a_{t+1}^{\ast }}\gamma r(s_{t+1}^{\ast },a_{t+1}^{\ast })P(a_t^{\ast }|s_t)P(s_{t+1}^{\ast }|s_t,a_t^{\ast })P(a_{t+1}^{\ast }|s_{t+1}^{\ast })+\cdots +\sum _{a_t^{\ast }}\cdots \sum _{a_{t+n}^{\ast }}{\gamma }^{n}r(s_{t+n}^{\ast },a_{t+n}^{\ast })P(a_t^{\ast }|s_t)\cdots P(a_{t+n}^{\ast }|s_{t+n}^{\ast })$$

排除策略的影响就是把以期望最大的那个策略作为最有概率。
我们可以分析一下有多少参数需估计，假设状态数量为$n$，动作数量为$m$，所以状态到动作一共有$nm$个参数，而状态动作到状态一共有：$n^{2}m$个参数，同时状态动作到奖励一共有$nm$个参数，所以一共需要估计$(2n+n^2)m$个参数就可以计算出任意的的采样动作价值函数。要想最大化期望动作价值函数书中是说是通过修改状态动作函数来实现的，也就是通过调整$nm$个参数来实现的，所以其他的参数都可以看作是固定的。不过如果是固定的话，这个最优$nm$个参数就是确定的了，同时对于不同的选定参数，比如不同的状态动作到状态的转移参数以及状态动作到奖励的参数，都会有不同的最优的状态动作参数。
如果优化的目标是最优的动作价值函数那就是价值函数估计，也可以直接估计状态动作参数，也就是策略函数估计。
这背后的原因是因为状态加动作所产生的状态往往是由系统本身确定的，我们唯一可以设置的就是状态动作策略函数以及状态动作的奖励函数。然后用分析应用于下述内容。

仿真实验环境测试

import gym
if __name__=='__main__':
    env=gym.make('CartPole-v1',render_mode='human')
    state=env.reset()
    for t in range(10000000):
        env.render()
        action=env.action_space.sample()
        state,reward,done,info,_ = env.step(action)
        if done:
            print('finished')
            break
    env.close()

运行结果为可视化结果：

想保存为.gif文件。此时render_mode不能用human而应该用rgb_array。具体代码如下：

import gym
import matplotlib.pyplot as plt 
from matplotlib import animation
def display_frames_as_gif(frames):
    patch = plt.imshow(frames[0])
    plt.axis('off')
    def animate(i):
        patch.set_data(frames[i])

    anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=5)
    anim.save('./breakout_result.gif', writer='pillow', fps=30)

if __name__=='__main__':
    env=gym.make('CartPole-v1',render_mode='rgb_array')
    state=env.reset()
    frames=[]
    for t in range(10000000):
        frames.append(env.render())
        action=env.action_space.sample()
        state,reward,done,info,_ = env.step(action)
        if done:
            print('finished')
            break
    env.close()
    display_frames_as_gif(frames)

运行结果：

看个不停转的：

import gym
import matplotlib.pyplot as plt 
from matplotlib import animation
def display_frames_as_gif(frames):
    patch = plt.imshow(frames[0])
    plt.axis('off')
    def animate(i):
        patch.set_data(frames[i])

    anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=5)
    anim.save('./breakout_result.gif', writer='pillow', fps=30)

if __name__=='__main__':
    env=gym.make('CartPole-v1',render_mode='rgb_array')
    state=env.reset()
    frames=[]
    for t in range(100):
        frames.append(env.render())
        action=env.action_space.sample()
        state,reward,done,info,_ = env.step(action)
    env.close()
    display_frames_as_gif(frames)

运行结果为：

参考链接：

• 强化学习环境OpenAI Gym的运行、显示，以及保存成gif的ice_bear221评论!!!
• python动态图的绘制和保存

对倒立摆环境进行分析

倒立摆环境中涉及的变量如下所示：

包括离散的控制变量，观测变量。
控制变量就是控制板子向左向右移动，规定：左：$0$；右：$1$

而观测变量就倒立摆的状态变量，按照在向量中顺序依次为位置，速度，角度，角速度：

经过实验及观察，可以发现：对于角度：右倾为正。对于位置：向右为正。对于速度：向右为正。
我们要确定的就是策略：对于一个状态给出对应的动作。使得回报函数最大或者动作状态概率最大。
我们先使用经典的PID控制来试一下。在这里强调一下之前参考文章选的不对，状态变量理解错了，就是各个位置对应的状态不正确，导致我写出来的PID控制函数跟屎一样，运行顶多400步就错了，后来看了官方文档，随便挑的参数能运行3389步。
假设说我们希望角度保持为$0$。那么就有$error=\theta$，$\frac{derror}{dt}=\frac{d\theta }{dt}$，为了使用$pid$控制，需要再找到$error$的积分。也就是${\int }_0^t\theta dt$，离散化以后就是：${\sum }_{n=0}^T\theta (n\Delta t)\ast \Delta t$。在实验中每次迭代进行得很快，所以我设置积分的$\Delta t=0.001$，然后通过分析角度，角速度，角度的积分与板子移动方向之间的关系，我写出了以下代码。其中只考虑了角度和角速度两个状态变量。由于没有考虑板子的位置，所以这个实验最后的失败一定是由于达到了界限位置，也就是$x$坐标达到了边界。

import gym
import matplotlib.pyplot as plt 
from matplotlib import animation
import time
def display_frames_as_gif(frames):
    patch = plt.imshow(frames[0])
    plt.axis('off')
    def animate(i):
        patch.set_data(frames[i])

    anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=5)
    anim.save('./breakout_result.gif', writer='pillow', fps=30)

if __name__=='__main__':
    env=gym.make('CartPole-v1',render_mode='rgb_array')
    state=env.reset()
    frames=[]
    state,_=state
    sum=0
    for t in range(10000):
        frames.append(env.render())
        #pid control
        sum=sum+0.001*state[2]
        if 10*state[2]+1*sum+5*state[3]>0:
            action=1
        else:
            action=0
        #action=env.action_space.sample()
        state,reward,done,info,_ = env.step(action)
        if done:
            print('finished')
            print(t)
            break
    env.close()
    display_frames_as_gif(frames)

运行结果：

做都做到这一步了，不把位置也PID控进去真让人膈应，所以把位置也PID进去，关键是分析位置的影响，位置主要是控制在$0$，所以位置大于$0$的话往左。也就是：$x>0\to action=0$。不过参数调整是个问题，需要调整参数才有好的表现。

import gym
import matplotlib.pyplot as plt 
from matplotlib import animation
import time
def display_frames_as_gif(frames):
    patch = plt.imshow(frames[0])
    plt.axis('off')
    def animate(i):
        patch.set_data(frames[i])

    anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=5)
    anim.save('./breakout_result.gif', writer='pillow', fps=30)

if __name__=='__main__':
    env=gym.make('CartPole-v1',render_mode='rgb_array')
    state=env.reset()
    frames=[]
    state,_=state
    sum1=0
    sum=0
    for t in range(10000):
        frames.append(env.render())
        #pid control
        sum1=sum1+0.001*state[2]
        sum=sum+0.001*state[0]
        if 10*(10*state[2]+1*sum1+5*state[3])-1*(10*state[0]+1*sum+4*state[1])>0:
            action=1
        else:
            action=0
        #action=env.action_space.sample()
        state,reward,done,info,_ = env.step(action)
        if done:
            print('finished')
            print(f'总迭代步数为：{t}')
            break
    env.close()
    display_frames_as_gif(frames)

上述参数是瞎调的，需要考虑数据量的数量级差异，我没考虑。而且调参数最烦人所以结果就不放了。
参考内容：

• 正确的Cart Pole环境信息：Gymnasium Documentation
• 有错误的参考文章：OpenAI Gym 经典控制环境介绍——CartPole（倒立摆）

附录1.需要安装的包

运行文中的代码需要安装一些包，安装包的命令如下所示：

#安装任意包[package]
pip install [package] -i https://pypi.tuna.tsinghua.edu.cn/simple
#安装pygame
pip install pygame -i https://pypi.tuna.tsinghua.edu.cn/simple
#安装pillow
pip install pillow -i https://pypi.tuna.tsinghua.edu.cn/simple

参考文献

• 深度强化学习（张志华，王树森）
• 机器学习总结