介绍了 $\Delta\text{-system}$ 这种特殊的集簇, 以及 $\Delta\text{-system lemma}$ 的证明.

简单介绍

如果一个集簇 $\mathscr{A}$ 满足 $\forall x,y\in \mathscr{A}(x\cap y=r)$ , $r$ 是某个确定的集合, 那么这个集簇就叫做 $\Delta\text{-system}$ , $r$ 叫做这个 $\Delta\text{-system}$ 的根.

$\Delta\text{-system lemma}$

令 $\kappa$ 是某个不可数基数, 若正则基数 $\theta>\kappa$ 且满足 $\forall \alpha<\theta(|\alpha^{<\kappa}|<\theta)$ , 那么对某个集簇 $\mathscr{A}$ 若其满足 $|\mathscr{A}|\geqslant\theta$ 并且 $\forall x\in\mathscr{A}(|x|<\kappa)$ , 那么就存在子集 $\mathscr{B}\sub\mathscr{A}$ , $|\mathscr{B}|=\theta$ 且 $\mathscr{B}$ 是 $\Delta\text{-system}$ .

证明

事实上, 我们可以假设 $|\mathscr{A}|=\theta$ , 那么根据题设有 $\bigcup{\mathscr{A}}\leqslant\theta$ . 而由于 $\mathscr{A}$ 中的元素具体是什么与这个结论成立与否没有关系, 那么我们就可以假设 $\bigcup{\mathscr{A}}\subset\theta$ . 那么我们就得知 $\forall x\in \mathscr{A}(\exist\rho<\theta, \rho\cong x)$ , 即每个 $x$ 都有其对应的序. 又由于 $\theta$ 的正则性并且 $\theta>\kappa$ , 因此存在序数 $\rho<\theta$ 使得 $|\{x\in\mathscr{A}\mid x\cong \rho\}|=\theta$ , 否则有 $\forall \rho <\theta, \sup\{x\in\mathscr{A}\mid x\cong \rho\}<\theta$ , 然而又有 $\bigcup_\rho\{x\in\mathscr{A}\mid x\cong \rho\}=\mathscr{A}$ , 这意味着 $\{\sup\{x\in\mathscr{A}\mid x\cong \rho\}\}$ 与 $\theta$ 共尾, 违背了 $\theta$ 的正则性. 那么取这样的一个序数 $\rho$ , 令 $\mathscr{A_1}=\{x\in\mathscr{A}\mid x\cong \rho\}$ , 现在我们只对 $\mathscr{A}_1$ 做研究.

从 $\forall \alpha<\theta(|\alpha^{<\kappa}|<\theta)$ 中我们可以得知, $\mathscr{A}_1$ 中的元素是 $\alpha$ 的子集的数量少于 $\theta$ , 这是因为 $(\mathscr{P}(\alpha)\cap \mathscr{A})\subset\alpha ^{<\kappa}<\theta$. 这意味着 $\bigcup \mathscr{A}_1$ 和 $\theta$ 共尾. 取 $x\in\mathscr{A}_1$ , 令 $x(\xi)$ 为 $x$ 的第 $\xi$ 个元素, 显然存在一些 $\xi$ 使得 $\{x(\xi)\mid x\in \mathscr{A}\}$ 和 $\theta$ 共尾 (由 $\theta$ 的正则性可得) . 取 $\xi_0$ 为 最小的这样的 $\xi$​ . 令

这样就有 $\alpha_0<\theta$ 且对于任意的 $x\in\mathscr{A},\eta<\xi_0$ 有 $x(\eta)<\alpha_0$ . 对 $\mu<\theta$ 做递归, 令 $x_{\mu}\in\mathscr{A}$ 满足
$$x_{\mu}(\xi_0)>\max(\alpha_0,\sup\{x_\nu(\eta)\mid \nu<\mu,\eta<\xi_0\})$$
令 $\mathscr{A}_2=\{x_{\mu}\mid \mu<\theta\}$ , 容易验证 $\forall x,y\in\mathscr{A}, x\not=y((x\cap y)\subset\alpha_0)$ , 而 $|\alpha_0^{<\kappa}|<\theta$ , $|x\cap y|<\kappa$ , 这意味着 $\alpha_0$ 的所有小于 $\kappa$ 大小的子集的数量小于 $\theta$, 也就是说存在 $r\subset\alpha_0,\mathscr{B}\subset\mathscr{A}_0$ , 使得 $\mathscr{B}$ 是一个 $\Delta\text{-system}$ 且满足 $|\mathscr{B}|=\theta, \forall x,y\in\mathscr{B}(x\cap y=r)$​ .

本文主要证明了当基数 $\kappa\geqslant\omega$ , 那么有 $\kappa \oplus \kappa=\kappa, \kappa \otimes \kappa=\kappa$​ .

简单介绍

这是一个重要的集合论定理, 无论是基数的幂 ($\alpha^\alpha$) 还是不可数集的不可数交, 都可以用这个定理导出.

定义

基数乘法和加法:

而我们又得知对任意 $\beta<\alpha$, 都有 $\beta\times\{0\}\cup\beta\times\{1\}<\alpha$ (根据基数加法的定义), 这意味着 $\sup\{\beta\times\{0\}\cup\beta\times\{1\}\mid\beta<\alpha\}\leqslant\alpha$ , 即 $\left|\sup\{\beta\times\{0\}\cup\beta\times\{1\}\mid\beta<\alpha\}\right|\leqslant\alpha$ 但是又有 $\alpha\oplus\alpha\geqslant\alpha$ , 根据势的三歧性, 则有 $\alpha\oplus\alpha=\alpha$ , 即 $|\alpha|\oplus|\alpha|=|\alpha|$ . 根据超限归纳法知命题成立.$\quad\blacksquare$​

而乘法的证明是类似的, 利用超限归纳法, 下面只证明当 $\alpha$ 是基数的情况. 根据定义, 有
$$|\alpha|\otimes|\alpha|=\alpha\otimes\alpha=\left|\sup\{\beta\times\beta\mid\beta<\alpha\}\right|$$
那么就有

$\blacksquare$​

本文主要证明了序数的唯一性, 即若序数 $O_1 \cong O_2$ , 则有 $O_1=O_2$ , $\cong$ 是同构的意思.

简单介绍

序数是指一类集合, 满足:

• 可传递性, 即其元素也是其子集.
• 通过 $\in$ 关系构成良序集.

定义

定义 $0=\{\}$ , 即 $0$ 是空集.

证明

引理 1. 对于某个序数 $O\not=0$, 一定有 $0\in O$.

证明: 任取 $x\in O$, 若 $x\not=0$ , 则取 $x'$ 为 $x\cap O$ 的最小元, 易得 $x'=0$ , 否则可取 $x''\in x'$ , 即可得出 $x''\in x\cap O$ , 与 $x'$ 为最小元矛盾.$\quad\blacksquare$

引理 2. 记 $f\colon A\to B$ 为 $O_1$ 与 $O_2$ 之间保持结构的双射, 有 $f(0)=0$.

证明: 设 $f(0)=x\in O_2$, 若 $x\not=0$, 则有 $0\in O_2$ , 这说明 $f^{-1}(0)\in0$ , 这是不可能的.$\quad\blacksquare$

引理 3. 若 $x_1\in O_1$, 且有 $\forall x\in x_1, f(x)=x$ , 则有 $f(x_1)=x_1$.

证明: 不妨设 $f(x_1)=x_2\in O_2$ , 则有 $x_2=\{f(x)\mid \forall x\in x_1\}=\{x\mid \forall x\in x_1\}=x_1$ (这很容易证明, 用反证法即可) , 即 $f(x_1)=x_1$.$\quad\blacksquare$

现在来证明整个命题:

取集合 $C=\{x\mid f(x)\not=x\}\in O_1$ , 若其不是空集, 则存在最小元 $x'$, 满足 $\forall x\in x', f(x)=x$ , 但由引理 3可得 $f(x')=x'$ , 这就产生了矛盾即 $x'\not\in C$ , 这也就说明 $C$ 为空集. $\quad\blacksquare$

由上讨论可知不仅序数是唯一的, 他们之间的同构映射也是唯一的.

题外话

证明超穷归纳法也可以用类似的证明方法.

2

7

8

根据定义有
$$f'(a)=\lim_{x\to a}\frac{(x-a)\varphi(x)}{x-a}=\varphi(a)$$

这说明至少 $\varphi(a)=0$ .同时若 $\varphi(a)=0$ , 那么带入上面的式子有
$$g'(a)=0$$

9

根据定义
$$f'(0)=\lim_{x\to0}\frac{x^\lambda\sin\frac{1}{x}}{x}=\lim_{x\to0}x^{\lambda-1}\sin\frac{1}{x}$$
我们已知当 $\lambda>0$ 时 $\lim_{x\to0}x^\lambda=0$ , $\lambda<0$ 时 $\lim_{x\to0}x^\lambda=\infty$ . 这就证明了命题.

这说明存在 ${x^*}_n\to {x_0}^-,x_{*n}\to {x_0}^-$ , 使得 $f({x^*}_n)\to\mathop{\lim\sup}_{x\to {x_0}^-}f(x), f({x_*}_n)\to\mathop{\lim\inf}_{x\to {x_0}^-}f(x)$ . 根据介值定理在 $n

3

(1)

显然的.

(2)

根据 $\sup$ 的定义, 对于任意 $\epsilon>0$ 都有 $x\in A$ 使得 $\sup A\geqslant x>\sup A-\epsilon$ , 这说明我们可以在 $A=\{f(x)\colon 0<|x-x_0|<\frac{1}{n}\}$ 中找到 $\sup A\geqslant f(x_n)>\sup A-\frac{1}{n}$ , 显然 $f(x_n)\to\lim_{\delta\to 0^+}\varphi(\delta)$ . 因此 $\lim_{\delta\to 0^+}\varphi(\delta)=\mathop{\lim\inf}_{x\to x_0}f(x)$ . $\inf$ 同理.

假设是无界的, 那么由本节前面内容可推出 $\lim_{x\to a}f(x)=\infty$ 或 $\lim_{x\to b}f(x)=\infty$ . 由一致连续的定义可推出矛盾.

2

如果是有限区间, 有
$$f(a) + g(a)=\lim_{x\to a}f(x)+\lim_{x\to a}g(x)=\lim_{x\to a}f(x)+g(x)$$
说明 $f(a)+g(a)$ 是连续的. 如果是开区间只需补充两边定义即可成为闭区间, 而由该节内容可知闭区间中的连续函数必然一致连续.

如果是无穷区间, 就不一定成立, 比如 $f(x)=g(x)=x$ .

3

补充定义, 然后和上一题有限区间情况类似.

4

由题目可得, 对于任意的 $\epsilon/4>0$ 存在 $b>0$ , 使得当 $x\geqslant b$ 时, 有 $|f(x)-f(+\infty)|<\epsilon/4$ . 由此可得当 $x_1, x_2>b$ 时, 有

5

一致连续加减一致连续还是一致连续.

6

求根公式

显然该函数单调递增, 因此可以肯定 $(0, 1)$ 中必有一根.

7

(1)

同理得
$$\lim_{x\to-\infty}x^n+\varphi(x)=-\infty$$

由零点定理可得必有一实根.

(2)

与 $(1)$ 类似, 我们有
$$\lim_{x\to\infty}x^n+\varphi(x)=+\infty$$
取 $f(x)=x^n+\varphi(x)$

因此对于存在 $A>0$ , 使得存在 $x_0$ 使得 $f(x_0)0$ , 使得 $f(x_1)=A$ . 且存在 $x_2>0$ 使得当 $|x|\geqslant x_2$ 时, 有 $f(x)>A$ . 取闭区间 $[-x_2, x_2]$ , 该闭区间是有限区间, 且函数在该闭区间连续, 因此在此区间的函数的值域必然存在下界, 且该下界必然存在于值域中, 我们称为 $f(x_{*})$ . 显然 $x_1\in[-x_2, x_2]$ , 因此我们有 $f(x_*)\leqslant f(x_1)=A$ , 这表明 $y=x_*$ 是符合题意的.

8

令函数 $g_n(x)=f(x)-f(x+\frac{1}{n})$ . 那么有 $g_n(0)=f(0)-f(\frac{1}{n})$ , $g_n(1-\frac{1}{n})=f(1-\frac{1}{n})-f(1)$ .

假设 $f(\frac{1}{n})>f(0), f(1-\frac{1}{n})>f(1)$ , 那么问题结束 (小于的情况类似, 不做讨论) . 如果不是这样, 假设 $f(\frac{1}{n})x_1$ 的存在, 与 $x_1$ 的最大性矛盾.

9

等价于 $f(x)=a$ 有至少两个解. $f(a)-a<0$ , 这说明在 $(-\infty,a)$ 与 $(a,+\infty)$ 之中各有至少一个解.

10

记 $g(x)=x+f(x)$ , 显然这导致 $g(x)$ 的值域为无理数. 而若 $g(x)$ 是连续的, 那么根据介值定理以及有理数的稠密性, 必然存在 $x_0$ 使得 $g(x_0)$ 为有理数 ($g(x)$ 不可能为常值函数), 这说明 $g(x)$ 不是连续的, 同样, $f(x)$ 也不会是连续的.

11

(1)

(2)

令 $g(x) = (1-k)x+kx-f(x)$ . 显然 $g(x)$ 递增, 且有
$$\lim_{x\to-\infty}g(x)=-\infty,\lim_{x\to+\infty}g(x)=+\infty$$

12

假设周期为 $T$ , 任取 $x_0\in\mathbb{R}$ , 显然函数在闭区间 $[x_0, x_0+T]$ 是一致连续的. 自然在其他的区间内也是一致连续的.

由于一致连续的函数加减并不影响一致连续的性质, 即只需证明 $\sin(x^2)$ 不是一致连续的即可, 这是容易证明的.

由一致连续的定义知, 对于 $\epsilon>0$ , 存在 $\delta>0$ , 使得 $|f(x)-f(x\pm\delta)|<\epsilon$ . 任取 $x_0\in (a, b)$ , 有 $|f(x)-f(b-\epsilon_0)|<\epsilon([(b-x)/\delta]+1)$ , 其中 $[]$ 是取整函数. 这意味着 $f(b-\epsilon_0)$ 有限, 即 $b$ 的左邻域有限, 自然 $f(b-)$ 存在且有限.

$f(a+)$ 同理.

(1)

等价于
$$\begin{aligned}&\lim_{x\to1}\frac{x^n-1}{x^m-1}\\=&\lim_{t\to0}\frac{(t+1)^n-1}{(t+1)^m-1}\\=&\lim_{t\to0}\frac{t^n+nt+o(t)}{t^m+mt+o(t)}\\=&\lim_{t\to0}\frac{t^{n-1}+n+o(1)}{t^{m-1}+m+o(1)}\\=&\frac{n}{m}\end{aligned}$$

(2)

令 $1+\alpha x=t^m$ 可得
$$\lim_{t\to 1}\frac{\alpha(t-1)}{t^m-1}=\frac{\alpha}{m}$$

(3)

(4)

原式等价于

3

(7)

在我手上这个版本中是 $x\to+\infty$ , 实际上应该是 $n\to+\infty$​.

等价于
$$\lim_{t\to0}x^2\frac{\cos(t)-1}{t^2}$$

由于 $\cos(t)-1\sim-\frac{1}{2}t^2$ , 结果为 $\frac{-x^2}{2}$ .

4

(1)

不能, 在 $0$ 处 $f$ 极限不存在.

(2)

4

(1)

不连续.

(2)

不一定.

5

这说明

即
$$|f(x)-f(x_0)|<\epsilon$$

易得.

6

不成立.

7

显然是连续函数.

10

显然有 $f(nx)=nf(x)$ . 其中 $n$ 为整数. 对于 $x_0$ , 我们考虑如下数列:

那么只需令 $i\to\infty$ , 我们可以得到 $n_ix_i\to x_0$ , 由连续性得 $f(x_0)=x_0f(1)$ .

(1)

由极限的加法可得.

(2)

由极限的乘法可得.

(3)

由极限的乘法可得.

(4)

只需证明

这等价于
$$\lim_{x\to x_0}\frac{\alpha}{1+\alpha}=0$$

这是显然的.

你有两个一维数组: array1, array2 . 现在需要将它们的所有元素的组合排列出 (组合成二维数组).

1

np.array(np.meshgrid(array1, array2).T.reshape(-1, 2)

求出二维数组中最大值位置

你有一个二维数组: array , 求其中最大值的二维坐标.

1

np.unravel_index(np.argmax(array), array.shape)

在 $V$ 被不断更新的情况下, 式子左边的 $V(S_t)$ 与右边的是不等价的. 因为右边的 $V(S_t)$ 是没有更新的, 而左边的 $V(S_t)$ 却是已经更新的. 因此右边得再加上 $\alpha\delta_t$ .

6.2

我们将整个走高速以及到家的过程简化成一个状态 $s_2$ , 从新办公楼到新停车场到高速的过程简化成 $s_1$ , 显然 $V(s_2)$ 与之前的是一样的, 于是我们如果采取时序差分只需一步就可以获得较准确的更新, 这样显然比蒙特卡洛整个走一遍再更新的效率要高, 且准确度是差不多的 (关键就在于 $V(s_2)$ , 即某些状态的价值仍然相当正确的) .

6.3

因为无折扣, 所以 $\gamma=1$ , 又因为在多数情况下回报 $R=0$ , 所以根据 $\text{TD}$ 方法的更新公式多数情况的价值都不会改变 (仍是 $0.5$). 而第一幕, 应该是到达了左边的终止状态, 值改变了 $-0.5\alpha$ .

6.4

不知如何回答.

但是总的来说, $\alpha$ 越小, 收敛约慢, 相同的结果也越好. 且同一参数下 (至少不是太大的参数) $\text{TD}$ 总是优于蒙特卡洛.

6.5

可能是因为 $\alpha$ 过大导致难以收敛. 应该与初始化有关.

6.6

蒙特卡洛和 $\text{TD}$ . 猜不到.

6.7

将第 5 章中 “离轨策略 $\text{MC}$ 控制算法, 用于估计 $\pi\approx\pi_*$“ 中更新公式中的 $[G-Q(S_t,A_t)]$ 改为 $[R_{t+1}+\max_aQ(S_{t+1}, a)-Q(S_t, A_t)]$ .
$$V(S_t)=R_{t+1}+\max_aV(S_{t+1})-V(S_t)$$

6.8

6.9

在有风的网格世界中向 8 个方向移动

6.10

随机强度的风

6.11

因为它的更新公式与 $\text{Sarsa}$ 的区别在于将 $Q(S', A')$ 换成了 $\max_aQ(S',a)$ . 这其实与将你当前的策略换成贪心策略是等价的. 因此事实上你其实是用了贪心策略来更新你现在的 (不一定是贪心) 的策略, 因此是 “离轨” 的.

6.12

并不.

$\text{Sarsa}$ 在 $Q$ 更新前就已经选取好了下一步动作 $A'$ . 而 $\text{Q}$ 学习在更新后才选取 $A'$ . 如果执行动作后的环境 $S'$ 仍然是先前的环境 $S$ . 那么 (下一步选取的动作) 就会产生不同.

6.13

应当随机的用其中一个 $Q$ , 如何用 $\epsilon$-贪心 策略选取一个动作 $A_{t+1}$ , 然后在更新公式中用另一个 $Q$ 来计算 $Q(S_{t+1}, A_{t+1})$ .

由和差化积可得
$$\begin{aligned}&\lim_{x\to+\infty}(\sin\sqrt{x+1}-\sin\sqrt{x-1})\\=&\lim_{x\to+\infty}2\cos \frac{\sqrt{x+1}+\sqrt{x-1}}{2}\sin\frac{\sqrt{x+1}-\sqrt{x-1}}{2}\end{aligned}$$
显然为 $0$ .

4

假设有
$$\sin\sqrt{x+k}=\sin\sqrt{x}+\epsilon_x^k$$
显然 $\lim_{x\to\infty}\epsilon_x^k=0$ , 由此可证得.

5

因此有
$$\lim_{x\to+\infty}\sin(\pi\sqrt{n^2+1})=0$$

7

原式等于
$$\lim_{n\to+\infty}n^{x-1}\left(1+\frac{1}{n}\right)^n$$
只有当 $x\in(-\infty,1]$ 时函数才有意义, 其中 $f((-\infty,1))=\{0\}$ , $f(1)=\mathrm{e}$ .

8

设函数 $f$ 在 $(x_0-r, x_0)$ ($r$ 是一个确定的正数) 上有定义. 设 $l$ 是一个给定的实数. 若对任意给定的 $\varepsilon>0$ , 存在一个 $\delta\in(0,r)$ , 使得当 $0$$|f(x)-l|<\varepsilon,$$
则称 $l$ 为 $f$ 在 $x_0$ 处的右极限, 表示成
$$l=\lim_{x\to{x_0}^-}f(x).$$

2

由定义显然.

8

即对于任意的 $\epsilon>0$ 存在 $N\in\mathbb{Z}$ 使得当 $n>N$ 时有 $|f(x_n)-A|<\epsilon$ . 由递增性可得, 任意 $x\in(x_N,x_0)$ 都有 $|f(x)-A|<\epsilon$ . 由此可证.

10

显然可以取得足够小的 $\delta>0$ , 使得有对于任意的某个 $N\in\mathbb{Z}$ 当 $n\leqslant N$ 时 $A_n$ 不包含于 $(x_0-\var,x_0+\var)$ , 因此对于 $x\in(x_0-\var,x_0+\var)$ 有 $|x-0|<\frac{1}{N}$ . 于是对于任意 $\epsilon>0$ , 只需找到 $N$ 使得 $\frac{1}{N}<\epsilon$ , 即可证明
$$\lim_{x\to x_0}f(x)=0$$
当然当 $x=0或1$ 时只有右极限与左极限 (都为 $1$) .

14

由 1.6 节可知, 原式可以等价于

其中 $\mathrm{e_n}=\mathrm{e}-\sum_{i=1}^n1/i!$ .

那么我们化简可得

在这节同样我们可以知道
$$\frac{n}{n!(n+1)}令 $n\to\infty$ 即可得最终极限为 $0$ .

15

在 $0$ 的邻域内始终存在 $x$ 使得 $g(x)=0$ .

16

与书中是类似证法.

用反证法. 若 $f$ 有两个不动点 $x_1, x_2$ , 显然这两个同样也是 $f\kern -0.2em \scriptsize\circ \normalsize \kern -0.4emf$ 的不动点.

4

(1)

无穷多个.

(2)

不妨设 $f(x)=y$ . 显然有 $f(y)=x$ .又不妨设 $x\geqslant y$ , 那么显然有 $f(y)\geqslant f(x)$ , 由递增可知 $f(x)\geqslant f(y)$ . 那么就只有 $f(x)=f(y)$ , 也就是 $f(x)=x$ . 这是唯一解.

6

有
$$f(1+1)=f(2) = 2f(1)$$
用数学归纳法, 假设对于 $n$ , $f(n)=nf(1)$ 成立, 那么有
$$f(n+1)=f(n)+f(1)=(n+1)f(1)$$
证毕.

7

因此有 $f(l)=f(0), f(-l)=f(0)$ , 自然就是常函数.

8

反证法.

若是, 则有
$$\begin{aligned}\sin (x+l)^2&=\sin x^2\\\sin (x^2+2xl+l^2)&=\sin x^2\end{aligned}$$
而
$$\sin(x^2+2k\pi)=\sin x^2$$
那么只能
$$2k\pi=2xl+l^2$$
显然不可能 ($x$ 是变量).

对于第二个函数, 则有

移项后显然不成立 (变量与定值).

9

如果有一个函数 $f$ ,一个实数 $t$ , 不妨设 $f(t)=a, f(-t)=b$ .令 $g(t)+h(t)=a. g(t)-h(t)=b$ . 很明显, $g(t),h(t)$ 有唯一解. 再令 $g(-t)=g(t),h(-t)=-h(t)$ , 很显然有 $g(-t)+h(-t)=b$ . 对于任意的 $t$ 都可以如此构造, 我们可以得到一个偶函数 $g(t)$ , 一个奇函数 $h(t)$ , 使得 $g(t)+h(t)=f(t)$ .

利用定理 2.2.2 即可.

2

将多项式方程按次数排序 (一次多项式, 两次多项式$\cdots$) , 显然, 每个次数多项式方程的解是可数的, 而多项式方程所有的次数是可数的. 根据定理 2.2.2 , 代数数是可数的.

3

按区间中间与零点的距离排序, 右边优先.

4

将 $[0, 1]$ 间所有数换成二进制小数即可.

5

显然 $x$ 无法在这个排列中找到, 因此 $\mathrm{R}$ 不可数.

6

考虑一个直线集合 $L$ .首先我们选定一条直线 $l$ , 找到另一条直线 $l'$ 使得 $l'\parallel l$ , 同时 $l'\not\in L$ .这是容易找到的, 因为与 $l$ 垂直的直线上的点是不可数的, 而 $L$ 是可数集, 那么说明与 $l$ 垂直的直线上必然存在一个点使得过该点的平行于 $l$ 的直线 $l'$ 不属于 $L$ . 从而我们可以得知, $L$ 中的其他直线最多与 $l'$ 有一个交点. 那么将这些交点也划为一个集合 $P$ (交点集) , 这个集合显然是至多可数的, 而 $l'$ 上有不可数个点, 这说明必然有点不被 $L$ 中的直线覆盖, 证毕.

用数学归纳法可以证明 $f^n(a)=a$ .

4

(1)

既然是单射, 那么就有 $|f(A)|=|A|$ ($|A|$ 指的是这个集合中的元素个数) . 而又有 $f(A)\subseteq A$ .那么只能有 $f(A)=A$ .

(2)

上面的讨论同样说明映射 $f$ 是满射. 也就是说 $f$ 是双射, 自然 $f^{-1}$ 存在.

(3)

5

先对这个集合的元素制定一个符号, 数字 $i$ 就代表第 $i$ 个元素.

那么只需令 $f$ 为
$$f(i)=n-i+1$$
即可.

(1)

等价于

由 1.6 节练习题 10 可得
$$\lim_{n\to \infty}\frac{1/n}{\ln(n)-\ln(n-1)}=\lim_{n\to\infty}\frac{1/n}{1/n+\varepsilon_n-\varepsilon_{n-1}}=1$$

(3)

等价于

(4)

等价于

因此极限为 $0$ .

2

等价于

3

等价于

4

等价于

5

显然有

但
$$\frac{\sin n-\sin(n-1)}{1}$$

却没有极限.

6

只证明有限数的情况.

同样有
$$A-\varepsilon<\frac{a_n-a_{n_0-1}}{b_n-b_{n_0-1}}因此就有

令 $\varepsilon\to0$ 即可得.

因为 $20,21$ 这两个状态下玩家会停牌, 而此时赢庄家的概率会很高, 因此价值较大. 而小于 $20$ 时, 要牌可能会导致爆牌, 因此较低.

5.2

我觉得不会. 应当都会收敛到真实值.

5.3

不会画, 懒得画.

5.4

只需修改 $\mathrm{average}$ 函数即可. 定义一个变量为 $pre\text -avg$ 储存之前的平均数, 然后定义 $\mathrm{average}$ 函数为

1
2
3

def average(G, pre-avg):
    n = len(Returns)
    return avg + (G - avg) / n

即可.

5.5

首次访问是 $10$, 每次访问是 $5.5$.

5.6

给定起始状态与起始动作 $S_t, A_t$ , 后续的状态-动作轨迹 $S_{t+1},A_{t+1},A_{t+1},\dots,S_T$ 在策略 $\pi$ 下的概率是

因此重要度采样比为

即将 $k$ 的起始向后移一位即可,

5.7

由于一开始加权重要度采样就是有偏的, 因此误差会小幅度上升.

5.8

由于这题的特殊性, 我们可以很简单的知道, 在每一幕中, 首次访问型 $s$ 状态的价值估计 (这里恰好等于回报) $G_0$ 的一半要小于每次访问型 $s$ 状态的价值估计 $G_0'$, 更准确些其实是有等式 $G_0+1=2G_0'$ . 因此就有

这只能是 $\mathbb E[{X'}^2]=\infty$ .

5.9

类似练习 5.4 .

5.10

显然有

5.11

算法只是将 $\pi(A_t\mid S_t)$ 换成了 $1$ . 事实上本来就有 $\pi(A_t\mid S_t)=1$ , 这样的特性由上一步的 “如果” 保证.

5.12

只做了第一个赛道.

同时没有判定边界, 因为一个一个手动输太麻烦了.

就是懒

赛道问题

5.13

5.14

判断是否 $0$ , 如果是, 伪代码第 13 行后面加的项中的 $G$ 乘上一个 $\gamma^{T}$ , 如果不是, 乘上 $(1-\gamma)\gamma^{T-t-1}$ .

(1)

只需找到对应的子列 $\{a_{k_n}\}$ , 然后运用极限的四则运算即可.

(2)

由 1.8 节得 $\inf_{k\geqslant n}-a_k=-\sup_{k\geqslant n}a_k$ . 因此等式显然成立.

(3)

显然第一个右边不等式也成立. 利用同样方法可以证明接下来的不等式.

(4)

同 (1).

3

依题意得存在 $N, n>N$ 时有 $a_n<(1+\epsilon)^n$ , 由此可得 $\lim_{n\to\infty}a_n/l^n=0$ . 这个关系是等价的.

由于 $(n/(n-1))^{(n-1)}<\mathrm e<3\leqslant4-1\leqslant n-1,n\geqslant4$ 因此有 $\sqrt[n]{n}<\sqrt[n-1]{n-1}$ . 然后又有 $1<\sqrt{2}=\sqrt[4]{4}<\sqrt[3]{3}$ . 所以上确界是 $\sqrt[3]{3}$ , 下确界是 $1$ .

4

根据上下确界的定义, 可以找到两个子列极限分别为上下确界, 数列自然不收敛.

5

一个有界数列 $\{a_n\}$ , 我们找出它任意一个上界 $A$ 与下界 $B$ , 取用二分法将 $[A,B]$ 分为两个区间, 显然两个区间之中至少有一个有无穷多个数列的项在其中. 不停重复这个过程, 根据闭区间套定理可得一个极限 $a$ , 由我们选取的过程可得存在子列趋近于 $a$ .

4.2

都是 $-20$ .

事实上只需要算出第一个 $-20$ 就可以了, 状态 13 与状态 15 具有相同的状态价值, 状态 13 的动态特性变化并不影响它的价值 ($\text{down}$ 都是 $-20$) .

4.3

4.4

“如果 $old\text-action\not= \pi(s)$ “ 改为 “如果 $\sum_{s',r}p(s',r\mid s,\pi(s))[r+\gamma V(s')]\not=\sum_{s',r}p(s',r\mid s,old\text-action)[r+\gamma V(s')]$“ .

4.5

1. “任意设定 $V(s)\in R$ “ 改为 “任意设定 $Q(s, a)\in R$“ .
2. “对每一个 $s\in \mathcal S$ 循环” 改为 “对每一个 $s\in\mathcal S,a\in\mathcal A$ 循环” ,
3. ‘策略评估’ 中循环的内容改为

1. ‘3. 策略改进’ 中 “$\pi(s)\leftarrow \mathop{\arg\max}_{a}\sum_{s',r}p(s',r\mid s,a)[r+\gamma V(s')]$“ 改为 “$\pi(s)\leftarrow \mathop{\arg\max}_{a}Q(s,a)$“

4.6

3: $\pi(s)$ 不能只取定值 $a$ , 要根据题目要求设定.

2: 好像没啥要改的…

1: 初始化需要多弄一个参数 $\varepsilon$ .

4.7

这训练方法效率也忒慢了… 于是我就偷懒无奈放弃了, 只写了策略评估的部分 (真的不是我懒啊喂).

杰克租车问题

4.8

首先确定一点, 在赌资为 $50$ 美元时, $q_*(50,50)=v_*(50)>v_*(s), s<50$ . 如果赌资少于 $50$ , 当达到 $50$ 时就相当于成功了一小半. 如果赌资大于 $50$ (大一点), 在输的时候最好也是输到 $50$ 美元, 好有一个退路. 因此就有了如此奇怪 (不连续) 的策略. 当然 $25$ 美元, $75$ 美元也是特殊的两个情况, 一个 ($25$ 美元) 堵上全部赌资 (赢了的话) 刚刚好达到 “成功了一小半的境地”, 一个 ($75$ 美元) 堵上 $25$ 美元赢了的话刚刚好胜利, 输了还有 $50$ 美元, 赢得概率还是很大, $25$ 美元算是次优情况, 而 $75$ 美元是更优情况 (这里的优指的是比之前的情况的优势大了很多). 因此其他情况都在考虑输和赢对这 3 种情况的靠拢.

4.9

赌徒问题

是稳定的.

4.10

是. 因为

2

(1)

不是, 简单举个反例, 调和级数.

(2)

那就是了, 对应于之前 1.5 的例二.

很显然有 $|a_{n+1}-a_n|<\frac{1}{(n+1)^2}$ , 那么 $|a_m-a_n|<\sum_{i=n+1}^m 1/i^2,(m>n)$ , 记
$$\lim_{n\to\infty}\sum_{i=1}^n\frac{1}{i^2}=L$$
那么对于任意 $\epsilon>0$ , 存在 $N\in\mathbb{Z}^*$ , 使得当 $n>N$ 时, 有
$$L-\sum_{i=1}^n\frac{1}{i^2}<\epsilon,\left(L>\sum_{i=1}^n\frac{1}{i^2}\right)$$
那么对于这样的 $\epsilon$ , 当 $m>n>N$ 时, 就有
$$|a_m-a_n|<\sum_{i=n+1}^m \frac{1}{i^2}

那么该数列显然是基本列.

3

(1)

根据第 2 题 (2) 显然成立 (它是基本列) .

(2)

记 $|a_n|$$|b_m-b_n|=\left|\sum_{i=n+1}^ma_iq^i\right|由于

那么对于任意 $\epsilon>0$ , 存在 $N\in\mathbb{Z}^*$ , 使得当 $n>N$ 时, 有
$$|b_m-b_n|<\frac{Mq^{n+1}}{1-q}<\epsilon$$

因此 $\{a_n\}$ 是基本列, 自然收敛.

(3)

由 (2) 得成立.

(4)

由 (3) 得成立.

4

用反证法. 假设不收敛, 那么就有: 存在 $\epsilon>0$ , 使得任取 $N\in\mathbb{Z}^*$ , 都存在 $m>n>N$ 使得 $|a_m-a_n|>\epsilon$ . 取

1.确定游戏

闯关小游戏 (类似森林冰火人那种) , 游戏是确定的, 即你每次都可以用同样的方式获得同种分数

动作为上下左右, 可以考虑用相同时间间隔来进行离散处理, 通关给出正收益, 被攻击, 死亡给出负收益.

2.对弈

棋类游戏, 给定对手, 那么对手的行为的概率就是可预测的, 那么环境 (棋盘) 就可预测.

3.随机游戏

比如 2048.

2

不能. 环境信息决定于智能体的感知能力, 如果感知能力不够强 (不是上帝视角) , 那么同样的环境信息就可能是不同的情况, 那么这样的任务就不是 $\text{MDP}$ 框架.

3

个人觉得是第一个层次 (即方向盘) . 首先要考虑 “动作” 操控 (实际操作) 的难度. 比如说轮胎、肌肉、思想这种层面, 即使训练好了, 如何方便之前的做出这种动作仍是一种困难. 而且要控制动作的数量. 肌肉要控制的地方太多了, 会导致训练的参数很多, 收敛慢. 而且还要便于人类理解. 人类就是操控方向盘来与环境交互的, 以方向盘层次作为训练的动作更容易理解.

4

这是我在别的地方找到的答案. 但我认为这样的答案是错误的 (或者是题目没有出得足够严谨) .

要知道 $r_{\text{search}},r_{\text{wait}}$ 在文中的定义是 “期望数量 (期望收益)” , 重点关注 “期望” , “期望” 并不能作为 $p(s',r\mid s,a)$ 中的 $r$ , 因为取得期望的概率在绝大多数的情况下不是 $1$ , 甚至是 $0$ . 这里的 $r$ 应该取 $0,1,2,3\cdots$ , 并且给出 $r$ 取 $0,1,2,3\cdots$ 的条件概率才能够做这道题. 但题目也不可能这么出, 因此我猜测出题人要的答案应该就是如此, 但是他出的这道题目并不对应这个答案 (出题不严谨) .

5

6

每次的回报都是 $-\gamma^K$ , $K$ 是每一幕失败前的步数. 区别在于持续性任务将所有失败的事件都考虑了 (失败会大于等于一次) .

7

可能没有采用折扣, 导致机器人认为只要走出迷宫即可, 不需要考虑时间的长短.

8

9

10

中学等比数列+一丢丢极限(不严谨甚至可以直接忽略极限).

11

12

13

14

15

应该是相对大小.

16

会, 因为 $v_c$ 对每个状态来说都不一样了 (距离终结状态的距离不同) . 举例懒得举.

17

18

19

20

绿色部分是 $-1$ , 洞口是 $0$ , 然后按照木杆的距离递减.

21

绿色部分是 $-1$ , 然后按照推杆的距离画一个 $-2$ 等值线, 然后以木杆的距离递减.

22

23

懒得写, 式 (3.20) 套进去就好.

24

25

26

27

28

29

最优价值函数同理.

(1)

2

显然当 $k=1$ 时成立. 假设对于 $k=i$ 成立, 那么有

因此对于 $i+1$ 同样成立, 得证.

3

利用提示.

4

利用提示.

5

易证.

6

由上一题可得.

7

右边不等式易证, 因此只证左边.

因此就有
$$\left(\frac{n+k}{n}\right)^{n+k}>\left(\frac{n+k+1}{n+1}\right)^{n+k+1}$$

因此显然.

8

积分秒解

因此
$$\ln(1+n)<\frac{1}{n}+\frac{1}{n-1}+\dots+\frac{1}{2}+\frac{1}{1} +\ln1=1+\frac{1}{2}+\dots+\frac{1}{n}$$
又由于
$$\begin{aligned}\ln(1+\frac{1}{n})&>\frac{1}{n+1}\\\ln(1+n)&>\frac{1}{n+1}+\ln(n)\end{aligned}$$

同理

9

因此 $\{x_n\}$ 有界. 由于 $\ln(n+1)+\frac{1}{n+1}-\ln(n+2)>0$ , $\{x_n\}$ 是单调递增的, 因此极限存在.

10

易证.

11

因此只需数学归纳法就可证明.

12

(怎么每次都被夹逼卡)

利用 11 题, 可得

用 1.2 节例 4 的类似方法可证明 $\lim_{n\to\infty}(n+1)^{1/n}=1$ . 那么由夹逼定则就可证明.

13

14

显然 $0<\theta_n/n<1$ , 因此 $n!\mathrm{e}-[n!\mathrm{e}]=\theta_n/n$ , 两边取极限得等于 $0$.

15

由 10 得

两边取极限得极限为 $\ln2$ ,

16

显然 $\{x_n\}$ 单调 (递增) , 且 $0

由算术几何平均不等式得

自然极限存在.

(1)

当 $n>10$ 时, 数列单调递减, 而 $x_n>0$ , 因此极限存在.

(2)

数列单调递减, $x_n>0$ , 极限存在.

2

显然该数列单调递增, 但有 $x_n<2$ (由数学归纳法得) , 因此极限存在.

3

设数列 $\{a_n\}$ 是单调递增的, 若子列 $\{a_{k_n}\}$ 收敛, 说明 $a_{k_n}

对递减数列同理.

4

已经有提示了.

易得 $a_{n+1}>a_n$ , 即 $\{a_n\}$ 是单调数列, 由题意知有界, 因此有
$$(1-\lim_{n\to\infty}a_n)\lim_{n\to\infty}a_n\geqslant\frac{1}{4}, (1-\lim_{n\to\infty}a_n)\lim_{n\to\infty}a_n\leqslant\frac{1}{4}$$
那么只有
$$\lim_{n\to\infty}a_n=\frac{1}{2}$$

5

6

易得 $x_n-x_1< \sum_{n=1}^\infty\frac{1}{n^2}$ , 而右边极限是存在的, 那么 $\{x_n\}$ 也就单调且有界, 即极限存在.

当 $x$ 足够大, 时有
$$p(x)=x^3(1-\frac{4}{x}+\frac{5}{x^2}-\frac{6}{x^x})>\frac{x^3}{2}$$
显然 $\lim_{n\to\infty}p(n)=+\infty$ .

而当 $x$ 足够小时同理.

2

显然.

3

由求和公式显然.

4

两边取极限可得.

5

两边取极限可得.

其中 $a_t$ 是最优动作

贪心:
$$\frac{1}{10}\sum_{i=1}^{10}\mathbb{E}]q_*(a_i)]$$

2.4

2.5

多臂赌博机

可以明显看出常数步长对于非平稳问题的优势.

2.6

因为其会探索得更多, 因此会更糟, 但同时由于其还拥有贪心的本质, 因此在不同臂收益差距明显时, 会出现峰值.

2.7

只需证明最后表达式与 $Q_1$ 无关即可. 展开可得
$$Q_{n+1}=Q_1\prod_{i=1}^{n}(1-\beta_i)+\sum_{i=1}^nR_i\beta_i\prod_{j=i+1}^{n}(1-\beta_j)$$
显然有 $\beta_1=1$ . 因此
$$Q_{n+1} =\sum_{i=1}^nR_i\beta_i\prod_{j=i+1}^{n}(1-\beta_j)$$
与 $Q_1$ 无关.

2.8

第 11 步恰好是 “10” 臂赌博机加一, 为什么这么恰好呢? 原因是 $\text{UBC}$ 的特点让其对于从未选择过的动作的优先度高于其他动作, 于是前 10 步恰好做过 10 钟动作, 因此对于每个动作来说 $\text{UBC}$ 特有的那一项标准差度量相等, 因此这一步完全是贪心的状态 (完全没有试探) , 因此产生一个小小的峰值. 而过了这一步, 试探的能力才会逐渐提升. 如果 $c=1$ , 也就是减少, 相当于提升了 $\text{UBC}$ 贪心的能力, 也就会更平滑, 尖峰就不会那么突出了.

2.9

$\text{softmax}$ 就是广义的 $\text{sigmoid}$ .

2.10

(1)

只选动作 1 或动作 2 , 期望是 0.5 .

(2)

最优期望是 0.55 . 当 A 时选择动作 2 , B 时选择动作 1 .

2.11

这是要我把其他算法都实现一遍的意思??

多臂赌博机2

好像有点丑.

(1)

一开始应该收敛得很慢.

(2)

应该不会, 我觉得它应该会收敛到必定不输的那个策略.

1.2 对称性

(1)

可以在更新价值表格时同时更新其对称位置.

(2)

应该会更快收敛.

(3)

不应该. 因为如果对手有偏好, 那么我们对对称的位置应该有不同的考虑.

(4)

不一定, 这与对手的策略有关.

1.3 贪心策略

(1)

如果是一开始就贪心, 当然是更差 (根本没有训练) . 如果已经收敛, 就会玩得更好.

(2)

贪心难以收敛到最优策略.

1.4 从试探中学习

我认为从试探中学习的方式应该… 不太正确. 应该来说无论是学习还是胜率考虑都是不从试探中学习的更优.

1.5 其他提升方法

(1)

不能.

(2)

直接几个 if 判断就好了.

只做部分, 且不完全做完因为我懒.

(3)

于是显然成立.

(5)

显然成立.

(9)

取 $N=[\tan( \frac{\pi}{2}-\epsilon)]+1$, 那么当 $n>N$ 时, $\arctan n>\frac{\pi}{2}-\epsilon$ , 等价于 $|\arctan n-\frac{\pi}{2}|<\epsilon$ , 因此成立.

2

狄利克雷函数.

3

令 $\lim_{n\to\infty}a_n=a$ , $a$ 显然是个整数, 如若不然, $|a_n-a|\geqslant \max{(a-[a], [a]+1-a)}$ , 数列不收敛. 当 $a$ 为整数时, 若从某项起数列的项都等于一个常数 $b$ , 由收敛的定义得显然数列收敛且 $\lim_{n\to\infty}a_n=a=b$ . 若不存在某项使得在这项之后的项都等于一个常数, 那么 $|a_n-a|\geqslant 1$ , 原数列显然不收敛.

4

(1)

不可以. 只需令这无限多个正数都大于 1 即可.

(2)

不可以, 书里明确说了, 考虑的是 “小的方面” .

(3)

可以, 理由同上.

(4)

可以, 只需令 $k>[\frac{1}{\epsilon}]+1$ 即可.

(5)

可以.对于任意的 $\epsilon'>0$ , 只需取 $\epsilon=\delta<\epsilon'$ , 并取 $N$ 使得这有限多项全在 $N$ 项之前即可.

5

6

对于任意的 $\epsilon>0$ , 存在 $N'$ 使得当 $n>N$ 时, $\frac{a_n}{n}<\epsilon$ , 那么只需找到 $N\geqslant N'$ 使得 $\max(a_1, a_2, \dots, a_N, a_{N+1})=a_{N+!}$ , 先假设可以找到这样的 $N$ , 那么当 $n>N$ 时, 假设 $a_k=\max(a_1, a_2, \dots,a_{n})$ 那么就有
$$\frac{\max(a_1, a_2, \dots,a_{n})}{n}\leqslant\frac{a_k}{k}<\epsilon$$
若无法找到这样的 $N$ , 那么说明数列在 $N$ 项之后是不单调递增的, 因此 $\max(a_1, a_2, \dots,a_{n})\leqslant\max(a_1, a_2, \dots,a_{N})=a_k, k\in\{1,2,3,\dots,N\}$ .因此只需取 $N=\left[\frac{a_k}{\epsilon}\right]+1$ 即可.

7

对 $a_n-c_n$ 做同样讨论, 最终得到
$$\exist N\in\mathbb{Z}^*,a_n-\epsilon因此
$$3a_n-2\epsilon

由于 $a_n+b_n+c_n=a+b+c$ , 因此
$$3a_n-2\epsilon等价于
$$\left|\frac{a+b+c}{3}-a_n\right|<\frac{2}{3}\epsilon<\epsilon$$
因此 $\lim_{n\to\infty}a_n=\frac{a+b+c}{3}$ . 同理得其他两个数列的极限.

用反证法. 假设 $a+b$ 是有理数, 那么有 $a+b = \frac{p}{q}$ , 令 $a=\frac{p'}{q'}$ , 那么有
$$\begin{aligned}\frac{p'}{q'} + b &= \frac{p}{q}\\b&=\frac{pq'-p'q}{qq'}\end{aligned}$$
即 $b$ 为有理数, 与题目矛盾, 因此 $a+b$ 是无理数. $a-b$ 是同理可得.

若 $ab$ 是有理数, 那么有 $ab = \frac{p_0}{q_0}$ , 因此 $b=\frac{p_0}{aq_0}$ , 即 $b$ 为有理数, 矛盾, 因此 $ab$ 是无理数. $a/b$ 同理可得.

2

这里只考虑大于零的情况 (小于等于零的情况类似, 因此为了方便不做讨论) . 假设有两个有理数 $a=\frac{p}{q}>b=\frac{p'}{q'}>0$ . 通分得 $\frac{pq'}{qq'}>\frac{p'q}{qq'}$ , 显然有 $\frac{pq'-1}{qq'}\geqslant\frac{p'q}{qq'}$ , 等价于 $\frac{kpq'-k}{qq'k}\geqslant\frac{p'qk}{qq'k}$ , 其中 $k\in\mathbb Z^*$因此 $a,b$ 两个有理数之间至少有 $\frac{kpq'}{qq'k}, \frac{kpq'-1}{qq'k},\dots,\frac{kpq'-k+1}{qq'k}$ , $k$ 个有理数, 有由于 $k$ 可以取任意大, 因此 $a,b$ 间有无限多个有理数. 而 $\frac{pq'}{qq'}>\frac{\sqrt{(pq')^2-1}}{qq'}>\frac{p'q}{qq'}$ , 由该节知 $\sqrt{(pq')^2-1}$ 是无理数, 由练习题 1 知 $\frac{\sqrt{(pq')^2-1}}{qq'}$ 是无理数, 因此两个有理数间至少有一个无理数. 由于两个有理数间有无限多个有理数, 因此两个有理数间也就有无限多个无理数.

3

用类似书里的方法, 假设 $\sqrt[3]{2} = \frac{p}{q}$ , $p$ 与 $q$ 不存在公因子, 那么 $\sqrt[3]{2}q=p$ , 等价于 $2q^3=p^3$ , 显然 $p$ 是偶数, 令 $2p'=p$ , 那么 $q^3=8p^3$ , 因此 $q$ 也是偶数, 产生矛盾, 于是 $\sqrt[3]{2}$ 是无理数.

4

平方得 $5+2\sqrt{6}$ , 显然是无理数, 假设 $\sqrt 2+\sqrt 3=\frac{p}{q}$ , 那么 $\frac{p^2}{q^2}$ 就是无理数了, 这显然不正确, 于是 $\sqrt 2+\sqrt 3$ 是无理数.

5

一开始看这道题我就估计这与 $\sqrt{2}$ 是无理数有关, 果然猜对了.

显然 $(0,0)$ 是该圆上的一个有理点. 若 $\frac{p}{q},\frac{p'}{q'}\not=0, (\frac{p}{q},\frac{p'}{q'})$ 是该圆的一个有理点, 那么有 ${\left(\frac{p}{q}\right)}^2-{\left(\frac{p'}{q'}\right)}^2 -2\sqrt{2}\frac{p}{q}=0$ , 即 $2\sqrt 2=\frac{{\left(\frac{p}{q}\right)}^2-{\left(\frac{p'}{q'}\right)}^2}{\frac{p}{q}}$ 显然是有理数 (懒得化简) , 与 $\sqrt{2}$ 是无理数矛盾, 因此不存在 $(0,0)$ 之外的有理点, 即该圆只有唯一有理点.

6

小学的竖式除法派上用场啦! 同样只考虑正数. 由于有尽小数可以看成是特殊无尽循环小数, 因此可以合并处理. 考虑 $\frac{p}{q}$ , 我们用竖式除法来做, 第 $n$ 次除得到的数 (第一个非零数开始算起) 称为 $a_n$ , 余下的数称为 $b_n$ (已经进位). 比如说 22/7 , 那么 $a_1=3, b_1=10, a_2=1, b_2=30$ .

显然对于固定的 $q$ ,那么 $a_n, b_n$ 完全由 $b_{n-1}$ 决定, 而我们又有 $b_n<10q$ .由鸽笼原理可知, 在 ${b_1, b_2,\dots, b_{10q}}$ 中必然存在两项相同, 假设这两项是 $b_i,b_j$ , $i

后一个问题更简单些, 并且其实书中已经给出了求法, 这里不过多叙述.

7

显然是无理数. 当然我们还是严谨的证明一下. 如果是有理数, 那么一定有循环节, 易知我们可以在这串数字中得到任意长度连续的 $0$ , 那么循环节只能由 $0$ 组成, 但是又不存在某位之后的所有数字都是 $0$ (必然会出现 $1$), 因此产生矛盾, 也就是说它是无理数.

8

9

与第七题是一样的证法. 易知我们可以从这串数字中得到任意长度连续的 $0$ , 于是循环节只能由 $0$ 组成, 同样也可以得到任意长度的 pl.$1$ , 于是循环节只能由 $1$ 组成, 矛盾, 于是该数为无理数.

10

(1)

若 $r,s\not=0$ , 那么令 $r=\frac{p}{q}, s=\frac{p'}{q'}$ , 易得 $\sqrt{2}=-\frac{pq'}{qp'}$ 矛盾.

(2)

若 $r,s,t\not=0$ , 那么令 , 那么有 $r^2=2s^2+3t^2+2st\sqrt{6}$ , 等价于 $\sqrt{6} = \frac{r^2-2s^2-3t^2}{2st}$ 显然是有理数, 矛盾.

11

为了方便讨论, 我们将左边的展开式的项分类, 有几个 $a$ 相乘的项就称为几次项. 当它们都大于 $0$ 时, 展开左式得
$$1+a_1+a_2+\cdots+a_n+a_1a_2+\cdots>1+a_1+a_2+\cdots+a_n$$
当它们都小于 $0$ 时, 分两种情况讨论.

当 $\sum_{i=1}^n\leqslant-1$ 时. $(1+a_1)(1+a_2)\cdots(1+a_n)>0\geqslant1+a_1+a_2+\cdots+a_n$ .

当 $\sum_{i=1}^n>-1$ 时, 展开左式得 $1+a_1+a_2+\cdots+a_n+S$ , $S$ 是余下的项的和. 现证明 $S>0$ . 显然 $2k$ 次的项的和 (正数) 要大于 $2k+1$ 次项的和 (负数) 的绝对值. 比如
$$\sum_{i就是二次项和大于三次项和的绝对值. 也就是说 $S>0$ . 因此原式成立.

有点二项式展开的味道.

12

本题 $(1),(2)$ 题可以合并, 即条件变成 $a_1,a_2,\dots a_n$ 符号相同, 且 $\left|\sum_{i=1}^na_i\right|<1$ . 由 11 题知后半部分成立, 因此我们只需证
$$\frac{1}{1-\sum_{k=1}^na_k}>\prod_{k=1}^n(1+a_k)$$
令 $a_{n+1} = 1-\sum_{k=1}^na_k$ , 那么由算数-几何平均不等式得
$$\begin{aligned}a_{n+1}\prod_{k=1}^n(1+a_k)&\leqslant1\\\prod_{k=1}^n(1+a_k)&\leqslant\frac{1}{a_{n+1}}\\\prod_{k=1}^n(1+a_k)&\leqslant\frac{1}{1-\sum_{k=1}^na_k}\end{aligned}$$
显然 $1+a_k>1>a_{n+1}$ , 等号无法取得. 因此
$$\prod_{k=1}^n(1+a_k)<\frac{1}{1-\sum_{k=1}^na_k}$$
得证.

13

用书中方法即可证明.

14

分别假设 $a\leqslant b, a>b$ 即可得. 几何意义即是, 在数轴上找到 $a,b$ 的中点, 然后向正半轴大的那个值靠拢.

15

先证明两个的情况.

假设 $\frac{a_2}{b_2}\geqslant\frac{a_1}{b_1}$ , $b_1=kb_2$ , 那么就有$\frac{a_2}{b_2}\geqslant\frac{a_1}{kb_2}$ , 即 $ka_2\geqslant a_1$ , 因此有 $\frac{a_1+a_2}{b_1+b_2}\leqslant\frac{(1+k)a_2}{(1+k)b_2}=\frac{a_2}{b_2}$ , 同理得 $\frac{a_1+a_2}{b_1+b_2}\geqslant\frac{a_1}{b_1}$ .由于对于两项成立, 那么自然对于 $n$ 项成立.

16

题目已经提示了.

当 $n=2$ 时显然成立. 假设当 $n=k$ 时成立, 那么有
$$(1+x)^k>1+kx$$
因此
$$(1+x)^{k+1}>(1+kx)(1+x)=1+(k+1)x+kx^2>1+(k+1)x$$
因此对于 $n=k+1$ 也成立, 证毕.

17

即证
$$\begin{aligned}x^m(y^n-x^n)+y^m(x^n-y^n)&\leqslant0\\(x^m-y^m)(y^n-x^n)&\leqslant0\end{aligned}$$
显然成立 (异号) .

题外话

终于搞定累死我了…

(1)

不能.

(2)

发散.

(3)

发散.

(4)

既可以收敛也可以发散.

(5)

证毕.

3

(1)

利用极限的四则运算可得出极限为 $\frac{1}{3}$.

(3)

将 $\sqrt{n+1}-\sqrt{n}$ 转换为 $\frac{1}{\sqrt{n+1}+\sqrt n}$ 即可.

(4)

这个问题我还没有解决.

题目

已知平面向量 $v_1,v_2,v_3,\cdots,v_n$ 满足 $\sum_{i=1}^n|\vec{v_i}|=1$ . 若必存在若干个向量, 它们的和的模不小于 $k$ , 求 $k$ 的最大值.

原题如下

给出的解法虽然很精彩, 但是并不是最大值 (最少是没证明 $1/4$ 是最大值) . 于是就产生了这个求最大值的想法.

猜想

我猜测结果是 $1/\pi$ .

一些结果

令 $P\subseteq \{1,2,3,\cdots,n\}$ , 且满足 $\left|\sum_{i\in P}v_i\right|$ 为所有向量相加的组合中能取到的最大值, 我们来考虑如何选取得到这个向量的集合. 设一个向量 $\vec{w}\not=\vec 0$ , 如何取向量并相加才能使得这个相加后的向量在 $\vec{w}$ 上的投影的模最大? 很显然, 取一条过原点的直线, 然后分别将直线的两边的所有向量相加 (在直线上的向量相加与否并不影响这个模的取值), 得到的两个向量必有一个在 $\vec{w}$ 上的投影的模是最大的, 但是这样取到的最大的模必然小于等于 $\left|\sum_{i\in P}v_i\right|$ (当 $\vec w$ 与 $\sum_{i\in P}v_i$ 的方向相同或相反时取等号). 于是, 向量 $\left|\sum_{i\in P}v_i\right|$ 必然是某条过原点的直线的一边的所有向量的和的模.

因此, 我们就可以利用这个结果来设计一个较低复杂度 $O(n)$ 的程序, 来使我的猜想更加可信.

代码验证

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

import numpy as np
rand = lambda num, t: np.random.rand(num, t) - 0.5
sin = np.sin
cos = np.cos
arcsin = np.arcsin
arccos = np.arccos
sqrt = np.sqrt
pi = np.pi

def angle(x0, y0):
    x = x0 / sqrt(x0**2 + y0**2)
    y = y0 / sqrt(x0**2 + y0**2)
    efactor = 0.01
    if y > 0:
        theta = arcsin(y)
        if cos(theta) - x < efactor:
            return theta
        else:
            return pi - theta
    else:
        theta = arcsin(y) + 2*pi
        if cos(theta) - x < efactor:
            return theta
        else:
            return 3*pi - theta
        
def angle(x0, y0):
    x = x0 / sqrt(x0**2 + y0**2)
    y = y0 / sqrt(x0**2 + y0**2)
    efactor = 0.01
    if y > 0:
        theta = arcsin(y)
        if cos(theta) - x < efactor:
            return theta
        else:
            return pi - theta
    else:
        theta = arcsin(y) + 2*pi
        if cos(theta) - x < efactor:
            return theta
        else:
            return 3*pi - theta
def rand_vec(num):
    res = []
    for x, y in rand(num, 2):
        res.append(Vector(x, y))
    return res

def init_vec(num):
    vec_arr = rand_vec(num)
    res = []
    length = 0
    for vec in vec_arr:
        length += vec.length()
    for vec in vec_arr:
        res.append(Vector(vec.x / length, vec.y / length))
    return res

def init_sum_vec_list(MAXNUM = 100):
    vec_list = init_vec(MAXNUM)
    vec_list.sort(key=(lambda vec: vec.angle))
    sum_vec = vec_list[-1]
    sum_vec_list = []
    bedex = 0
    edex = 0

    for bdex in range(MAXNUM):
        sum_vec -= vec_list[bdex - 1]
        bedex = edex
        for edex in range(bedex, bedex + MAXNUM):
            sum_vec += vec_list[edex % MAXNUM]
            if edex + 1 < MAXNUM:
                if vec_list[(edex + 1) % MAXNUM].angle - vec_list[bdex % MAXNUM].angle > pi:
                    sum_vec_list.append(sum_vec)
                    break
            else:
                if vec_list[(edex + 1) % MAXNUM].angle - vec_list[bdex % MAXNUM].angle > -pi:
                    sum_vec_list.append(sum_vec)
                    break
    return sum_vec_list

res_len = []
for i in range(100):
    res_len.append(max(init_sum_vec_list()).length())
print(min(res_len))

代码没有注释是因为优秀的代码不需要注释我太懒了. 最后结果算出来基本上都大于 0.5, 想来可能是简单的等概率随机分布并不适合生成随机向量, 以后有时间再优化一下吧.

对于一个点 $P_0(x_0,y_0)$ 来说 , $P_1(x_0\cos\theta-y_0\sin\theta,x_0\sin\theta+y_0\cos\theta)$ 是 $P_0$ 旋转 $\theta$ 角度 (顺时针) 后对应的点. 这个公式的推导是很简单的, 但是它这样的形式似乎并没有什么显而易见的规律. 但是, 复数乘法可以给我们一些启示.

复数乘法的几何意义

设 $z_1=a_1+b_1\mathrm{i}, z_2=a_2+b_2\mathrm{i}$ , 那么就有 $z_1z_2=a_1a_2-b_1b_2+(a_1b_2+a_2b_1)\mathrm{i}$ . 如果还看不出什么, 就进行三角换元, 令 $a_1=k_1\cos\alpha, b_1=k_1\sin\alpha, a_2=k_2\cos\beta,b_2=k_2\sin\beta$ , 那么就有 $k_1=|z_1|, k_2=|z_2|$ , 于是
$$\begin{aligned}z_1z_2&=a_1a_2-b_1b_2+(a_1b_2+a_2b_1)\mathrm{i}\\&=k_1k_2(\cos\alpha\cos\beta-\sin\alpha\cos\beta)+k_1k_2(\cos\alpha\sin\beta+\cos\beta\sin\alpha)\mathrm{i}\\&=k_1k_2\cos(\alpha+\beta)+k_1k_2\sin(\alpha+\beta)\mathrm{i}\end{aligned}$$
现在就很显然了, 复数乘法的几何意义在于, 若复数 $z_1$ 的长度为 $k_1$ , 角度为 $\alpha$ , $z_2$ 的长度为 $k_2$ , 角度为 $\beta$ , 那么它们乘积的结果的复数的长度即为 $k_1k_2$ , 角度为 $\alpha+\beta$ .

旋转公式推导

这就启示我们使用一个特殊的复数即 $z'=\cos\theta+\sin\theta\mathrm{i}$ ,这个复数的特殊之处在于它的角度为 $\theta$ , 长度为 $1$ . 用这个复数去乘其他复数, 就可以起到旋转 $\theta$ 角的作用. 于是对于一个点 $P_0(x_0,y_0)$ , 我们将其表示在复平面即 $z_0=x_0+y_0\mathrm{i}$ , 然后就可以得到 $z_1=z_0z'=x_0\cos\theta-y_0\sin\theta+x_0\sin\theta+y_0\cos\theta\mathrm{i}$ , 再将 $z_1$ 重新用直角坐标系表达, 最终得到 $P_1(x_0\cos\theta-y_0\sin\theta,x_0\sin\theta+y_0\cos\theta)$ .

Geogebra 演示

我发现我越来越喜欢用 GGB 了…

打开 GeoGebra , 然后在制作好的图中点击分享 (如下图)

然后就会进入登录界面, 有账号直接登录, 没有就注册.

接着进入 GGB 官网 , 登录并进入个人主页

接着看 资源 中是否有你分享的图, 如果没有, 重新回到 GGB 再次尝试分享.

然后点击进入你要嵌入到网页的资源, 查看该资源 ID .

记下 ID, 然后就可以在需要展示 GGB 的地方用 iframe 引用了

1
2
3
4
5
6
7

<iframe 
frameborder="no"
title="随便写" 
src="https://www.geogebra.org/material/iframe/id/刚刚记下的 ID/smb/false/stb/false/stbh/false/ai/false/asb/false/sri/true/rc/false/ld/false/sdz/true/ctl/false/" 
width=100% 
height="480px">
</iframe>

比如

1
2
3
4
5
6

<iframe 
frameborder="no"
title="垂点抛物线" src="https://www.geogebra.org/material/iframe/id/myysrpxf/smb/false/stb/false/stbh/false/ai/false/asb/false/sri/true/rc/false/ld/false/sdz/true/ctl/false/" 
width=100% 
height="480px">
</iframe>

就会有这样的效果:

先上结论:

若有圆锥曲线 $\Gamma\colon\frac{x^2}{A}+\frac{y^2}{B}=1$ ,$A$ 与 $B$ 不同时取负数 (这样就同时代表了双曲线和椭圆) , 那么对于一个在该圆锥曲线上的点 $P_1(x_1,y_1)$ 来说, 存在一个点 $P_2(\frac{A-B}{A+B}x_1,\frac{B-A}{A+B}y_1)$ . 若作直线 $l_1, l_2$ 过点 $P_0$ 且相互垂直, 那么这两条直线与该圆锥曲线异于 $P_0$ 的两个交点 $M,N$ 的连线恒过点 $P_1$ .

对于形如 $y^2=2px$ 的抛物线也有类似结论, 不过 $P_2$ 为 $(2p+x_1,-y_1)$.

如何得到

我们以椭圆为例.

设椭圆 $\Gamma\colon\frac{x^2}{a^2}+\frac{y^2}{b^2}=1$ , 点 $P_2 (x_2, y_2)$ , 直线 $l_{MN}\colon y-y_2=k(x-x_2)$ 联立可得
$$(a^2k^2+b^2)x^2+2a^2k(y_2-kx_2)x+a^2((kx_2-y_2)^2-b^2)=0$$
设直线 $l_{MN}$ 与曲线交点为 $M(x_m,y_m),N(x_n,y_n)$ 根据韦达定理可得
$$\begin{aligned}x_mx_n=\frac{a^2((kx_2-y_2)^2-b^2)}{a^2k^2+b^2},x_m+x_n=\frac{2a^2k(kx_2-y_2)}{a^2k^2+b^2}\\y_my_n=\frac{b^2((kx_2-y_2)^2-a^2k^2)}{a^2k^2+b^2},y_m+y_n=\frac{2b^2(y_2-kx_2)}{a^2k^2+b^2}\end{aligned}$$
同时设 $P_1(x_1,y_1)$ ,有
$$\begin{aligned}(x_m-x_1,y_m,y_1)\cdot(x_n-x_2,y_n-y_2)&=0\\x_nx_m-x_1(x_m+x_n)+{x_2}^2+y_ny_m-y_1(y_m+y_n)+{y_2}^2&=0\end{aligned}$$
代入得
$$\begin{aligned}a^2((kx_2-y_2)^2-b^2)-2x_1a^2k(kx_2-y_2)+b^2((kx_2-y_2)^2-a^2k^2)-2y_1b^2(y_2-kx_2)\\=-({x_1}^2+{y_1}^2)(a^2k^2+b^2)\end{aligned}$$
即上式对于任意 $k$ 成立. 凭借这个复杂的等式我们已可以 (理论上) 求出 $P_1$ 与 $P_2$ 的关系, 但是这样太困难了, 我们稍稍取下巧, 只需取两个 $k$ 值就行, 很容易想到 $k=0$ 与 $k\to\infty$ (即令 $1/ \to 0$),

令 $k=0$ 得
$$a^2({y_2}^2-b^2)+b^2{y_2}^2-2b^2y_1y_2=-b^2({x_1}^2+{y_1}^2)$$
令 $k\to\infty$ 得
$$b^2({x_2}^2-a^2)+a^2{x_2}^2-2a^2x_1x_2=-a^2({x_1}^2+{y_1}^2)$$
这就好多了. 但是我们发现, 已知 $x_2,y_2$ 去求 $x_1,y_1$ 有困难, 但是我们稍稍整理一下就会发现
$$(a^2+b^2)\cdot {y_2}^2 -2b^2y_1\cdot y_2 + b^2({x_1}^2+{y_1}^2)-a^2b^2=0\qquad(k=0)$$
而这恰好是一个以 $x_1,y_1$ 作为参数的关于 $y_2$ 的二元一次方程, 那么就让我们把 $x_1,y_1$ 看成已知, 而 $x_2,y_2$ 看成未知的吧.

用求根公式可得
$$y_2=\frac{2b^2y_1\pm\sqrt{4b^2{y_1}^2-4(a^2+b^2)(b^2({x_1}^2+{y_1}^2)-a^2b^2)}}{2(a^2+b^2)}$$
$x_2$ 的求法也是同理 (利用 $k\to \infty$ 的情况) , 这样我们就得出了结果.

等会… 这个公式和上面那个完全不一样啊! 而且还带 $\pm$ , 显然有一个解得舍去的啊! 事实上, 最上面那个公式只是这个公式的简化, 运用了到目前还没用过的最重要的等式, 即
$$\begin{aligned}\frac{{x_1}^2}{a^2}+\frac{{y_1}^2}{b^2}&=1\\a^2-{x_1}^2&=\frac{a^2}{b^2}{y_1}^2\end{aligned}$$因此有$$\begin{aligned}y_2&=\frac{2b^2y_1\pm\sqrt{4b^2{y_1}^2-4(a^2+b^2)(b^2({x_1}^2+{y_1}^2)-a^2b^2)}}{2(a^2+b^2)}\\&=\frac{b^2y_1\pm\sqrt{b^2(a^2-{x_1}^2)(a^2+b^2)-a^2b^2{y_1}^2}}{a^2+b^2}\\&=\frac{b^2y_1\pm\sqrt{a^2{y_1}^2(a^2+b^2)-a^2b^2{y_1}^2}}{a^2+b^2}\\&=\frac{b^2y_1\pm a^2y_1}{a^2+b^2}\end{aligned}$$
取 $+$ 的不符合实际情况 $y_1=y_2$ , 于是就有
$$y_1=\frac{b^2-a^2}{a^2+b^2}y_2$$
同理得
$$x_1=\frac{a^2-b^2}{a^2+b^2}x_2$$
双曲线和椭圆公式类似, 可以用同样方法求得, 并且归入最上面说到的一整个结论.

但是抛物线和它们可不太一样, 难道要重新求一遍? 并不, 注意到抛物线是椭圆的一种极限. 设抛物线 $E\colon y^2=2px$ , 有
$$E\colon\lim_{n\to\infty} \frac{(x-np)^2}{n^2p^2}+\frac{y^2}{np^2}=1$$
利用上面求出的公式, 有
$$\begin{aligned}x_2&=\lim_{n\to\infty}np+(x-np)\frac{n^2p^2-np^2}{n^2p^2+np^2}\\&=\lim_{n\to\infty}np+(x-np)\frac{n-1}{n+1}\\&=\lim_{n\to\infty}\frac{n-1}{n+1}x+\frac{2np}{n+1}\\&=2p+x_1\end{aligned}$$

$y_2=-y_1$ 也是类似求法.

由上得到了全部结果.

感想

解析几何就一句话: 干就完事了!

摸索许久后, 找到了一个比较不错的方法解决该问题. 即在公式前后加上 ` 与 `, 即

1
2
3
4
5

{%raw%}$$
xxxxxx (公式内容)
$${%endraw%}

就可以完美解决.

这绝对不是水文.

DQN (Deep Q-Networks) 算法, 简单来说就是 Deep Learning + Q Learning.

Q Learning

Q Learning 实际上是维护一个 $Q$ 值表, 这个表可以认为是状态 $s$ 与动作 $a$ 的一个函数 $Q(s,a)$ , 其输出表示在状态 $s$ 下采用动作 $a$ 所获得的期望回报. 通过查询 $Q$ 值表, 就可以找出在某个状态 $s_t$ 下的最佳动作 $a_t$ . Q Learning 算法的要点就在于得到一个足够真实的 $Q$ 值表. 而 $Q$ 值表的更新, 则基于 Bellman 方程 (详情可见RL 基本概念).

DQN

DQN 的核心思想与 Q Learning 一样, 但区别就在于 $Q$ 函数. 在 Q Learning 中, $Q$ 函数是 $Q$ 值表, 也即一个个状态-动作对与期望回报的一一对应, 也就是离散的, 而在一些环境中 (比如 Atari 2600 games) 状态几乎是无穷多的, 根本不可能用 $Q$ 值表来容纳, 于是我们就用回归的方法来解决. 用神经网络 $Q(s,a\mid\theta)$ 来作为 $Q$ 函数从而代替 $Q$ 值表, 而这样的 $Q$ 函数的更新, 也同样基于 Bellman 方程.

数据获取与处理

获取游戏内容的最后 4 帧而不是 1 帧, 目的在于将游戏的动态过程表现出来. $\phi$ 函数保证输入给卷积神经网络的数据的维度固定. 而伪代码中的 $\text{Set}\;s_t+1=s_t,a_t,x_{t+1}$ 使得历史数据得以运用, 这就是为什么论文中说 “每一步的数据都可以在许多次参数更新中起到作用 (Each step of experience is potentially used in many weight updates) .”

输出的优化处理

一般来说, $Q$ 函数是根据状态 $s$ 和动作 $a$ 输出一个值 $r$ , 但是如果在实际中这样设计的话, 如果有 $n$ 个动作, 就要对每个动作都计算一次 $r$ 来得出最佳动作, 也就是计算 $n$ 次 ($n$ 次神经网络的前向传播) . 这样的话, 每次获取 $r$ 的计算时间与动作的个数乘正比, 如果动作数量足够多, 那么算力消耗会很大. 论文中给出了一个更优化的结构, 也就是 $Q$ 函数只依赖与状态 $s$ , 而其输出是传统 $Q$ 函数所有动作的输出结果的一个 array, 这样就可以只计算一次, 得到最佳动作.

疑问

现在还有的疑问就是 $\phi$ 函数究竟要怎样实现呢? 希望大佬们不吝赐教.

播放器文件下载并引入

地址在 https://github.com/cnyist/player .

下载下来后放入 source 目录中 (主题或 Hexo 自带的皆可) , 然后用 iframe 引入 index.html 文件

1

iframe(name="player", id="player", src="/player/", frameborder="0", onload="this.width=player.jp_container_N.scrollWidth;{%raw%}$('.songlist__item').each(function(){generate(${%endraw%}(this).attr('id'))});", style="z-index:100; position:fixed; left:0px; bottom:0px")

以上代码建议插入到 head 标签中 (这是 PUG 格式, 其他格式可以自行更改). 然后你就可以看见你的博客里多了一个播放器.

配置

1
2
3
4
5
6
7
8
9
10
11

var musicList = [{
    title: "Life Is Beautiful",
    artist: "The Afters",
    mp3: "https://cdn.jsdelivr.net/gh/cnyist/music@master/The%20Afters%20-%20Life%20Is%20Beautiful/The%20Afters%20-%20Life%20Is%20Beautiful.mp3",
    poster: "https://cdn.jsdelivr.net/gh/cnyist/music@master/The%20Afters%20-%20Life%20Is%20Beautiful/The%20Afters%20-%20Life%20Is%20Beautiful.jpg"
}, {
    title: "Fire",
    artist: "Said The Sky",
    mp3: "http://music.163.com/song/media/outer/url?id=435289279.mp3",
    poster: "http://p1.music.126.net/tg2zke_mrqwuOPlEIEUjGg==/18294773975127592.jpg?param=130y130"
}];

都很直白, 如果要增加歌曲或者更改就按照格式就好了.

配套播放框

在需要播放框的页面的底部引入 js/generate.js 文件, 同时写上这段 js,

1

generate_all()

并且引入 CSS css/player_box.css . 然后在需要插入音乐的地方写上

1

<li class="song_item" id="歌曲编号"></li>

其中歌曲编号是以歌曲顺序编的, 第一首为 ‘song1’ , 第二首为 ‘song2’ … 依此类推. 要插入音乐必须在播放器里配置这个音乐.

我是在差不多三年前看到过这张图的. 曾经对极限完全不了解的我, 简单的认为由于边长一直不变, 所以不能这么算. 前几天有个同学的问题突然又激发了我对这个问题的思考, 突然意识到了之前的我对这个问题理解的浅显, 弄明白了这样论证的问题所在以及它为什么看起来如此正确.

为什么是错误的?

首先, 我们自然知道 $\pi=3.1415926\cdots$ , 而上面的论证中不断的重复折叠所得到的周长, 最终都不会收敛于圆的周长 (一直等于 $4$) . 但是这里就会有人疑惑了: 为什么最终得到的 $4$ 不是圆的周长呢? 明明折到最后就是个圆呀? 而这, 其实源于我们对图中表述 不断的重复 和 一个图形怎样才是圆形 的理解的混乱所致.

什么是不断的重复?

在数学中, 有一个对应的概念, 即为极限. 重复次数设为 $n$ , 然后 $\lim n\to\infty$ 就可以认为是不断的重复了.

一个图形怎样才是圆形?

为了方便表述, 我们只考虑一个单位半圆 (半径为 $1$) 的圆弧

通过适当的建系, 可以通过一个函数来描述它, 我们用 $f(x)$ 来表示这个半圆. 现在, 我们列出两个关于判定某个图形 (该图形可以用函数表达, 该函数设为 $g(x)$) 是不是该半圆的两个指标:

1. $g(x) = f(x)$
2. 函数曲线的长度为 $\pi$ (即等于该半圆长度)

可以看到, 指标 1 其实是一个充要条件, 而指标 2 只是一个必要条件, 不过这足以用来解释矛盾的产生了. 我们将第 $n$ 次折叠后的正方形的函数设为 $g_n(x)$ , 结合起对 不断的重复 的理解 (求极限) , 我们来分析一下两种观点:

• 不断的重复后正方形最终折叠成一个半圆

  事实上这种想法用数学语言解释其实就是认为, 不断重复后的正方形的表达其实是 (此时正方形必须斜放, 不然不会有函数表达式, 但是这只是为了方便, 并不影响最终结果)

  $$ \lim_{n\to\infty} g_n(x) $$

  并且有

  $$ \lim_{n\to\infty} g_n(x)=f(x) $$

  按照指标 1 自然可以认为最终就是得到一个半圆.

• 不断的重复后最终并不是半圆

  我们让 $l(g_n(x))$ 表示 $g_n(x)$ 函数曲线的长度 . 那么有

  $$ \lim_{n\to\infty}l(g_n(x))=4\not-\pi $$

  根据指标 1 就可以认为最终其实不是圆.

因此不同的答案的原因在于指标选取不同.

那为什么不能证明 π = 4 ?

通过上述解释, 可能有的人仍然疑惑: 明明按照指标 1 自然可以认为最终就是得到一个半圆, 那为什么最终 $\pi\not=4$ ? 这种想法产生的原因其实就是对极限运算的顺序的随意调换导致的. 可以用一个不等式来表示
$$\lim_{x\to\infty}l(g_n(x))\not=l(\lim_{x\to\infty}g_n(x))$$
以第一种观点来计算, 最终算得折叠后的图形的长度为 $\lim_{x\to\infty}l(g_n(x))=\pi$ , 而以第二种观点来计算, 最终得到的长度为 $l(\lim_{x\to\infty}g_n(x))=4$ . 用人话说就是: 第一种观点下最终图形是半圆, 周长是 $\pi$ , 第二种观点下最终图形不是半圆, 周长自然就不是 $\pi$ 而是 $4$ . 而有人将这两个情况混在一起, 以第一种观点来讨论最终的图形是不是圆, 然后却以第二种观点来计算这个图形的长度, 自然就会产生谬误, 这也是这个论证极具有迷惑性的原因. 并且, 由于人们通常认为数学问题只会有一个答案, 因此会自然 (不自觉) 的把两种解释结合起来. 当然 (严谨的) 数学问题只会有一个答案, 但是用自然语言描述的数学问题, 由于其不够严谨, 因此才会产生不同的解答 (特别是谈到极限这类问题时).

1. 0 是自然数；
2. 每一个确定的自然数 a，都有一个确定的后继数 a’，a’ 也是自然数；
3. 对于每个自然数b、c，b = c 当且仅当 b 的后继数 = c 的后继数；
4. 0 不是任何自然数的后继数；
5. 任意关于自然数的命题，如果证明：它对自然数 0 是真的，且假定它对自然数 a 为真时，可以证明对 a’ 也真。那么，命题对所有自然数都真。

第五条公理事实上保证了数学归纳法的正确性. 但是看到这里也许就会有些疑惑, 数学归纳法的成立是自然的呀? 为什么还需要一个第五公理? 对于自然数 $0$ 成立, 并且可以从 $a$ 正确推出 $a'$ 成立, 不就能从 $0$ 开始一直推然后遍历整个自然数集么?

但事实上并非如此, 我们之所以会认为 “能从 $0$ 开始一直推然后遍历整个自然数集” 是因为我们被现有的自然数集的概念束缚住了, 认为某个数 $a$ 一定能由 $0$ 一直取后继数得到. 但是我们仔细查看公理, 并没有说明 (事实上也无法证明) 一个自然数一定可以由 $0$ 一直取后继数得到. 并且虽然公理 4 说明了 $0$ 不是任何自然数的后继数, 但是这并不代表自然数中只有 $0$ 不是任何自然数的后继数, 我们假设 $a$ 是自然数, $a\not =0$ , 并且 $a$ 不是任何自然数的后继数, 事实上 $a$ 的存在并没有违反任意一条公理, 但是由于其不是任何自然数的后继数, 自然也就无法由 $0$ 一直取后继数来得到, 也就是说如果没有第五公理, 即使能够证明某个命题 “对自然数 0 是真的，且假定它对自然数 a 为真时，可以证明对 a’ 也真。” 也不能推出该命题对于 $a$ 是真的. 因此第五公理的目的就是为了确保数学归纳法对于类似 $a$ 这样的数也可以成立. 当然, 就算整个自然数中只有 $0$ 不是自然数的后继数, 仍然可以存在自然数 $a\not=0$ 且 $a$ 不能由 $0$ 一直取后继数得到, 因为这并不违反公理.

例如 (下标只是一种记号) :
$$0\rightarrow1\rightarrow2\rightarrow3\rightarrow4\rightarrow\cdots$$
与
$$\cdots \rightarrow a_{-4}\rightarrow a_{-3}\rightarrow a_{-2}\rightarrow a_{-1}\rightarrow a_0\rightarrow a_1\rightarrow a_2\rightarrow a_3\rightarrow a_4\rightarrow\cdots$$
这两条链式结构之间没有相同元素 (显然是符合皮亚诺公理的) . 然而如果没有第五公理, 从 $0$ 开始的数学归纳法显然不会对下面那条链成立 (虽然对上面那条链成立).

Box

表示一个 n 维框, 即由 n 个数字描述这个空间.

Box.high

打印一个一维数组, 其中元素值为各个描述这个空间的数字的极大值.

Box.low

打印一个一维数组, 其中元素值为各个描述这个空间的数字的极小值.

Box.sample()

从可能的数值中随机采样.

Discrete

表示固定范围的非负数, 可以看做一些非负离散值的集合.

Discrete.n

可能的数值的总数.

Discrete.sample()

从可能的数值中随机采样.

最近学习发现电脑换来换去很麻烦, 然后就想到要把 Jupyter 部署在云服务器上, 正好服务器放在腾讯云也吃灰很久了, 就拿来玩一玩. 这里的所有操作都基于 Centos , 当然 Ubuntu 也适用, 但是要将教程中所有 root 换成 home/用户名 , 比如 home/ubuntu .

部署 Jupyter

安装 Anaconda

可以前往清华镜像源选择对应版本, 找到你想要的 Anaconda3 版本, 通过下面的指令进行下载

1

wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2020.07-Linux-x86_64.sh  # Anaconda3-2020.07-Linux-x86_64.sh 可以更换成你自己选择的版本

然后安装

1

bash Anaconda3-2020.07-Linux-x86_64.sh  # 同样更换你自己选择的版本

然后一路 enter / yes 就完事.

添加环境变量

接着添加环境变量.

1

sudo vi /etc/profile

输入密码后进入文件进行编辑. 在最底下加入两行

1
2

# Anaconda
export PATH="/root/anaconda3/bin:{%raw%}$PATH"

如果搞不懂服务器中文件的编辑 (vim) 的话, 可以百度一下, 很多教程的. 编辑完后, 按 ESC 后输入 :wq 然后 enter 保存文件并退出 vi.

然后

1

source ~/.bashrc

接着重启服务器

1

reboot

重启完成后验证是否安装成功

1

conda

成功就不会报错.

配置 Jupyter

进入 Python

1

python

然后

1
2

from notebook.auth import passwd
passwd()

接着它就会让你输入密码, 输入你想要设置的密码并再确认一次, 然后它就会生成一串密匙

1

'sha1:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'

复制下来, 然后生成配置文件

1

jupyter lab --generate-config

进入配置文件并修改

1

vi /root/.jupyter/jupyter_notebook_config.py

然后修改一下配置项, 如果要修改就将其前面的注释符号 # 删除

1
2
3
4
5
6

c.NotebookApp.ip = '*'
c.NotebookApp.password = u'sha1:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'  # 就是那串你复制的密匙
# 这个部分可改可不改, 不改就不要删除注释符号
c.NotebookApp.notebook_dir = '/tree' # 输入要 jupyter 开启的目录, 如果不修改, 那么就会默认在输入命令的目录下打开
c.NotebookApp.open_browser = False # 禁止自动打开浏览器
c.NotebookApp.allow_root = True # 允许 root 启动

然后就可以了

启动

1

jupyter lab

然后打开浏览器进入

1

云服务器ip:8888

然后输入你刚刚设置的密码就可以进入了.

PM2 进程托管

但是此时你必须一直开着服务器的终端不然 Jupyter 就会退出, 很不方便, 因此我们使用 PM2 来托管进程.

安装 Node.js

使用下列命令安装

1
2
3

wget -qO- https://raw.github.com/creationix/nvm/master/install.sh | sh
source ~/.bash_profile  # 如果是 Ubuntu 改成 source ~/.bashrc
nvm install stable

安装并使用 PM2

1

npm install pm2 -g

如果下载太慢先换成淘宝源

1

npm config set registry https://registry.npm.taobao.org

然后再试一次

1

npm install pm2 -g

在任意的目录新建文件 jupyter.js , 然后写入如下内容

1
2
3
4
5
6
7
8
9
10

//run
const { exec } = require('child_process')
exec('jupyter lab',(error, stdout, stderr) => {
        if(error){
                console.log('exec error: ${%endraw%}{error}')
                return
        }
        console.log('stdout: {%raw%}${stdout}');
        console.log('stderr: ${%endraw%}{stderr}');
})

然后保存退出, 执行脚本

1

pm2 start jupyter.js

就可以愉快的在服务器上使用 Jupyter 啦!

众所周知, 策略梯度有多种写法, 总的来说, 在保持策略梯度不变的情况下, 策略梯度可以写作
$$g=\mathbb{E}\left[\sum_{t=0}^{\infty}\Psi_t\nabla_\theta \log\pi_0(a_t\mid s_t)\right]\tag{1}$$
其中 $\Psi$ 可以是
$$\begin{aligned} 1.\;&\sum\nolimits_{t=0}^\infty r_t&轨迹的总回报\\\\ 2.\;&\sum\nolimits_{t'=t}^\infty r_{t'}&动作后轨迹的总回报\\\\ 3.\;&\sum\nolimits_{t'=t}^\infty r_{t'}-b(s_t)&基线形式\\\\ 4.\;&Q^{\pi}(s_t,a_t)&状态-动作价值函数\\\\ 5.\;&A^{\pi}(s_t,a_t)&优势函数\\\\ 6.\;&r_t+V^{\pi}(s_{t+1})-V^\pi(s_t)&\text{TD}\,残差 \end{aligned}$$
其中
$$ \begin{align} V^\pi(s_t):=\mathbb{E}_{\substack{s_{t+1:\infty},\\\\a_{t:\infty}}}\left[\sum_{l = 0}^\infty r_{t+l}\right]\qquad Q^\pi(s_t, a_t):=\mathbb{E}_{\substack{s_{t+1:\infty},\\\\a_{t+1:\infty}}}\left[\sum_{l = 0}^\infty r_{t+l}\right]\tag{2}\\\\ A^{\pi}(s_t,a_t)=Q^{\pi}(s_t,a_t)-V^{\pi}(s_t)\tag{3} \end{align}$$
这里逗号表示 $a:b$ 指的是 $(a,a+1,\dots,b)$ 这样的序列, $\mathbb{E}$ 的下标枚举了要被积分的变量. 前面 $5$ 项的推导或者推导资料在参数优化中都有说明, 而 $\text{TD}$ 残差其实是优势函数的一种无偏估计.

其中令 $\Psi_t=A^\pi(s_t, a_t)$ (优势函数) 的选择有几乎最小的方差. 这一点可以从策略梯度的角度直观的解释: 策略梯度中的每一步都会增加 “高于平均水平的动作” 的概率, 减少 “低于平均水平的动作” 的概率, 而优势函数 $A^{\pi}(s_t,a_t)=Q^{\pi}(s_t,a_t)-V^{\pi}(s_t)$ 恰好衡量了动作相对平均水平的好坏, 当动作高于平均水平时, 优势函数会取正数, 从而增加其概率; 当动作低于平均水平时, 优势函数会取负数. 从而降低其概率.

我们利用一个参数 $\gamma$ 来降低回报对延迟效应的反应的权重 (即减少未来回报的影响) 来减少方差, 代价是引入偏差. 这个参数相当于有折损的 $\text{MDPs}$ 公式, 但是我们将其当做一个在无折损问题中的一个减少方差的参数. 这些有折损的公式可以表示为
$$ \begin{align} V^{\pi, \gamma}(s_t):=\mathbb{E}_{\substack{s_{t+1:\infty},\\\\a_{t:\infty}}}\left[\sum_{l = 0}^\infty \gamma^l r_{t+l}\right]\qquad Q^{\pi, \gamma}(s_t, a_t):=\mathbb{E}_{\substack{s_{t+1:\infty},\\\\a_{t+1:\infty}}}\left[\sum_{l = 0}^\infty \gamma^l r_{t+l}\right]\tag{4}\\\\ A^{\pi, \gamma}(s_t,a_t)=Q^{\pi, \gamma}(s_t,a_t)-V^{\pi, \gamma}(s_t)\tag{5} \end{align}$$
梯度的有折损近似可以表示为
$$ g^\gamma:=\mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[\sum_{t=0}^{\infty}A^{\pi, \gamma}(s_t,a_t)\nabla_\theta \log\pi_0(a_t\mid s_t)\right]\tag{6}$$
由于优势函数是未知的, 所以我们需要对它进行估计. 在实践中, 往往只能学习到 $A^{\pi,\gamma}$ 的一个有偏估计 (但没有那么偏) .

我们引入一个关于 $A^{\pi,\gamma}$ 的一个估计, 并且这个估计是无偏的. 考虑一个与整个轨迹有关的优势函数的估计 $\hat{A}_t(s_{0:\infty},a_{0:\infty})$ .

我们定义: 一个估计 $\hat{A}_t$ 是 $\gamma\text{-just}$ 的当且仅当
$$ \mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[\hat{A}_t(s_{0:\infty},a_{0:\infty})\nabla_\theta \log\pi_0(a_t\mid s_t)\right]=\mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[A^{\pi, \gamma}(s_t,a_t)\nabla_\theta \log\pi_0(a_t\mid s_t)\right]\tag{7}$$
因此如果对于所有的 $t$ 来说 $\hat{A}_t$ 都是 $\gamma\text{-just}$ 的话, 就有
$$ \mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[\sum_{t=0}^{\infty}\hat{A}_t(s_{0:\infty},a_{0:\infty})\nabla_\theta \log\pi_0(a_t\mid s_t)\right]=g^\gamma\tag{8}$$
一个令 $\hat{A}_t$ 为 $\gamma\text{-just}$ 的充分条件是 $\hat{A}_t$ 可以被分解为两个函数 $Q_t$ 和 $b_t$ 之间的差. 并且 $Q_t$ 可以依赖于轨迹中的任意变量, 但必须是 $\gamma$-折扣 的 $Q$ 函数 (状态-动作价值函数) 的无偏估计 (如果要求是状态-动作价值函数的估计, 那么由于马尔科夫性, 在时间 $t$ 之前的变量都对状态-动作价值函数的值没有影响, 因此 $Q_t$ 只被时间 $t$ 以及 $t$ 以后的变量决定), 而 $b_t$ 是先于 $a_t$ 被采样的动作和状态的任意函数. 即如果 $\hat{A}_t$ 可以被写成 $\hat{A}_t(s_{0:\infty},a_{0:\infty})=Q_t(s_{t:\infty},a_{t:\infty})-b_t(s_{0:t},a_{0:t-1})$ 的形式, 并且对于任意的 $(s_t,a_t)$ 有 $\mathbb{E}_{s_{t+1:\infty},a_{t+1:\infty}\mid s_t,a_t}[Q_t(s_{t:\infty},a_{t:\infty})]=Q^{\pi, \gamma}(s_t,a_t)$ , 那么 $\hat{A}$ 就是 $\gamma\text{-just}$ 的.

证明:
$$ \begin{align} &\mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[\hat{A}_t(s_{0:\infty},a_{0:\infty})\nabla_\theta \log\pi_0(a_t\mid s_t)\right]\\\\ =&\mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[Q_t(s_{t:\infty},a_{t:\infty})\nabla_\theta \log\pi_0(a_t\mid s_t)\right]-\mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[b_t(s_{0:t},a_{0:t-1})\nabla_\theta \log\pi_0(a_t\mid s_t)\right] \end{align}$$
其中
$$ \begin{align} &\mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[Q_t(s_{t:\infty},a_{t:\infty})\nabla_\theta \log\pi_0(a_t\mid s_t)\right]\\\\ =&\mathbb{E}_{\substack{s_{0:t},\\\\a_{0:t}}}\left[\mathbb{E}_{\substack{s_{t+1:\infty},\\\\a_{t+1:\infty}}}\left[Q^{\pi,\gamma}(s_t,a_t)\nabla_\theta \log\pi_0(a_t\mid s_t)\right]\right]\\\\ =&\mathbb{E}_{\substack{s_{0:t},\\\\a_{0:t}}}\left[\mathbb{E}_{\substack{s_{t+1:\infty},\\\\a_{t+1:\infty}}}\left[A^{\pi, \gamma}(s_t,a_t)\nabla_\theta \log\pi_0(a_t\mid s_t)\right]\right]\\\\ =&\mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[A^{\pi, \gamma}(s_t,a_t)\nabla_\theta \log\pi_0(a_t\mid s_t)\right] \end{align}$$
而
$$ \begin{align} &\mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[b_t(s_{0:t},a_{0:t-1})\nabla_\theta \log\pi_0(a_t\mid s_t)\right]\\\\ =&\mathbb{E}_{\substack{s_{0:t},\\\\a_{0:t-1}}}\left[\mathbb{E}_{\substack{s_{t+1:\infty},\\\\a_{t:\infty}}}\left[b_t(s_{0:t},a_{0:t-1})\nabla_\theta \log\pi_0(a_t\mid s_t)\right]\right]\\\\ =&\mathbb{E}_{\substack{s_{0:t},\\\\a_{0:t-1}}}\left[\mathbb{E}_{\substack{s_{t+1:\infty},\\\\a_{t:\infty}}}\left[\nabla_\theta \log\pi_0(a_t\mid s_t)\right]b_t(s_{0:t},a_{0:t-1})\right] \end{align}$$
根据 $\text{EGLP}$ 定理 (见参数优化) 有
$$ \mathbb{E}_{\substack{s_{t+1:\infty},\\\\a_{t:\infty}}}\left[\nabla_\theta \log\pi_0(a_t\mid s_t)\right]=0$$
因此
$$ \mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[b_t(s_{0:t},a_{0:t-1})\nabla_\theta \log\pi_0(a_t\mid s_t)\right]=0$$
所以有
$$ \mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[\hat{A}_t(s_{0:\infty},a_{0:\infty})\nabla_\theta \log\pi_0(a_t\mid s_t)\right]=\mathbb{E}_{\substack{s_{0:\infty},\\\\a_{0:\infty}}}\left[A^{\pi, \gamma}(s_t,a_t)\nabla_\theta \log\pi_0(a_t\mid s_t)\right]$$
也就是说 $\hat{A}$ 是 $\gamma\text{-just}$ 的.

容易验证, 下列估计表达式 $\hat{A}_t$ 也是 $\gamma\text{-just}$ 的:
$$ \begin{align} &\bullet\sum\nolimits_{l=0}^\infty \gamma^l r_{t+l}&\qquad\qquad\qquad\qquad\bullet& A^{\pi,\gamma}(s_t,a_t)\\\\ &\bullet Q^{\pi,\gamma}(s_t,a_t)&\bullet& r_t+\gamma V^{\pi,\gamma}(s_{t+1})-V^{\pi,\gamma}(s_t) \end{align}$$

优势函数的估计

令 $\delta_t^V=r_t+\gamma V(s_{t+1})-V(s_t)$ 为 $V$ 的 $\gamma$ 折扣 $\text{TD}$ 残差. 注意到 $\delta_t^V$ 可以被看做是动作 $a_t$ 的优势. 事实上, 如果我们有确切的价值函数 $V=V^{\pi,\gamma}$ , 那么 $\delta_t^{V^{\pi,\gamma}}$ 会是一个无偏的, $\gamma\text{-just}$ 的优势估计.
$$ \begin{align} \mathbb{E}_{s_{t+1}}\left[\delta_t^{V^{\pi,\gamma}}\right]&=\mathbb{E}_{s_{t+1}}\left[r_t+\gamma V^{\pi,\gamma}(s_{t+1})-V^{\pi,\gamma}(s_t)\right]\\\\ &=\mathbb{E}_{s_{t+1}}\left[Q^{\pi,\gamma}(s_t,a_t)-V^{\pi,\gamma}(s_t)\right]\\\\ &=A^{\pi,\gamma}(s_t,a_t) \end{align}$$
然而, 也只有当 $V=V^{\pi,\gamma}$ 时这个优势估计才是 $\gamma\text{-just}$ 的.

接着, 让我们考虑 $k$ 项这样的 $\delta$ 相加的情况, 我们将其记为 $\hat{A}_t^{(k)}$
$$ \begin{align} &\hat{A}_t^{(1)}:=\delta_t^V&=&-V(s_t)+r_t+\gamma V(s_{t+1})\tag{11}\\\\ &\hat{A}_t^{(2)}:=\delta_t^V+\gamma\delta_{t+1}^V&=&-V(s_t)+r_t+\gamma r_{t+1}+\gamma^2 V(s_{t+2})\tag{12}\\\\ &\hat{A}_t^{(2)}:=\delta_t^V+\gamma\delta_{t+1}^V+\gamma^2\delta_{t+2}^V&=&-V(s_t)+r_t+\gamma r_{t+1}+\gamma^2 r_{t+2}+\gamma^3 V(s_{t+3})\tag{13} \end{align}$$

容易得出当且仅当 $V=V^{\pi,\gamma}$ 时 $\hat{A}_t^{(k)}$ 是 $\gamma\text{-just}$ 的. 注意到当 $k\to \infty$ 时, 由于 $\gamma^kV(s_{t+k})$ 项急剧减小 (当 $V\not= V^{\pi,\gamma}$ 时, 该项会产生偏差), 因此其偏差也会减少, 而 $-V(s_t)$ 项是不会产生偏差的 (因为这是基线). 令 $k\to \infty$ , 我们得到
$$ \hat{A}_t^{(\infty)}=\sum_{l=0}^{\infty}\gamma^l\delta_{t+l}^V=-V(s_t)+\sum_{l=0}^\infty\gamma^lr_{t+l}\tag{15}$$
仅仅是回报减去价值函数基线.

广义优势估计 $(\text{generalized advantage estimator})$ $\mathrm{GAE}(\gamma,\lambda)$ 被定义为这些 $k$ 步估计量的指数加权平均:
$$ \begin{align} \hat{A}_t^{\mathrm{GAE}(\gamma,\lambda)}&:=(1-\lambda)\left(\hat{A}_t^{(1)}+\lambda\hat{A}_t^{(2)}+\lambda^2\hat{A}_t^{(3)}+\cdots\right)\\\\ &=(1-\lambda)\left(\delta_t^V+\lambda(\delta_t^V+\gamma\delta_{t+1}^V)+\lambda^2(\delta_t^V+\gamma\delta_{t+1}^V+\gamma^2\delta_{t+2}^V)+\cdots\right)\\\\ &=(1-\lambda)\left(\delta_t^V(1+\lambda+\lambda^2+\cdots)+\gamma\delta_{t+1}^V(\lambda+\lambda^2+\lambda^3+\cdots)\\\\ +\gamma^2\delta_{t+2}^V(\lambda^2+\lambda^3+\lambda^4+\cdots)+\cdots\right)\\\\ &=(1-\lambda)\left(\delta_t^V\left(\frac{1}{1-\lambda}\right)+\gamma\delta_{t+1}^V\left(\frac{\lambda}{1-\lambda}\right)+\gamma^2\delta_{t+2}^V\left(\frac{\lambda^2}{1-\lambda}\right)+\cdots\right)\\\\ &=\sum_{l=0}^\infty(\gamma\lambda)^l\delta_{t+l}^V\tag{16} \end{align}$$
这个公式有两个特殊的情况即 $\lambda=0$ 和 $\lambda=1$ ,
$$\begin{align} \mathrm{GAE}(\gamma, 0):&\hat{A}_t:=\delta_t=r_t+\gamma V(s_{t+1})-V(s_t)\tag{17}\\\\ \mathrm{GAE}(\gamma,1):&\hat{A}_t:=\sum_{l=0}^\infty \gamma^l\delta_{t+l}=\sum_{l=0}^\infty \gamma^lr_{t+l}-V(s_t)\tag{18} \end{align}$$
 $\mathrm{GAE}(\gamma,1)$ 是 $\gamma\text{-just}$ 的, 不论 $V$ 的精度如何, 但由于其表达式中有多项和而导致其有高方差. 而 $\mathrm{GAE}(\gamma,0)$ 是 $\gamma\text{-just}$ 的当且仅当 $V=V^{\pi.\gamma}$ , 如果并非如此, 那么就会包含偏差, 但其往往具有更低的方差. 当 $0<\lambda<1$ 时我们得到更普遍的优势估计, 并且通过调整参数 $\lambda$ , 我们可以在偏差和方差之间取得一个平衡.

我们引入了一个包含两个参数 $\gamma$ 和 $\lambda$ 的优势估计, 这两个参数都会影响偏差和方差之间的平衡. 但是, 它们的作用以及对平衡的影响有本质上的不同. $\gamma$ 决定了价值函数 $V^{\pi,\gamma}$ 的最大值, 而 $\lambda$ 对其并没有影响. 并且无论价值函数是否是正确的, 只要 $\gamma<1$ 那么对于梯度 $g$ 来说就一定会有偏差 (因为已经使用了有折损回报, 而我们要优化的是无折损回报, 而 $\gamma$ 可以看做是影响方差与偏差的一个参数) . 而当 $\lambda<1$ 时只有错误的价值函数才会带来偏差. 因此我们往往会发现 $\lambda$ 的最优值往往比 $\gamma$ 的最优值要低得多, 这有可能是因为当获取到一个足够准确的价值函数后 $\lambda$ 引入的误差要比 $\gamma$ 小得多.

使用广义优势估计, 我们可以构建一个 $g^\gamma$ 的有偏估计
$$ g^\gamma\approx\mathbb{E}\left[\sum_{t=0}^{\infty}\nabla_\theta\log\pi_{\theta}(a_t\mid s_t)\hat{A}_t^{\mathrm{GAE(\gamma,\lambda)}}\right]=\mathbb{E}\left[\sum_{t=0}^{\infty}\nabla_\theta\log\pi_{\theta}(a_t\mid s_t)\sum_{l=0}^\infty (\gamma\lambda)^l\delta_{t+l}^V\right]\tag{19}$$
当 $\lambda=1$ 时就是无偏的了.

对回报变形后的解释

令 $\Phi \colon\mathcal{S}\to \mathbb{R}$ 为在状态空间上的任意函数考虑一个变形后的回报 $\tilde{r}$
$$ \tilde{r}(s,a,s')=r(s,a,s')+\gamma\Phi(s')-\Phi(s)\tag{20}$$
容易证明, 对于变形后的回报, 其有折损和为
$$ \sum_{l=0}^\infty \gamma^l \tilde{r}(s_{t+l},a_t,a_{t+l+1})=\sum_{l=0}^\infty \gamma^l r(s_{t+l},a_t,a_{t+l+1})-\Phi(s_t)\tag{21}$$
类似的, 我们定义
$$ \begin{align} &\tilde{Q}^{\pi,\gamma}(s,a)=Q^{\pi,\gamma}(s,a)-\Phi(s)\tag{22}\\\\ &\tilde{V}^{\pi,\gamma}(s)=V^{\pi,\gamma}(s)-\Phi(s)\tag{23}\\\\ &\tilde{A}^{\pi,\gamma}(s,a)=(Q^{\pi,\gamma}(s,a)-\Phi(s)\tag{24})-(V^{\pi,\gamma}(s)-\Phi(s))=A^{\pi,\gamma}(s,a) \end{align}$$
分别为变形后的回报, 价值, 优势函数.

注意到如果 $\Phi$ 如果恰好等于价值函数 $V^{\pi,\gamma}$ , 那么 $\tilde{V}^{\pi,\gamma}(s)$ 对于任何状态都等于零.

同样注意到使用变形后的回报对最大化有折损回报 $\sum_{t=0}^\infty \gamma^tr(s_t,a_t,s_{t+1})$ 的策略梯度是没有影响的. 但本文的目的其实是要最大化无折损回报, 而 $\gamma$ 是一个用来降低方差的参数.

引出回报变形后, 让我们考虑将其使用在梯度估计上. 注意到 $\tilde{r}$ 的形式与 $\delta^V$ 完全相同. 如果我们令 $\Phi=V$ , 那么就有
$$ \sum_{l=0}^\infty(\gamma\lambda)^l\tilde{r}(s_{t+l},a_t,s_{t+l+1})=\sum_{l=0}^\infty(\gamma\lambda)^l\delta_{t+l}^V=\hat{A}_t^{\mathrm{GAE}(\gamma,\lambda)}\tag{25}$$
因此可以将 $\delta_{t}^V$ 理解为变形后的回报, 而 $\gamma\lambda$ 其实就是折损.

还有另一种解释, 记响应函数 $\chi$ 为
$$\chi(l;s,a)=\mathbb{E}[r_{t+l}\mid s_t,a_t]-\mathbb{E}[r_{t+l}\mid s_t]\tag{26}$$
注意到 $A^{\pi,\gamma}(s,a)=\sum_{l=0}^\infty \gamma^l\chi(l;s,a)$ . 然后重新回忆我们用折扣因子 $\gamma$ 和 $A^{\pi,\gamma}$ 来估计的策略梯度 (式 $(6)$) 中有如下形式
$$ \nabla_\theta \log\pi_0(a_t\mid s_t)A^{\pi, \gamma}(s_t,a_t)=\nabla_\theta \log\pi_0(a_t\mid s_t)\sum_{l=0}^\infty \gamma^l\chi(l;s,a)\tag{27}$$
使用折扣 $\gamma<1$ 相当于急剧减少当 $l\gg 1/(1-\gamma)$ 的项 (因为 $\gamma^l$ 会变得很小) . 因此这些项带来的偏差会随着 $l$ 的增加而变少, 也就是说, 在大约 $1/(1-\gamma)$ 步后行动对回报的影响看起来像是被 “遗忘” 了.

如果我们使用变形后的回报 $\tilde{r}$ 并且有 $\Phi=V^{\pi,\gamma}$ , 不难得到当 $l>0$ 时有 $\mathbb{E}[\tilde{r}_{t+l}\mid s_t,a_t]=\mathbb{E}[\tilde{r}_{t+l}\mid s_t]=0$ (由于 $t$ 之后时刻采取的动作的概率完全依赖于那时候的状态 $s$ , 而 $t$ 时刻的动作已经给定为 $a_t$) . 因此只有 $l=0$ 是项才是非零的. 因此变形回报将依赖长时间的梯度估计变成了瞬时的. 当然我们往往难以得到非常好的估计, 但这已经能够给出式 $(16)$ 的一个很好的解释: 变形后的回报可以通过拟合 $V^{\pi,\gamma}$ 来减少响应函数起作用的范围, 通过引入一个更陡的折损 $\gamma\lambda$ 来减少由回报延迟 (即梯度估计中有很多项回报的和) 引起的噪声 (这是产生方差的原因), 也就是当 $l\gg 1/(1-\gamma\lambda)$ 时忽略项 $\nabla_\theta \log\pi_0(a_t\mid s_t)\delta^{V}_{t+l}$​ .

后记

这篇文章可能可以算是论文 High-Dimensional Continuous Control Using Generalized Advantage Estimation 的一个翻译, 但是其中增添了一些我自己的理解并且有些东西换了一些表述. 这篇文章只有论文前半部分的内容, 后面则是讲如何拟合价值函数以及一些探究, 有兴趣的可以看原论文. 其实原论文后面这段解释我看着怪怪的… 虽然说不出什么问题吧… 但是总感觉没什么必要… 因为前面的介绍以及推导已经解释了 $\text{GAE}$ 是如何起作用的… 还有我本人英语非常菜, 借助了翻译才一点点看下来… 如果哪个地方理解不对请指出, 还有大佬们请轻喷.

准备

首先, 你需要有 Github 和 CloudFlare 账号 (怎么注册就不用我教了吧…) 并登陆.

Github

fork jsproxy 项目,

然后进入到自己 fork 的 jsproxy 项目中, 进入 Settings 并下拉, 拉到 Github Pages 这一项

将 Select branch 设置成 gh-pages , 并 Save (这里我已经设置过了所以无法点击), 重新刷新并来到同样的位置, 它会显示大概如下内容

Your site is published at https://xxxx.github.io/jsproxy/

后面那串网址就是你的 Pages 地址, 记住它.

CloudFlare

进入主页, 然后进入 Workers ,

并创建 Worker,

然后在左侧的 “脚本” 区写下如下代码, 其中第 6 行中 https://xxxx.github.io/jsproxy 需要替换成你的 Pages 地址 (就是我前面叫你记住的那个) ,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290

'use strict'

/**
 * static files (404.html, sw.js, conf.js)
 */
const ASSET_URL = 'https://xxxx.github.io/jsproxy'//这里填写你Github pages的网址！

const JS_VER = 10
const MAX_RETRY = 1

/** @type {RequestInit} */
const PREFLIGHT_INIT = {
  status: 204,
  headers: new Headers({
    'access-control-allow-origin': '*',
    'access-control-allow-methods': 'GET,POST,PUT,PATCH,TRACE,DELETE,HEAD,OPTIONS',
    'access-control-max-age': '1728000',
  }),
}

/**
 * @param {any} body
 * @param {number} status
 * @param {Object<string, string>} headers
 */
function makeRes(body, status = 200, headers = {}) {
  headers['--ver'] = JS_VER
  headers['access-control-allow-origin'] = '*'
  return new Response(body, {status, headers})
}


/**
 * @param {string} urlStr 
 */
function newUrl(urlStr) {
  try {
    return new URL(urlStr)
  } catch (err) {
    return null
  }
}


addEventListener('fetch', e => {
  const ret = fetchHandler(e)
    .catch(err => makeRes('cfworker error:\n' + err.stack, 502))
  e.respondWith(ret)
})


/**
 * @param {FetchEvent} e 
 */
async function fetchHandler(e) {
  const req = e.request
  const urlStr = req.url
  const urlObj = new URL(urlStr)
  const path = urlObj.href.substr(urlObj.origin.length)

  if (urlObj.protocol === 'http:') {
    urlObj.protocol = 'https:'
    return makeRes('', 301, {
      'strict-transport-security': 'max-age=99999999; includeSubDomains; preload',
      'location': urlObj.href,
    })
  }

  if (path.startsWith('/http/')) {
    return httpHandler(req, path.substr(6))
  }

  switch (path) {
  case '/http':
    return makeRes('请更新 cfworker 到最新版本!')
  case '/ws':
    return makeRes('not support', 400)
  case '/works':
    return makeRes('it works')
  default:
    // static files
    return fetch(ASSET_URL + path)
  }
}


/**
 * @param {Request} req
 * @param {string} pathname
 */
function httpHandler(req, pathname) {
  const reqHdrRaw = req.headers
  if (reqHdrRaw.has('x-jsproxy')) {
    return Response.error()
  }

  // preflight
  if (req.method === 'OPTIONS' &&
      reqHdrRaw.has('access-control-request-headers')
  ) {
    return new Response(null, PREFLIGHT_INIT)
  }

  let acehOld = false
  let rawSvr = ''
  let rawLen = ''
  let rawEtag = ''

  const reqHdrNew = new Headers(reqHdrRaw)
  reqHdrNew.set('x-jsproxy', '1')

  // 此处逻辑和 http-dec-req-hdr.lua 大致相同
  // https://github.com/EtherDream/jsproxy/blob/master/lua/http-dec-req-hdr.lua
  const refer = reqHdrNew.get('referer')
  const query = refer.substr(refer.indexOf('?') + 1)
  if (!query) {
    return makeRes('missing params', 403)
  }
  const param = new URLSearchParams(query)

  for (const [k, v] of Object.entries(param)) {
    if (k.substr(0, 2) === '--') {
      // 系统信息
      switch (k.substr(2)) {
      case 'aceh':
        acehOld = true
        break
      case 'raw-info':
        [rawSvr, rawLen, rawEtag] = v.split('|')
        break
      }
    } else {
      // 还原 HTTP 请求头
      if (v) {
        reqHdrNew.set(k, v)
      } else {
        reqHdrNew.delete(k)
      }
    }
  }
  if (!param.has('referer')) {
    reqHdrNew.delete('referer')
  }

  // cfworker 会把路径中的 `//` 合并成 `/`
  const urlStr = pathname.replace(/^(https?):\/+/, '{%raw%}$1://')
  const urlObj = newUrl(urlStr)
  if (!urlObj) {
    return makeRes('invalid proxy url: ' + urlStr, 403)
  }

  /** @type {RequestInit} */
  const reqInit = {
    method: req.method,
    headers: reqHdrNew,
    redirect: 'manual',
  }
  if (req.method === 'POST') {
    reqInit.body = req.body
  }
  return proxy(urlObj, reqInit, acehOld, rawLen, 0)
}


/**
 * 
 * @param {URL} urlObj 
 * @param {RequestInit} reqInit 
 * @param {number} retryTimes 
 */
async function proxy(urlObj, reqInit, acehOld, rawLen, retryTimes) {
  const res = await fetch(urlObj.href, reqInit)
  const resHdrOld = res.headers
  const resHdrNew = new Headers(resHdrOld)

  let expose = '*'
  
  for (const [k, v] of resHdrOld.entries()) {
    if (k === 'access-control-allow-origin' ||
        k === 'access-control-expose-headers' ||
        k === 'location' ||
        k === 'set-cookie'
    ) {
      const x = '--' + k
      resHdrNew.set(x, v)
      if (acehOld) {
        expose = expose + ',' + x
      }
      resHdrNew.delete(k)
    }
    else if (acehOld &&
      k !== 'cache-control' &&
      k !== 'content-language' &&
      k !== 'content-type' &&
      k !== 'expires' &&
      k !== 'last-modified' &&
      k !== 'pragma'
    ) {
      expose = expose + ',' + k
    }
  }

  if (acehOld) {
    expose = expose + ',--s'
    resHdrNew.set('--t', '1')
  }

  // verify
  if (rawLen) {
    const newLen = resHdrOld.get('content-length') || ''
    const badLen = (rawLen !== newLen)

    if (badLen) {
      if (retryTimes < MAX_RETRY) {
        urlObj = await parseYtVideoRedir(urlObj, newLen, res)
        if (urlObj) {
          return proxy(urlObj, reqInit, acehOld, rawLen, retryTimes + 1)
        }
      }
      return makeRes(res.body, 400, {
        '--error': `bad len: ${%endraw%}{newLen}, except: ${rawLen}`,
        'access-control-expose-headers': '--error',
      })
    }

    if (retryTimes > 1) {
      resHdrNew.set('--retry', retryTimes)
    }
  }

  let status = res.status

  resHdrNew.set('access-control-expose-headers', expose)
  resHdrNew.set('access-control-allow-origin', '*')
  resHdrNew.set('--s', status)
  resHdrNew.set('--ver', JS_VER)

  resHdrNew.delete('content-security-policy')
  resHdrNew.delete('content-security-policy-report-only')
  resHdrNew.delete('clear-site-data')

  if (status === 301 ||
      status === 302 ||
      status === 303 ||
      status === 307 ||
      status === 308
  ) {
    status = status + 10
  }

  return new Response(res.body, {
    status,
    headers: resHdrNew,
  })
}


/**
 * @param {URL} urlObj 
 */
function isYtUrl(urlObj) {
  return (
    urlObj.host.endsWith('.googlevideo.com') &&
    urlObj.pathname.startsWith('/videoplayback')
  )
}

/**
 * @param {URL} urlObj 
 * @param {number} newLen 
 * @param {Response} res 
 */
async function parseYtVideoRedir(urlObj, newLen, res) {
  if (newLen > 2000) {
    return null
  }
  if (!isYtUrl(urlObj)) {
    return null
  }
  try {
    const data = await res.text()
    urlObj = new URL(data)
  } catch (err) {
    return null
  }
  if (!isYtUrl(urlObj)) {
    return null
  }
  return urlObj
}

然后点击 “保存并部署”,

然后在右侧的红框框内, 就可以看到你的网页代理的网址, 类似 https://xxxx.xxxx.workers.dev 这样的.

这样, 你的网页代理就搭建好啦! 只要访问网页代理的网址, 就可以突破 GFW 轻松浏览被墙的网站了.

绑定域名

首先需要拥有一个域名 (可以去 Freenom 获取免费域名) 并且将域名托管到 CloudFlare (什么你问我怎么托管??? 有手就行). 然后进入你的域名界面, 进入 Workers,

然后点击 “添加路由” , 在 “路由” 内填写你的域名以及二级前缀 (不知道什么是二级域名的自行百度…) 格式为 二级前缀.你的域名/* 并且在 “Worker” 中选你刚刚部署的 Worker,

当然这样还没完, 进入你域名的 DNS 解析到 CloudFlare 给你的 Worker 的域名

其中 “类型” 选择 “CNAME” , “名称” 填你的二级前缀, 内容填 CloudFlare 给你的 Worker 的域名 (类似 xxx.xxx.workers.dev) 然后保存.

这样域名就绑定成功, 可以访问你自己的域名愉快的 FQ 啦!

准备

创建账号及应用

先去 LeanCloud 注册个账号 (建议使用国际版, 这样绑定域名的时候不需要备案, 域名已经备案了的请无视) . 然后去控制台创建一个应用, 选择开发版, 名字就叫 image-api 吧.

下载命令行工具

详情请看安装命令行工具.

登录并初始化项目

命令行输入

1

lean login

登录, 然后按照提示选择区域并输入 LeanCloud 用户名和密码完成登录.

然后随意创建一个新文件夹, 进入里面执行

1

lean init

然后会输出大概类似下面的信息

1
2
3
4

[?] Please select an app: 
 1) Valine-Admin
 2) image-api
 => 

输入 2 , 回车, 然后又会出现

1
2
3
4
5
6
7

[?] Please select a language
 1) Node.js
 2) Python
 3) Java
 4) PHP
 5) Others
 => 

输入 4 回车, 然后…

1
2
3

[?] Please select an app template: 
 1) Slim
 =>

输入 1 回车, 项目就在本地初始化了.

实现随机 API

代码

进入 public/index.php , 然后就可以在这里写实现随机 API 的代码了. 至于如何写随机 API … 其实很简单, 百度一下就有了.

可以写成如下形式

1
2
3
4
5
6
7
8

<?php 
{%raw%}$num = 58;
${%endraw%}url = '';
{%raw%}$img = file_get_contents(${%endraw%}url, true);
header('Content-Type: image/jpeg');
echo {%raw%}$img;
exit;
?>

其中 ${%endraw%}url 变量需要你自己填写逻辑. 如果还是不会, 还是百度吧…. (Google 也可以哟)

上传并部署

写完代码之后就是上传和部署了, 非常简单, 只需要

1

lean deploy --prod 1

就好了.

绑定域名

绑定 LeanCloud 域名

如果你没有独立域名的话, 就只能绑定 LeanCloud 的二级域名. 进入应用 -> 云引擎 -> 设置 -> 云引擎域名设置域名, 填写你想要的域名, 然后保存就可以了.

绑定独立域名

绑定独立域名需要你拥有自己的域名. 点击 “绑定独立域名” ,

然后在 “云引擎、ClientEngine 域名” 下点击 “绑定新域名”,

然后写上你想要绑定的域名, 点击确定. 根据它的提示去你域名 DNS 解析所在服务商进行 CNAME 解析. 绑定成功后, 会提示 “已绑定” .

开始使用

只要访问你绑定的域名就可以啦! 现在你就拥有了一个属于自己的 API , 是不是很简单呢. 不过 LeanCloud 免费实例是有休眠政策的.

如果最近 24 小时内累计运行超过 18 小时，则强制休眠。此时新的请求会收到 503 的错误响应码

所以… 如果想要无限制使用, 可以升级实例.

代码文件在 spinup/alogs/pytorch/vpg/vpg.py . 我们尝试运行代码, 然后就报错了…

1
2
3
4
5
6
7
8
9
10

...
usage: ipykernel_launcher.py [-h] [--env_name ENV_NAME] [--render] [--lr LR]
ipykernel_launcher.py: error: unrecognized arguments: -f xxxx.json

An exception has occurred, use %tb to see the full traceback.

SystemExit: 2

xxxx/anaconda3/lib/python3.7/site-packages/IPython/core/interactiveshell.py:xxxx: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.
  warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)

嗯, 先看篇这篇文章解决. 然后再次运行, 又报错… 这次又是啥 ?!

1
2
3
4

...
--> 342     mpi_fork(args.cpu)  # run parallel code with mpi
...
CalledProcessError: Command '['mpirun', '-np', '4', 'xxxx/anaconda3/bin/python', 'xxxx/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py', '-f', 'xxxx/.local/share/jupyter/runtime/kernel-342bc725-7d2c-4cba-95f4-32c9b625dd61.json']' returned non-zero exit status 1.

观察了一下, 于是直接粗暴的删掉这一行 (就是这么任性) . 再次运行, 还是报错 ???

1
2

...
DependencyNotInstalled: No module named 'mujoco_py'. (HINT: you need to install mujoco_py, and also perform the setup instructions here: https://github.com/openai/mujoco-py/.)

这个问题我弄了好久, 最后发现好像是环境的问题, 我们将参数中 env 的值 HalfCheetah-v2 改为 CartPole-v0 , 也就是

1

parser.add_argument('--env', type=str, default='HalfCheetah-v2')

改成

1

parser.add_argument('--env', type=str, default='CartPole-v0')

然后再次运行. 终于, 成功运行了, 这下能够愉快的开启我们的代码研究之旅了.

Vanilla Policy Gradient

伪代码

使用 $\text{GAE-Lambda}$ (广义优势估计) 来进行优势估计. 因此需要拟合价值函数 $V^{\pi}(s_t)$ , 进而计算策略梯度进行优化. 有关广义优势估计的文章在这.

代码详解

VPGBuffer

1
2
3
4
5

"""
A buffer for storing trajectories experienced by a VPG agent interacting
with the environment, and using Generalized Advantage Estimation (GAE-Lambda)
for calculating the advantages of state-action pairs.
"""

从注释以及变量名中我们可以看出 VPGBuffer 是用来储存采样轨迹的各种信息的.

store

储存轨迹中的变量, 一个很简单的函数.

finish_path

结束一个 epoch 时调用的函数, 用之前储存的变量来计算 adv_buf (广义优势) 与ret_buf (回报).

self.adv_buf

计算广义优势估计.

last_val 的作用是方便计算 deltas , 而 deltas 就是 $\{\delta_1^V,\delta_2^V,\delta_3^V,\dots\}$ . (见广义优势估计)

其中计算优势时调用了一个重要的函数 core.discount_cumsum 这个函数在 core.poy 中有定义. 注释如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14

"""
magic from rllab for computing discounted cumulative sums of vectors.

input: 
    vector x, 
    [x0, 
     x1, 
     x2]

output:
    [x0 + discount * x1 + discount^2 * x2,  
     x1 + discount * x2,
     x2]
"""

确实很 magic . 而由于输入是 deltas 与 self.gamma * self.lam 而由注释看出计算的其实就是广义优势估计 $ \hat{A}_t^{\mathrm{GAE}(\gamma,\lambda)}$ .

self.ret_buf

计算有折损状态函数 $V^{\pi,\gamma}(s_t)$.

VPG

注释中已经详细介绍了参数的意义和作用. 中间有很多保存变量, 多线程的东西, 我们都略过, 只讲算法主体部分.

ac

1

ac = actor_critic(env.observation_space, env.action_space, **ac_kwargs)

由 actor_critic 对象生成, actor_critic 是对象 core.MLPActorCritic , 该对象在 core.py 中被定义, 由其从 torch.nn.Module 继承可知这是个神经网络.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class MLPActorCritic(nn.Module):


    def __init__(self, observation_space, action_space, 
                 hidden_sizes=(64,64), activation=nn.Tanh):
        super().__init__()

        obs_dim = observation_space.shape[0]

        # policy builder depends on action space
        if isinstance(action_space, Box):
            self.pi = MLPGaussianActor(obs_dim, action_space.shape[0], hidden_sizes, activation)
        elif isinstance(action_space, Discrete):
            self.pi = MLPCategoricalActor(obs_dim, action_space.n, hidden_sizes, activation)

        # build value function
        self.v  = MLPCritic(obs_dim, hidden_sizes, activation)

    def step(self, obs):
        with torch.no_grad():
            pi = self.pi._distribution(obs)
            a = pi.sample()
            logp_a = self.pi._log_prob_from_distribution(pi, a)
            v = self.v(obs)
        return a.numpy(), v.numpy(), logp_a.numpy()

    def act(self, obs):
        return self.step(obs)[0]

self.pi 与 self.v 分别是动作函数与价值函数.

其中出现了判断 action_space 是 Box 还是 Discrete 类型的代码. Box 与 Discrete 都是 Space 对象, 描述当前动作或环境. 其中 Box 表示多维连续空间, Discrete 表示一维离散空间. MLPGaussianActor 与 MLPCategoricalActor 都分别刻画了一个神经网络. 其输入 obs_dim 个数据, 输出 action_space.n 或者 action_space.shape[0] 个数据, 并且隐层由 hidden_sizes 指定.

总之, ac 是两个神经网络的集合, 一个是动作函数, 一个是价值函数.

var_counts

查看定义, 其计算的是神经网络变量的个数 (激活函数也算) .

compute_loss_pi

计算动作的损失, 对参数求导正是参数的梯度.

对参数求导后相当于用了广义优势估计 adv 来估计梯度.

compute_loss_v

计算价值的损失, 采用了均方误差.

从返回值为 ((ac.v(obs) - ret)**2).mean() 可以看出其拟合的是 ret 变量 (对应广义优势估计中的 $V^{\pi,\gamma}(s_t)$), 也就是状态函数 (有折损的).

update

一个函数, 是一次 epoch 后更新参数的过程, 其中先优化策略 (pi_optimizer) , 然后依据 train_v_tiers (每次 epoch 优化价值函数参数的次数) 多次优化价值函数 (vf_optimizer) .

训练过程

先在环境中 “走” 出一个 epoch (一个 epoch 的交互数 (interaction) 由 steps_per_epoch 指定), 然后调用 update 函数优化.

准备

首先 clone 下 spinningup 项目 (不要告诉我你连 Git 都没下载),

1

git clone https://github.com/openai/spinningup.git

然后按照spinningup 安装教程将该装的都装一遍, 接下来的代码都在其中执行.

已经完成的

• 参考资料

• OpenAI Spinning Up 文档
• Spinning Up Github 项目

先给出代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

import torch
import torch.nn as nn
from torch.distributions.categorical import Categorical
from torch.optim import Adam
import numpy as np
import gym
from gym.spaces import Discrete, Box

def mlp(sizes, activation=nn.Tanh, output_activation=nn.Identity):
    # Build a feedforward neural network.
    layers = []
    for j in range(len(sizes)-1):
        act = activation if j < len(sizes)-2 else output_activation
        layers += [nn.Linear(sizes[j], sizes[j+1]), act()]
    return nn.Sequential(*layers)

def train(env_name='CartPole-v0', hidden_sizes=[32], lr=1e-2, 
          epochs=50, batch_size=5000, render=False):

    # make environment, check spaces, get obs / act dims
    env = gym.make(env_name)
    assert isinstance(env.observation_space, Box), \
        "This example only works for envs with continuous state spaces."
    assert isinstance(env.action_space, Discrete), \
        "This example only works for envs with discrete action spaces."

    obs_dim = env.observation_space.shape[0]
    n_acts = env.action_space.n

    # make core of policy network
    logits_net = mlp(sizes=[obs_dim]+hidden_sizes+[n_acts])

    # make function to compute action distribution
    def get_policy(obs):
        logits = logits_net(obs)
        return Categorical(logits=logits)

    # make action selection function (outputs int actions, sampled from policy)
    def get_action(obs):
        return get_policy(obs).sample().item()

    # make loss function whose gradient, for the right data, is policy gradient
    def compute_loss(obs, act, weights):
        logp = get_policy(obs).log_prob(act)
        return -(logp * weights).mean()

    # make optimizer
    optimizer = Adam(logits_net.parameters(), lr=lr)

    # for training policy
    def train_one_epoch():
        # make some empty lists for logging.
        batch_obs = []          # for observations
        batch_acts = []         # for actions
        batch_weights = []      # for R(tau) weighting in policy gradient
        batch_rets = []         # for measuring episode returns
        batch_lens = []         # for measuring episode lengths

        # reset episode-specific variables
        obs = env.reset()       # first obs comes from starting distribution
        done = False            # signal from environment that episode is over
        ep_rews = []            # list for rewards accrued throughout ep

        # render first episode of each epoch
        finished_rendering_this_epoch = False

        # collect experience by acting in the environment with current policy
        while True:

            # rendering
            if (not finished_rendering_this_epoch) and render:
                env.render()

            # save obs
            batch_obs.append(obs.copy())

            # act in the environment
            act = get_action(torch.as_tensor(obs, dtype=torch.float32))
            obs, rew, done, _ = env.step(act)

            # save action, reward
            batch_acts.append(act)
            ep_rews.append(rew)

            if done:
                # if episode is over, record info about episode
                ep_ret, ep_len = sum(ep_rews), len(ep_rews)
                batch_rets.append(ep_ret)
                batch_lens.append(ep_len)

                # the weight for each logprob(a|s) is R(tau)
                batch_weights += [ep_ret] * ep_len

                # reset episode-specific variables
                obs, done, ep_rews = env.reset(), False, []

                # won't render again this epoch
                finished_rendering_this_epoch = True

                # end experience loop if we have enough of it
                if len(batch_obs) > batch_size:
                    break

        # take a single policy gradient update step
        optimizer.zero_grad()
        batch_loss = compute_loss(obs=torch.as_tensor(batch_obs, dtype=torch.float32),
                                  act=torch.as_tensor(batch_acts, dtype=torch.int32),
                                  weights=torch.as_tensor(batch_weights, dtype=torch.float32)
                                  )
        batch_loss.backward()
        optimizer.step()   
        return batch_loss, batch_rets, batch_lens

    # training loop
    for i in range(epochs):
        batch_loss, batch_rets, batch_lens = train_one_epoch()
        print('epoch: %3d \t loss: %.3f \t return: %.3f \t ep_len: %.3f'%
                (i, batch_loss, np.mean(batch_rets), np.mean(batch_lens)))

if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('--env_name', '--env', type=str, default='CartPole-v0')
    parser.add_argument('--render', action='store_true')
    parser.add_argument('--lr', type=float, default=1e-2)
    args, unknown = parser.parse_known_args()
    print('\nUsing simplest formulation of policy gradient.\n')
    train(env_name=args.env_name, render=args.render, lr=args.lr)

这里我们会对大部分函数以及一些变量一一解析, 其中一些 Pytorch 的 API 可以参考我的这篇文章或者官方文档 .

mlp

1
2
3
4
5
6
7

def mlp(sizes, activation=nn.Tanh, output_activation=nn.Identity):
    # Build a feedforward neural network.
    layers = []
    for j in range(len(sizes)-1):
        act = activation if j < len(sizes)-2 else output_activation
        layers += [nn.Linear(sizes[j], sizes[j+1]), act()]
    return nn.Sequential(*layers)

依据输入返回一个神经网络.

参数

• sizes

  其中包含神经网络的层数以及节点数信息

• activation

  节点的激活函数, 这里默认是 nn.Tanh 也就是 $\tanh$ 函数

• output_activation

  输出的激活函数

解析

layers 中的每一个元素就是神经网络的一部分 (节点与激活函数), 而 nn.Sequential(*layers) 是将这些部分组合成一个神经网络. 其中

1
2
3

for j in range(len(sizes)-1):
        act = activation if j < len(sizes)-2 else output_activation
        layers += [nn.Linear(sizes[j], sizes[j+1]), act()]

这个循环, act 指的是激活函数, 当该层不是最后一层时使用 activation , 是时使用 output_activation 作为激活函数.

get_policy

1
2
3

def get_policy(obs):
    logits = logits_net(obs)
    return Categorical(logits=logits)

依据环境计算出动作的对数概率, 并依此返回一个 Categorical 对象.

参数

• obs

  环境的参数, 描述了环境

解析

logits_net 是一个神经网络, 接受参数后输出最终结果 (动作的对数概率). 至于 Categorical 对象请自行了解.

get_action

1
2

def get_action(obs):
    return get_policy(obs).sample().item()

参数

• obs

  环境的参数, 描述了环境.

解析

利用 Categorical 对象采样动作.

compute_loss

1
2
3

def compute_loss(obs, act, weights):
    logp = get_policy(obs).log_prob(act)
    return -(logp * weights).mean()

计算损失.

参数

• obs

  环境的参数, 描述了环境

• act

  采样的动作

• weights

  某项的权重

解析

损失函数对参数的梯度要和期望回报对参数的梯度相同, 而期望回报对参数的梯度的估计式为
$$\hat{g}=\frac{1}{|\mathcal{D}|}\sum_{\tau\in\mathcal{D}}\sum^T_{t=0}\nabla_\theta\log \pi_\theta(a_t\mid s_t)R(\tau)$$
logp 其实就是 $\log \pi_\theta(a_t\mid s_t)$ , 而 weight 其实就是 $R(\tau)$ . 因此该函数返回的其实就是
$$\frac{1}{|\mathcal{D}|}\sum_{\tau\in\mathcal{D}}\sum^T_{t=0}\log \pi_\theta(a_t\mid s_t)R(\tau)$$
对 $\theta$ 求导后正是我们的梯度.

train_one_epoch

这是训练一个 epoch 的函数 (神经网络参数更新一次) .

解析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

if done:
    # if episode is over, record info about episode
    ep_ret, ep_len = sum(ep_rews), len(ep_rews)
    batch_rets.append(ep_ret)
    batch_lens.append(ep_len)

    # the weight for each logprob(a|s) is R(tau)
    batch_weights += [ep_ret] * ep_len

    # reset episode-specific variables
    obs, done, ep_rews = env.reset(), False, []

    # won't render again this epoch
    finished_rendering_this_epoch = True

    # end experience loop if we have enough of it
    if len(batch_obs) > batch_size:
        break

1
2
3
4
5
6
7
8

# take a single policy gradient update step
optimizer.zero_grad()
batch_loss = compute_loss(obs=torch.as_tensor(batch_obs, dtype=torch.float32),
                          act=torch.as_tensor(batch_acts, dtype=torch.int32),
                          weights=torch.as_tensor(batch_weights, dtype=torch.float32)
                          )
batch_loss.backward()
optimizer.step()   

依据 batch_size 确定走一个 epoch 走多少步. 然后当某个轨迹结束时 (也就是 done ) , 会计算总的回报, 然后通过 compute_loss 计算损失, 同时通过 Pytorch 的自动求导机制算出梯度, 然后用 optimizer (Adam 算法) 更新.

train

整个过程其实就是重复多个 epoch , 然后最终训练 epochs 次. 如果需要利用 Gym 的可视化, 可以将 render 参数设为 True

参数

• env_name

  Gym 环境的名称

• hidden_sizes

  神经网络隐藏节点数, 可以自行调整

• lr

  学习率.

• epochs

  训练的 epoch 数

• batch_size

  一次 epoch 行动的次数

• render

  Gym 是否可视化 (True or False)

1.

报错

1
2
3
4
5
6
7
8
9

usage: ipykernel_launcher.py [-h] [--env_name ENV_NAME] [--render] [--lr LR]
ipykernel_launcher.py: error: unrecognized arguments: -f xxxx.json

An exception has occurred, use %tb to see the full traceback.

SystemExit: 2

xxxx/anaconda3/lib/python3.7/site-packages/IPython/core/interactiveshell.py:xxxx: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.
  warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)

解决

将代码中的

1

args = parser.parse_args()

替换为

1

args, _ = parser.parse_known_args()

当然变量名可能不同, 将 args 替换为你使用的变量名就好了.

2.

报错

1
2
3
4

[In] !pip install xxxx
[Out] 
...
MemoryError

解决

使用 –no-cache-dir 参数

1

!pip –no-cache-dir install xxxx

如果还是不行, 请升级 pip 再试一次

1
2

pip install --upgrade pip
!pip –no-cache-dir install xxxx

torch.distributions

torch.distributions.categorical

torch.distributions.categorical.Categorical

CLASS

1	torch.distributions.categorical.Categorical(probs=None, logits=None, validate_args=None)

依据参数 probs 与 logits 来采样.

例子:

1
2
3
4
5
6
7
8
9
10
11

m = Categorical(torch.tensor([0.25, 0.25, 0.25, 0.25]))
m.sample()  # 在 0, 1, 2, 3 中等概率采样

输出: 
    tensor(3)

m = Categorical(torch.tensor([[0.25, 0.25, 0.25, 0.25], [0.25, 0.25, 0.25, 0.25]]))
m.sample()

输出: 
    tensor([0, 2])

参数:

• prob (Tensor)

  prob 是 $N$ 维向量, 同时采样输出为 $N-1$ 维向量. prob 其中包含的每个 $1$ 维向量为该结果中该位置数据的概率向量.

  注意: prob 必须是非负的, 有限的, 并且和不为 0 . 它会被标准化为和为 1 的形式.

• logits (Tensor)

  prob 的对数概率版本.

  注意: prob 与 logits 不能同时使用.

torch.nn

torch.nn.Identity

CLASS

1	torch.nn.Identity(*args, **kwargs)

建立起一个输入模块, 什么都不做, 一般用于神经网络的输入层.

例子:

1
2
3
4
5

m = nn.Identity(12, 2342, abc=123, asdfasudfio=23452345)  # 随意的参数
m(torch.randn(128, 20)).shape

输出:
    torch.Size([128, 20])

参数:

• 参数是任意的, 并且没有任何影响.

torch.nn.Linear

CLASS

1	torch.nn.Linear(in_features, out_features, bias=True)

用在线性方程 $y=xA^{\mathrm{T}}+b$ 中.

例子:

1
2
3
4
5
6
7

m = nn.Linear(20, 30)
input = torch.randn(128, 20)
output = m(input)
output.shape

输出:
    torch.Size([128, 30])

torch.nn.Tanh

CLASS

1	torch.nn.Tanh

用于元素的函数:
$$\mathrm{Tanh}(x)=\tanh(x)=\frac{\exp(x)-\exp(-x)}{\exp(x)+\exp(-x)}$$

例子:

1
2
3
4
5

m = nn.Tanh()
m(torch.Tensor([1, 3, 0.5]))

输出:
    tensor([0.7616, 0.9951, 0.4621])

torch.nn.Sequential

CLASS

1	torch.nn.Sequential(*args)

一个序列容器.

例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

nn.Sequential(
    nn.Conv2d(1,20,5),
    nn.ReLU(),
    nn.Conv2d(20,64,5),
    nn.ReLU()
)

输出:
    Sequential(
      (0): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
      (1): ReLU()
      (2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
      (3): ReLU()
    )

from collections import OrderedDict
nn.Sequential(OrderedDict([
    ('conv1', nn.Conv2d(1,20,5)),
    ('relu1', nn.ReLU()),
    ('conv2', nn.Conv2d(20,64,5)),
    ('relu2', nn.ReLU())
]))

输出:
    Sequential(
      (conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
      (relu1): ReLU()
      (conv2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
      (relu2): ReLU()
    )

torch.optim

方法:

• optimizer.step()

  在使用 backward() 后可以调用该方法执行一次优化步骤.

例子:

1
2
3
4
5
6

for input, target in dataset:
    optimizer.zero_grad()
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()

torch.optim.Adam

CLASS

1	torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)

实现了 Adam 算法

我们考虑一个随机的, 参数化的策略 $\pi_{\theta}$ . 我们的目标是最大化期望回报 (还可以称为性能函数, 与损失函数意义相反) $J(\pi_{\theta})=\mathop{\mathrm{E}}\limits_{\tau\sim \pi_{\theta}}[R(\tau)]$ . 这里使用有限无折损回报 ($\textrm{finite-horizon undiscounted return}$) 来推导, 但是无限有折损回报 ($\textrm{infinite-horizon discounted return}$) 的推导几乎是完全相同的.

我们会用梯度下降 ($\textrm{gradient ascent}$) 来优化策略的参数, 比如
$$\theta_{k+1}=\theta_k+\alpha\nabla_{\theta}J(\pi_{\theta})|_{\theta_k}$$
其中 $\nabla_{\theta}J(\pi_{\theta})|_{\theta_k}$ 代表 $\theta$ 取值为 $\theta_k$ .

为了使用该算法, 我们需要一个能够用数值计算的策略梯度表达式. 这包括两个步骤:

1. 推导出策略性能的解析梯度 ($\textrm{analytical gradient}$ , 什么是解析梯度? 详情看这篇文章) , 以期望值的形式表现 (便于用平均值估计).
2. 算出在样本上的估计的期望值, 可以使用有限步代理人-环境交互的数据.

这里列出对推导解析梯度有帮助的一些事实.

1. 轨迹的概率. 采取策略 $\pi_{\theta}$ 所做出的轨迹 $\tau=\{s_0,a_0,\dots,s_{T+1}\}$ 的概率是

1. 对数的把戏. 我们知道 $\log x$ 对 $x$ 的导数是 $1/x$ , 于是根据链式法则有

1. 轨迹的对数概率

1. 环境函数的梯度. 由于 $\rho_0(s_0),P(s_{t+1}\mid s_t,a_t),R(\tau)$ 与 $\theta$ 都无关, 因此它们的梯度为 $0$ .
2. 由第 4 条与第 3 条可知, 轨迹的对数概率的梯度是

由以上全部推导就有
$$\begin{aligned}\nabla_{\theta}J(\pi_\theta)&=\nabla_\theta\mathop{\mathrm{E}}_{\tau\sim\pi_0}[R(\tau)]\\\\&=\nabla_{\theta}\int_\tau P(\tau\mid \theta)R(\tau)\\\\&=\int_\tau \nabla_{\theta}P(\tau\mid \theta)R(\tau)\\\\&=\int_\tau P(\tau\mid \theta)\nabla_{\theta}\log P(\tau\mid \theta)R(\tau)\\\\&=\mathop{\mathrm{E}}_{\tau\sim\pi_\theta}[\nabla_{\theta}\log P(\tau\mid \theta)R(\tau)]\\\\&=\mathop{\mathrm{E}}_{\tau\sim\pi_\theta}\left[\sum_{t=0}^T\nabla_{\theta}\log \pi_\theta(a_t\mid s_t)R(\tau)\right]\end{aligned}$$
这样我们就可以用样本的平均值来估计策略梯度了. 假如我们有轨迹的集合 $\mathcal{D}=\{\tau_i\}_{i=1,\dots,N}$ , 并且这些轨迹都是代理人根据策略 $\pi_{\theta}$ 在环境中行动获得, 那么策略梯度可以估计为
$$\hat{g}=\frac{1}{|\mathcal{D}|}\sum_{\tau\in \mathcal{D}}\sum_{t=0}^T\nabla_\theta \log \pi_\theta(a_t\mid s_t)R(\tau)$$
其中 $|\mathcal{D}|$ 是集合 $\mathcal{D}$ 的元素个数.

损失函数

在强化学习中, 我们同样可以定义类似监督学习中的损失函数的概念, 但是在强化学习中的损失函数与监督学习中的损失函数有很大区别. 损失函数的梯度与策略梯度是相同的. 其接受的数据包含了 (状态, 动作, 权重) 三元组.

与参数关系

在监督学习中, 损失只与数据有关而与参数无关, 但是在强化学习中, 由于数据是遵循最近的策略采样得来的, 因此损失也与参数有关.

描述性能

在强化学习中, 我们关心的是期望回报 $J(\pi_{\theta})$ , 而损失函数并不能很好的表达它. 最优化损失函数并不能保证能够提升期望回报. 你甚至可以将损失函数降低到 $-\infty$ 而同时策略性能 (期望回报) 并不怎样. 此时我们称其 “过拟合” . 但这与我们通常所称的过拟合有所不同, 这只是一种描述, 因为实际上并没有什么泛化的错误, 只是损失函数低得吓人. 因此如果想真正描述策略性能, 我们应该关心期望回报而不是损失函数.

EGLP 定理

在这里我们会推导出一个在策略梯度中被广泛使用的一个中间结果, 我们称其为梯度对数概率期望 ($\text{Expect Grad-Log-Prob, EGLP}$) 定理.
$$\begin{aligned}\int_xP_{\theta}(x)&=1\\\\\nabla_\theta\int_xP_\theta(x)&=\nabla_\theta1\\\\\nabla_\theta\int_xP_\theta(x)&=0\\\\\int_x\nabla_\theta P_\theta(x)&=0\\\\\int_xP_\theta(x)\nabla_{\theta}\log P_\theta(x)&=0\\\\\mathop{\mathrm{E}}_{x\sim P_\theta}[\nabla_\theta\log P_\theta(x)]&=0\end{aligned}$$

别让过去影响你

梯度更新表达式
$$\nabla_\theta J(\pi_\theta)=\mathop{\mathrm{E}}_{\tau\sim\pi_0}\left[\sum_{t=0}^{T}\nabla_\theta \log\pi_0(a_t\mid s_t)R(\tau)\right]$$
每次更新, 都可以让每个动作的对数概率随着 $R(\tau)$ (采取动作的总回报) 成比例增加. 但这意义不大. 代理人应该根据其采取行动后的后果 (好还是坏) 来决定如何更改 (加强) 策略, 而采取行动之前的奖励和这一步行动的好坏没有直接关系. 事实上, 这一直觉在数学上也有很好的表达. 可以证明, 梯度更新表达式也可以写成如下等价形式.
$$\nabla_\theta J(\pi_\theta)=\mathop{\mathrm{E}}_{\tau\sim\pi_\theta}\left[\sum_{t=0}^{T}\nabla_\theta \log\pi_\theta(a_t\mid s_t)\sum_{t'=t}^TR(s_{t'},a_{t'},s_{t'+1})\right]$$
这被称为奖励策略梯度 ($\text{reward-to-go policy gradient}$).

证明过程比较繁琐, 不想看的可以略过.

证明

我们先提出一个函数
$$\mathop{\mathrm{E}}_{\tau\sim \pi_\theta}[f(t,t')]=\mathop{\mathrm{E}}_{\tau\sim\pi_\theta}[\nabla_\theta\log \pi_\theta(a_t\mid s_t)R(s_{t'},a_{t'},s_{t'+1})]$$
如果我们能证明当 $t'$$\begin{aligned}\mathop{\mathrm{E}}_{\tau\sim\pi_\theta}[f(t,t')]&= \int_\tau P(\tau\mid \pi_\theta)f(t,t')\\\\&=\int_{s_t,a_t,s_{t'},a_{t'},s_{t'+1}}P(s_t,a_t,s_{t'},a_{t'},s_{t'+1}\mid\pi_\theta)f(t,t')\\\\&=\mathop{\mathrm{E}}_{s_t,a_t,s_{t'},a_{t'},s_{t'+1}\sim\pi_\theta}[f(t,t')]\end{aligned}$$
根据贝叶斯法则, 我们有
$$\begin{aligned}\mathop{\mathrm{E}}_{A,B}[f(A,B)]&=\int_{A,B}P(A,B)f(A,B)\\\\&=\int_A\int_BP(B\mid A)P(A)f(A,B)\\\\&=\int_AP(A)\int_BP(B\mid A)f(A,B)\\\\&=\int_AP(A)\mathop{\mathrm{E}}_{B}\Big[f(A,B)\Big|A\Big]\\\\&=\mathop{\mathrm{E}}_A\bigg[\mathop{\mathrm{E}}_{B}\Big[f(A,B)\Big|A\Big]\bigg]\end{aligned}$$
若 $f(A,B)=h(A)g(B)$ , 那么还有
$$\begin{aligned}\mathop{\mathrm{E}}_{A,B}[f(A,B)]&=\mathop{\mathrm{E}}_A\bigg[\mathop{\mathrm{E}}_{B}\Big[f(A,B)\Big|A\Big]\bigg]\\\\&=\mathop{\mathrm{E}}_A\bigg[\mathop{\mathrm{E}}_{B}\Big[h(A)g(B)\Big|A\Big]\bigg]\\\\&=\mathop{\mathrm{E}}_A\bigg[h(A)\mathop{\mathrm{E}}_{B}\Big[g(B)\Big|A\Big]\bigg]\end{aligned}$$
因此就有
$$\begin{aligned}\mathop{\mathrm{E}}_{\tau\sim\pi_\theta}[f(t,t')]&=\mathop{\mathrm{E}}_{s_t,a_t,s_{t'},a_{t'},s_{t'+1}\sim\pi_\theta}[f(t,t')]\\\\&=\mathop{\mathrm{E}}_{s_{t'},a_{t'},s_{t'+1}\sim\pi_\theta}\bigg[\mathop{\mathrm{E}}_{s_t,a_t\sim\pi_\theta}\Big[f(t,t')\Big|s_{t'},a_{t'},s_{t'+1}\Big]\bigg]\\\\&=\mathop{\mathrm{E}}_{s_{t'},a_{t'},s_{t'+1}\sim\pi_\theta}\bigg[\mathop{\mathrm{E}}_{s_t,a_t\sim\pi_\theta}\Big[\nabla_\theta\log \pi_\theta(a_t\mid s_t)R(s_{t'},a_{t'},s_{t'+1})\Big|s_{t'},a_{t'},s_{t'+1}\Big]\bigg]\\\\&=\mathop{\mathrm{E}}_{s_{t'},a_{t'},s_{t'+1}\sim\pi_\theta}\bigg[R(s_{t'},a_{t'},s_{t'+1})\mathop{\mathrm{E}}_{s_t,a_t\sim\pi_\theta}\Big[\nabla_\theta\log \pi_\theta(a_t\mid s_t)\Big|s_{t'},a_{t'},s_{t'+1}\Big]\bigg]\end{aligned}$$
而
$$\begin{aligned}\mathop{\mathrm{E}}_{s_t,a_t\sim\pi_\theta}\Big[\nabla_\theta\log \pi_\theta(a_t\mid s_t)\Big|s_{t'},a_{t'},s_{t'+1}\Big]=\int_{s_t,a_t}P(s_t,a_t\mid\pi_\theta, s_{t'},a_{t'},s_{t'+1})\nabla_\theta\log \pi_\theta(a_t\mid s_t)\end{aligned}$$
当 $t'$$\begin{aligned}P(s_t,a_t\mid\pi_\theta, s_{t'},a_{t'},s_{t'+1})&=P(a_t\mid\pi_{\theta}, s_t,a_{t'},s_{t'+1})P(s_t\mid\pi_\theta, s_{t'},a_{t'},s_{t'+1})\\\\&=\pi_{\theta}(a_t\mid s_t,a_{t'},s_{t'+1})P(s_t\mid\pi_\theta, s_{t'},a_{t'},s_{t'+1})\\\\&=\pi_{\theta}(a_t\mid s_t)P(s_t\mid\pi_\theta, s_{t'},a_{t'},s_{t'+1})\end{aligned}$$
这是因为 $a_t$ 在当前环境 $s_t$ 已知晓时, 与之前做过的选择与之前经历的环境并无关系.

因此有
$$\begin{aligned}\mathop{\mathrm{E}}_{s_t,a_t\sim\pi_\theta}\Big[\nabla_\theta\log \pi_\theta(a_t\mid s_t)\Big|s_{t'},a_{t'},s_{t'+1}\Big]&=\int_{s_t,a_t}P(s_t,a_t\mid\pi_\theta, s_{t'},a_{t'},s_{t'+1})\nabla_\theta\log \pi_\theta(a_t\mid s_t)\\\\&=\int_{s_t,a_t}\pi_{\theta}(a_t\mid s_t)P(s_t\mid\pi_\theta, s_{t'},a_{t'},s_{t'+1})\nabla_\theta\log \pi_\theta(a_t\mid s_t)\\\\&=\int_{s_t}P(s_t\mid\pi_\theta, s_{t'},a_{t'},s_{t'+1})\int_{a_t}\pi_{\theta}(a_t\mid s_t)\nabla_\theta\log \pi_\theta(a_t\mid s_t)\\\\&=\mathop{\mathrm{E}}_{s_t\sim\pi_\theta}\bigg[\mathop{\mathrm{E}}_{a_t\sim\pi_\theta}\Big[\nabla_\theta \log\pi_\theta(a_t\mid s_t)\Big|s_t\Big]\bigg|s_{t'},a_{t'},s_{t'+1}\bigg]\end{aligned}$$
此时就要用到我们的 $\text{EGLP}$ 定理了.
$$\because \int_{a_t}\pi_\theta(a_t\mid s_t)\Big|s_t=1\\\\\therefore \mathop{\mathrm{E}}_{a_t\sim\pi_\theta}\Big[\nabla_\theta \log\pi_\theta(a_t\mid s_t)\Big|s_t\Big] =0$$
因此当 $t'

而当 $t'\geqslant t$ 时, 无法将 $P(s_t,a_t\mid\pi_\theta, s_{t'},a_{t'},s_{t'+1})$ 分解成该形式, 所以就不会有这个结果. 我们可以举个例子. 如果现在有 $80\%$ 的几率会下雨, 而你打算如果不下雨, 就有 $90\%$ 的可能会出去买水果. 此时, 无论之前发生了什么 (也许昨天下雨了 (环境) , 也许前天买了水果 (动作)) , 现在买水果的概率都是 $(1-80\%)\times90\%=16\%$ . 但是如果这个时候, 未来的你突然穿越回来, 告诉你你后来买了水果, 那么这时下雨的概率其实就改变了, 变得更倾向于不下雨 (事实上如果你后来买了水果, 不下雨的概率就会是 $1$ ). 如果没买, 则相反. 这就是未来影响现在而过去不影响现在.

既然期望是相同的, 但根据这个式子来训练为什么会更好呢? 这是因为策略梯度需要用样本轨迹来估计, 而且最好是低方差的. 如果方差较大, 说明估计不太准确. 如果公式中包括过去的奖励, 虽然它们均值为 $0$ , 但方差并不是, 在公式中增加它们只会给策略梯度的样本估计增加噪音, 增加方差. 而这会导致需要较多的样本轨迹才能得到一个相对稳定的值 (收敛) . 删除它们后, 我们就可以用更少的样本轨迹得到低方差的估计, 也就是说更容易收敛. 举个例子, 如果你要估计一系列数字的期望 (也就是算平均值) , 它们服从的概率分布的期望其实都是 $50$, 但是一个方差很大, 一会 $100$ 一会 $20$ 一会 $3$, 你需要很多数字才能得到一个较为准确的值. 而另一个方差很小, 基本就是 $50.3$ , $49.8$ , $49.5$ 这样, 只需要几个数字就能估计得差不多.

策略梯度的基线

由 $\text{EGLP}$ 可以得到一个非常直接的结论: 如果一个函数 $b(s_t)$ 只依赖于状态 $s_t$ , 那么有
$$\mathop{\mathrm{E}}_{a_t\sim\pi_\theta}[\nabla_\theta \log \pi_\theta(a_t\mid s_t)b(s_t)]=0$$
这使得我们可以在策略梯度的表达式中任意加上 (或删除) 这样的项而不改变最终结果, 比如说
$$\begin{aligned}\nabla_\theta J(\pi_\theta)&=\mathop{\mathrm{E}}_{\tau\sim\pi_\theta}\left[\sum_{t=0}^{T}\nabla_\theta \log\pi_\theta(a_t\mid s_t)\sum_{t'=t}^TR(s_{t'},a_{t'},s_{t'+1})\right]\\\\&=\mathop{\mathrm{E}}_{\tau\sim\pi_\theta}\left[\sum_{t=0}^{T}\nabla_\theta \log\pi_\theta(a_t\mid s_t)\left(\sum_{t'=t}^TR(s_{t'},a_{t'},s_{t'+1})-b(s_t)\right)\right]\end{aligned}$$
函数 $b$ 被称为基线 ($\text{baseline}$).

基线函数一般是策略上的价值函数 ($\text{on-policy value function}$) $V^\pi(s_t)$ . 稍微回想一下, 这个函数给出了代理人从状态 $s_t$ 开始, 使用策略 $\pi$ 以后的平均 (期望) 回报.
$$V^{\pi}(s) = \mathop{\mathrm E}_{\tau\sim\pi}[R(\tau)\mid s_0 = s]$$
经验上, 让基线 $b(s_t)=V^\pi(s)$ 对降低策略梯度的样本估计的方差有好处, 这会让策略学习更快, 更稳定. 从概念上来看, 这也很有意义: 它体现了一个直觉, 如果代理人得到了它所期望的 (即 $\sum_{t'=t}^TR(s_{t'},a_{t'},s_{t'+1})=V^\pi(s)$) , 他会对此 “感到” 中立 ( “中立” 在数学上看来即值为 $0$ ).

事实上, $V^\pi(s_t)$ 并不能被准确计算, 因此应该使用它的估计. 通常我们会使用一个与策略同步更新 (这样就能总是估计最近的策略的价值函数) 的神经网络 $V_\phi(s_t)$ 来估计它.

策略梯度的其他形式

我们已经见到了策略梯度的很多等价形式
$$\nabla_\theta J(\pi_\theta)=\mathop{\mathrm{E}}_{\tau\sim\pi_0}\left[\sum_{t=0}^{T}\nabla_\theta \log\pi_0(a_t\mid s_t)\Phi_t\right]$$
 $\Phi_t$ 可以是
$$\Phi_t=R(\tau)$$
又或者
$$\Phi_t=\sum_{t'=t}^TR(s_{t'},a_{t'},s_{t'+1})$$
再或者
$$\Phi_t=\sum_{t'=t}^TR(s_{t'},a_{t'},s_{t'+1})-b(s_t)$$
但还有两种重要的形式.

1. 状态-动作价值函数

证明可以看这里.

1. 优势方程

而
$$A^{\pi}(s_t,a_t)=Q^{\pi}(s_t,a_t)-V^{\pi}(s_t)$$
由基线得知等价.

为了更详细的了解这个主题, 你应该阅读 Generalized Advantage Estimation (GAE). 也可以参考我的文章 GAE 算法 .

问题

设 $M=\left[\begin{matrix}A&B\\\\C&D\end{matrix}\right]$ 为一个 $2n\times2n$ 矩阵, 其中每一块为一个 $n\times n$ 矩阵. 假设 $A$ 可逆且 $AC=CA$ . 那么有 $\det M=\det(AD-CB)$ .

证明

由于 $A$ 可逆且 $AC=CA$ , 所以两边左乘 $A^{-1}$ 有 $C=ACA^{-1}$ . 那么有
$$\begin{aligned}\det\left[\begin{matrix}A&B\\\\C&D\end{matrix}\right]&=\det\left[\begin{matrix}A&B\\\\C-A(CA^{-1})&D-B(CA^{-1})\end{matrix}\right]\\\\&=\det\left[\begin{matrix}A&B\\\\0&D-B(CA^{-1})\end{matrix}\right]\\\\&=\det(A)\det \Big(D-B(CA^{-1})\Big)\\\\&=\det\Big(D-B(CA^{-1})\Big)\det(A)\\\\&=\det\bigg(\Big(D-B(CA^{-1})\Big)A\bigg)\\\\&=\det(DA-BC)\end{aligned}$$
这已经很接近我们的答案了.

将矩阵沿主对角线旋转 (即转置) 与沿副对角线旋转并不改变行列式的值, 即
$$\det\left[\begin{matrix}A&B\\\\C&D\end{matrix}\right]=\det\left[\begin{matrix}D&C\\\\B&A\end{matrix}\right]$$
而根据上面的推导, 有
$$\det\left[\begin{matrix}D&C\\\\B&A\end{matrix}\right]=\det(AD-CB)$$
那么也就是说
$$\det\left[\begin{matrix}A&B\\\\C&D\end{matrix}\right]=\det\left[\begin{matrix}D&C\\\\B&A\end{matrix}\right]=\det(AD-CB)$$
$\blacksquare$

二

问题

对于形如
$$D_n=\left|\begin{matrix}1&1&\cdots&1\\\\x_1&x_2&\cdots&x_n\\\\\vdots&\vdots&&\vdots\\\\{x_1}^{n-1}&{x_2}^{n-1}&\cdots&{x_n}^{n-1}\end{matrix}\right|$$
的 $n$ 阶行列式称为范德蒙德行列式, 并且有
$$D_n=\prod_{1\leqslant j

证明

我们用数学归纳法证明. 当 $n=2$ 时, 显然成立. 假设该结论对 $n-1$ 阶范德蒙德行列式成立, 那么对于 $n$ 阶范德蒙德行列式有
$$\left|\begin{matrix}1&1&\cdots&1\\\\x_1&x_2&\cdots&x_n\\\\\vdots&\vdots&\ddots&\vdots\\\\{x_1}^{n-1}&{x_2}^{n-1}&\cdots&{x_n}{n-1}\end{matrix}\right|=\left|\begin{matrix}1&1&\cdots&1\\\\0&x_2-x_1&\cdots&x_n-x_1\\\\\vdots&\vdots&\ddots&\vdots\\\\0&{x_2}^{n-1}-{x_2}^{n-2}x_1&\cdots&{x_n}^{n-1}-{x_n}^{n-2}x_1\end{matrix}\right|$$
即从下到上每行减去上一行的 $x_1$ 倍. 从而我们有
$$\begin{aligned}\left|\begin{matrix}1&1&\cdots&1\\\\0&x_2-x_1&\cdots&x_n-x_1\\\\\vdots&\vdots&\ddots&\vdots\\\\0&{x_2}^{n-1}-{x_2}^{n-2}x_1&\cdots&{x_n}^{n-1}-{x_n}^{n-2}x_1\end{matrix}\right|&=\left|\begin{matrix}x_2-x_1&\cdots&x_n-x_1\\\\\vdots&\ddots&\vdots\\\\{x_2}^{n-1}-{x_2}^{n-2}x_1&\cdots&{x_n}^{n-1}-{x_n}^{n-2}x_1\end{matrix}\right|\\\\&=\left|\begin{matrix}1(x_2-x_1)&\cdots&1(x_n-x_1)\\\\\vdots&\ddots&\vdots\\\\{x_2}^{n-2}(x_2-x_1)&\cdots&{x_n}^{n-2}(x_n-x_1)\end{matrix}\right|\\\\&=(x_2-x_1)(x_3-x_1)\cdots(x_n-x_1)\left|\begin{matrix}1&\cdots&1\\\\\vdots&\ddots&\vdots\\\\{x_2}^{n-2}&\cdots&{x_n}^{n-2}\end{matrix}\right|\\\\&=(x_2-x_1)(x_3-x_1)\cdots(x_n-x_1)\prod_{2\leqslant j$\blacksquare$

引理 1: 以 $L_2,L_3,\dots L_n$ 为棱的广义平行六面体的体积的平方等于 $\det(AA^{\mathrm{T}})$ .

证明: $A$ 是 $m\times n$ 矩阵, 因此 $AA^{\mathrm{T}}$ 是 $m\times m$ 方阵. 现在对 $m$ 进行归纳: 当 $m=1$ 时, $A$ 为行向量, 于是 $AA^{\mathrm T}$ 为长度的平方, 因此 $m=1$ 时成立.

假设 $m>1$ , 且对于 $m-1$ 的情况引理 1 成立. 那么我们可以将 $L_1$ 分为 $H+G$
$$\newcommand\xrule{\rule[.5ex]{2em}{.4pt}}\left[\begin{matrix}\xrule &L_1&\xrule\\\\\xrule &L_2&\xrule\\\\&\vdots& \\\\\xrule &L_m&\xrule\\\\\end{matrix}\right]=\left[\begin{matrix}\xrule &H+G&\xrule\\\\\xrule &L_2&\xrule\\\\&\vdots&\\\\\xrule &L_m&\xrule\\\\\end{matrix}\right]$$
而由于 $G$ 可以由 $L_2,L_3,\dots L_n$ 线性表示, 于是可以左乘初等矩阵将 $L_1$ 中的 $G$ 通过减去其余向量相应倍数消去, 并且由于 $\det(E)=1$ , 因此不会影响结果
$$\det\Big((EA)(EA)^{\mathrm T}\Big)=\det\Big((EA)(A^{\mathrm T}E^{\mathrm{\mathrm T}})\Big)=\det(AA^{\mathrm{T}})$$
我们用 $A^*$ 来代替 $EA$ , 并且将 $A^*$ 去除 $H$ 后的部分用 $D$ 表示
$$A^*=\left[\begin{matrix}\xrule & H&\xrule\\\\\xrule &L_2&\xrule\\\\&\vdots& \\\\\xrule &L_m&\xrule\\\\\end{matrix}\right]=\left[\begin{matrix}\xrule &H&\xrule\\\\\xrule &D&\xrule\\\\\end{matrix}\right]$$
因此有
$$\newcommand\lrule{\rule[.5ex]{.4pt}{2em}}A^*{A^*}^{\mathrm{T}}=\left[\begin{matrix}\xrule &H&\xrule\\\\\xrule &D&\xrule\\\\\end{matrix}\right]\left[\begin{matrix}\lrule &\lrule \\\\H^{\mathrm T}&D^\mathrm T\\\\\lrule &\lrule \\\\\end{matrix}\right]=\left[\begin{matrix}HH^{\mathrm T}&HD^{\mathrm T}\\\\DH^\mathrm T&DD^\mathrm T\end{matrix}\right]=\left[\begin{matrix}HH^{\mathrm T}&0\\\\0&DD^\mathrm T\end{matrix}\right]$$
因为 $H\perp D$ , 因此 $HD^{\mathrm T}=DH^{\mathrm T}=0$ .

而根据行列式的递归定义, 可得
$$\det\left(\left[\begin{matrix}HH^{\mathrm T}&0\\\\0&DD^\mathrm T\end{matrix}\right]\right)=HH^\mathrm T\cdot\det(DD^\mathrm T)$$
由归纳假设与广义平行四面体体积定义得, $\det(DD^\mathrm T)$ 是底面体积的平方, 而 $HH^\mathrm T$ 是高的长度的平方, 于是相乘就是体积的平方. 证毕

由引理 1, 我们可以轻松证明行列式的几何意义.
$$\begin{aligned}\det(AA^\mathrm T)=\det(A)\det(A^\mathrm T)=\det(A)^2&=体积^2\\\\|\det(A)|&= 体积\end{aligned}$$

根据上式, 当 $\epsilon$ 取得足够小时, 就可以近似的认为其是梯度. 这样的方法求梯度非常方便, 但是并不是完全精确 (总是存在误差) , 这就是数值梯度.

解析梯度 (Analytical Gradient)

解析梯度即利用求导法则, 精确的求出其梯度, 推导一般比较麻烦, 但是如果推导出来, 那么求梯度的速度和精确度会好于数值梯度

例子

比如说我们要求 $f(x)=x^2$ 这个函数在 $x=2$ 时的梯度.

数值梯度

解析梯度

相信大家都在高中接触过超几何分布. 超几何分布是不放回的, 该分布给出了抽取 $n$ 次后抽到次品次数的概率. 如果一个随机变量 $X$ 服从于超几何分布, 那么有
$$P(X=k)=\frac{C_{N}^kC_{M-N}^{n-k}}{C_{M}^{n}}$$
其中 $k$ 为抽取到的次品数, $M$ 为总数, $N$ 为总次品数.

问题

生活中很多变量都服从于超几何分布, 我们举个例子

假设你们班要选出 $10$ 个人参加某个活动, 但是想要参加活动的人却有 $40$ 个人, 那么就要采取抽纸条的方式来选出参加活动的人. 准备 $40$ 张纸条, 其中有 $10$ 张是被标记了的. $40$ 个候选人每人抽取一张纸条, 抽到被标记纸条的人就可以参加活动.

当已经有 $n$ 个人抽取了之后, $n$ 个人里面有 $X$ 个人可以参加活动, 这个 $X$ 就服从于超几何分布. 现在我们想要讨论的问题是: 这样的抽取公平吗? 先抽和后抽对你抽到标记纸条的概率有没有影响? 再抽象一点, 即如果第 $n$ 次抽取时, 前面 $n-1$ 次抽取的结果都未知, 那么这次抽取抽到次品的概率是多少?

直觉告诉我们, 应该是公平的, 也就是说在这样一个无返回抽样中, 无论先后, 抽取到次品的概率都是一样的, 并且这个值应该就是 $N/M$ .

证明

我们先说明几个数学符号, 以便后续推导

• $N$, $M$ 分别为次品数和总数
• $X_1,X_2,\dots,X_n$ 分别为第 $n$ 次抽取抽取到的次品个数 ( $X_n$ 服从两点分布, 即其值要么 $0$ 要么 $1$)

首先, 我们可以立即得出, $P(X_1=1) = \frac{N}{M}$ . 然后我们尝试计算 $P(X_2=1)$
$$\begin{aligned}P(X_2=1)&=P(X_2=1,X_1=1)+P(X_2=1,X_1=0)\\\\&=P(X_2=1\mid X_1=1)P(X_1=1)+P(X_2=1\mid X_1=0)P(X_1=0)\\\\&=\frac{N}{M}\frac{N-1}{M-1}+\frac{M-N}{M}\frac{N}{M-1}\\\\&=\frac{N(M-N+N-1)}{M(M-1)}\\\\&=\frac{N}{M}\end{aligned}$$
果然, $P(X_2=1)$ 也等于 $\frac{N}{M}$ .

不过… 好像还是没有什么思路, 那我们继续计算 $P(X_3=1)$
$$\begin{aligned}P(X_3=1)&=\sum_{X_1}\sum_{X_2}P(X_3,X_2,X_1)\\\\&=\sum_{X_1}\sum_{X_2}P(X_3\mid X_2,X_1)P(X_2\mid X_1)P(X_1)\\\\&=\left(\frac{N}{M}\frac{N-1}{M-1}\frac{N-2}{M-2}+\frac{N}{M}\frac{M-N}{M-1}\frac{N-1}{M-2}\right)\\\\&+\left(\frac{M-N}{M}\frac{N}{M-1}\frac{N-1}{M-2}+\frac{M-N}{M}\frac{M-N-1}{M-1}\frac{N}{M-2}\right)\end{aligned}$$
并且有
$$\frac{N}{M}\frac{N-1}{M-1}\frac{N-2}{M-2}+\frac{N}{M}\frac{M-N}{M-1}\frac{N-1}{M-2}=\frac{N}{M}\frac{N-1}{M-1}\\\\\frac{M-N}{M}\frac{N}{M-1}\frac{N-1}{M-2}+\frac{M-N}{M}\frac{M-N-1}{M-1}\frac{N}{M-2}=\frac{M-N}{M}\frac{N}{M-1}$$
于是同样的 $P(X_3=1)=\frac{N}{M}$ .

现在我们思考 $P(X_3=1)$ 与 $P(X_2=1)$ , $P(X_2=1)$ 与 $P(X_1=1)$ 之间有什么关系. 我们想象有很多轨迹, 每条轨迹最终都可以到达 $X_2=1$ 这种情况, 而将所有的能达到 $X_2=1$ 的轨迹产生的概率相加, 就是 $P(X_2=1)$ . $\frac{N}{M}\frac{N-1}{M-1}$ (第一次抽中, 第二次抽中) 和 $\frac{M-N}{M}\frac{N}{M-1}$ (第一次没抽中, 第二次抽中) 最终都可以达到第二次抽中这个结果 (也就是 $X_2=1$), 而也就只有这两条轨迹, 因此它们的概率相加便是 $P(X_2)=1$ .

类似的, 我们考虑 $X_3=1$ 的各个轨迹. $X_3=1$ 的轨迹和 $X_2=1$ 的轨迹有没有什么关联? 当然有, $X_3=1$ 的轨迹可以由 $X_2=1$ 的轨迹 “派生” 出来. 每一条 $X_2=1$ 轨迹都可以派生为两条 $X_3=1$ 轨迹, 比如说 $\frac{N}{M}\frac{N-1}{M-1}$ (第一次抽中, 第二次抽中), 这一条 $X_2=1$ 轨迹, 可以派生出 $\frac{N}{M}\frac{N-1}{M-1}\frac{N-2}{M-2}$ (第一次抽中, 第二次抽中, 第三次抽中) 与 $\frac{N}{M}\frac{(M-1)-(N-1)}{M-1}\frac{N-1}{M-2}$ (第一次抽中, 第二次没抽中, 第三次抽中) 两条轨迹, 即第二次抽中与没抽中的区别. 而 $X_4=1$ 的轨迹与 $X_3=1$ 的轨迹, $X_5=1$ 的轨迹与 $X_4=1$ 的轨迹, 乃至 $X_n=1$ 的轨迹与 $X_{n-1}=1$ 的轨迹之间, 都有这种派生关系. 如果能够证明, 一条轨迹出现的概率等于其派生出的两条轨迹出现的概率之和 (前面的计算已经看出在 $n=1,2$ 时满足这种关系), 那么就能够用数学归纳法证明每次抽取抽到次品的概率是相同的. 于是就要证明
$$\cdots \frac{N-a}{M-b} = \cdots\frac{N-a}{M-b}\frac{N-a-1}{M-b-1}+\cdots\frac{(M-b)-(N-a)}{M-b}\frac{N-a}{M-b-1}$$
由于 $X_n=1$ 的某条轨迹派生出 $X_{n+1}=1$ 的轨迹的过程中, 轨迹前面 $n-1$ 个动作 (即是否抽取到) 是不变的, 因此用 $\cdots$ 代替. 上面的式子显然成立, 于是我们就证明了 $P(X_n=1)=P(X_{n-1}=1)=\dots= P(X_1=1)=\frac{N}{M}$ . 也就是说, 游戏是公平的.

应用

据此, 我们可以轻松得出, 超几何分布的期望和二项分布是类似的. 即如果 $X$ 服从于超几何分布, 那么如果抽取 $n$ 次, $E(X)=n\frac{N}{M}=np$ (将 $\frac{N}{M}$ 看成一个概率 $p$ ).

有模型与无模型

强化学习的一个最重要的分支即为有模型 ($\textrm{Model-Base}$) 与无模型 ($\textrm{Model-Free}$) 学习. 它们的区别在于, 代理人 ($\textrm{Agent}$, 即执行算法的主体) 是否获得环境的模型 ($\textrm{Model}$). 有了模型, 就可以预知状态转移以及回报.