Dynamic Programming

策略评估

回顾之前我们提到的状态值函数：
$$\begin{gathered} v_{\pi }(s)\doteq {\mathbb{E}}_{\pi }[G_t|S_t=s] \\ ={\mathbb{E}}_{\pi }[R_{t+1}+\gamma G_{t+1}|S_t=s] \\ ={\mathbb{E}}_{\pi }[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s] \\ =\sum _a\pi (a|s)\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\pi }(s^{\prime })] \end{gathered}$$

使用迭代法求解：考虑一系列近似值函数 $v_0,v_1,v_2,\dots$ 都是从 $S^{+}$ 到 $\mathbb{R}$ 的映射（$S^{+}$ 表示包含终止态的所有状态的集合）
利用贝尔曼方程进行迭代更新：
$$\begin{gathered} v_{k+1}(s)\doteq \mathbb{E}[R_{t+1}+\gamma v_k(S_{t+1})|S_t=s] \\ =\sum _a\pi (a|s)\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_k(s^{\prime })] \end{gathered}$$
这个算法被称为迭代策略评估

策略提升

考虑在当前状态 $s$ 下，改变原有策略，选择一个动作 $a\ne \pi (s)$，然后再遵从现有的策略 $\pi$

这种情况下的价值：
$$\begin{gathered} q_{\pi }(s,a)\doteq \mathbb{E}[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s,A_t=a] \\ =\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\pi }(s^{\prime })] \end{gathered}$$

如果 $q_{\pi }(s,a)$ 大于 $v_{\pi }(s)$ ，也就是说在状态 $s$ 下选择动作 $a$ 并且之后遵循策略 $\pi$ 会比一直遵循策略 $\pi$ 好，因此，每次到达状态 $s$ 时，我们都愿意去选择动作 $a$ ，而这个新的策略总体上来说会更好

这就是策略提升的一种特殊情况
考虑确定的策略 $\pi$ 和 ${\pi }^{\prime }$，如果有：
$$q_{\pi }(s,{\pi }^{\prime }(s))⩾v_{\pi }(s).\forall s\in \mathcal{S}$$
因此：
$$\begin{gathered} v_{\pi }(s)⩽q_{\pi }(s,{\pi }^{\prime }(s)) \\ =\mathbb{E}[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s,A_t={\pi }^{\prime }(s)] \\ ={\mathbb{E}}_{{\pi }^{\prime }}[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s] \\ ⩽{\mathbb{E}}_{{\pi }^{\prime }}[R_{t+1}+\gamma q_{\pi }(S_{t+1},{\pi }^{\prime }(S_{t+1}))|S_t=s] \\ ={\mathbb{E}}_{{\pi }^{\prime }}[R_{t+1}+\gamma \mathbb{E}[R_{t+2}+\gamma v_{\pi }(S_{t+2})|S_{t+1},A_{t+1}={\pi }^{\prime }(S_{t+1})]|S_t=s] \\ ={\mathbb{E}}_{{\pi }^{\prime }}[R_{t+1}+\gamma R_{t+2}+{\gamma }^2{v}_{\pi }(S_{t+2})|S_t=s] \\ ⩽{\mathbb{E}}_{{\pi }^{\prime }}[R_{t+1}+\gamma R_{t+2}+{\gamma }^2{R}_{t+3}+{\gamma }^3{v}_{\pi }(S_{t+3})|S_t=s] \\ ⋮ \\ ⩽{\mathbb{E}}_{{\pi }^{\prime }}[R_{t+1}+\gamma R_{t+2}+{\gamma }^2{R}_{t+3}+{\gamma }^3{R}_{t+4}+\cdots |S_t=s] \\ =v_{{\pi }^{\prime }}(s) \end{gathered}$$
我们就说策略 ${\pi }^{\prime }$ 不劣于 $\pi$

现在，给定一个策略和价值函数后，我们可以对在某个状态下的动作改变进行评估

将其扩展到所有状态和所有可能的动作，我们根据 $q_{\pi }(s,a)$ 来选择每个状态下表现最好的动作
因此，新的贪婪策略 ${\pi }^{\prime }$：
$$\begin{gathered} {\pi }^{\prime }(s)\doteq \underset{a}{\mathrm{argmax}}{q}_{\pi }(s,a) \\ =\underset{a}{\mathrm{argmax}}\mathbb{E}[R_{t+1}+\gamma v_{\pi }(S_{t+1})|S_t=s,A_t=a] \\ =\underset{a}{\mathrm{argmax}}\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\pi }(s^{\prime })] \end{gathered}$$
这种通过 在原始策略的价值函数上选取贪婪策略 的方式来制定新策略的过程就是策略提升

策略迭代

$${\pi }_0\stackrel{E}{\to }{v}_{{\pi }_0}\stackrel{I}{\to }{\pi }_1\stackrel{E}{\to }{v}_{{\pi }_1}\stackrel{I}{\to }{\pi }_2\stackrel{E}{\to }\cdots \stackrel{I}{\to }{\pi }_{\ast }\stackrel{E}{\to }{v}_{\ast }$$
$\stackrel{E}{\to }$ 表示策略评估 ，$\stackrel{I}{\to }$ 表示策略提升

书中给出的伪代码：

价值迭代

策略迭代过程中的策略评估可以用几种方式进行截断而不会失去其收敛性

一种方式是策略评估在一次迭代后就停止，这就是价值迭代
它可以写成：
$$\begin{gathered} v_{k+1}(s)\doteq \underset{a}{\max }\mathbb{E}[R_{t+1}+\gamma v_k(S_{t+1})|S_t=s,A_t=a] \\ =\underset{a}{\max }\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_k(s^{\prime })],\forall s\in \mathcal{S} \end{gathered}$$
注意到这种方式就是将贝尔曼最优方程作为更新方式：
$$v_{\ast }(s)=\underset{a}{\max }\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\ast }(s^{\prime })]$$
书中给出的伪代码：

广义策略迭代

术语广义策略迭代（GPI）指代策略评估和策略提升相互交互的一般概念

当评估过程和提升过程都稳定时，价值函数和策略就都是最优的

因为只有当价值函数与当前策略一致时它才会稳定，而策略只有当它关于当前价值函数是贪婪时才会稳定
因此，两个过程都稳定下来意味着，一个策略关于自己的价值函数是贪婪的
这预示着贝尔曼最优方程：
$$v_{\ast }(s)=\underset{a}{\max }\sum _{s^{\prime },r}p(s^{\prime },r|s,a)[r+\gamma v_{\ast }(s^{\prime })]$$
的成立，因此这个策略和价值函数都是最优的

实验

赌徒问题
一个赌徒对抛掷硬币的游戏进行下注。如果硬币正面朝上，他将赢得押在这一掷上的所有赌注，如果反面朝上，他将输掉所押的赌注。如果赌徒赢得 100 元，或者输光了钱，那么游戏结束。
每一次抛掷硬币，赌徒必须决定押多少，这些钱必须是整数
状态是赌徒的资本， s ∈ { 1 , 2 , … , 99 } s\in \{1, 2, \dots, 99 \} s∈{1,2,…,99}，动作是押注多少， a ∈ { 0 , 1 , … , min ⁡ ( s , 100 − s ) } a \in \{ 0, 1, \dots, \min (s, 100-s) \} a∈{0,1,…,min(s,100−s)}
赌徒到达目标时奖励为 +1，其他转移过程都为 0
状态价值函数给出从每个状态出发能够赢的概率
策略是从资本多少到押注的一个映射
最优策略最大化达到目标的概率
$p_h$ 代表硬币正面朝上的概率，事先已知

在这个问题里我们对于环境有着足够的了解，具体地说，可以事先确定四元组 $p(s^{\prime },r|s,a)$ 的值，因此，可以用动态规划求解

编程求解

Casino.hpp

#ifndef CASINO_H
#define CASINO_H

#include <vector>
#include <random>

// Implement value iteration for the gambler's problem
class Casino
{
public:
    Casino(unsigned target,
             double ph,
             double theta = 0.001,
             double gamma = 0.2)
        : target_(target)
        , ph_(ph)
        , theta_(theta)
        , gamma_(gamma)
        , valueFunc_(target_ + 1)
        , policy_(target_ - 1)
    {
        valueFunc_[0] = 0;
        std::random_device rd;
        std::knuth_b rng{rd()};
        for (size_t i = 1; i < target_; ++i)
            valueFunc_[i] = std::generate_canonical<double, 12>(rng);
        valueFunc_[target_] = 1;
        valueIterate();
    }

    inline std::vector<double>& ValueFunction() noexcept {return valueFunc_;}
    inline std::vector<unsigned>& Policy() noexcept {return policy_;}

private:
    void valueIterate() {
        for (unsigned s = 1; s < target_; ++s) {
            const unsigned maxWager = std::min(s, target_ - s);
            /*
             * value function
             * V(s) = \max_a \sum_{s', r} p(s', r|s, a) [r + \gamma V(s')]
             */
            double delta = 0;
            do {
                delta = 0;
                const double raw = valueFunc_[s];
                double maxValue = 0;
                for (unsigned a = 0; a <= maxWager; ++a) {
                    double sum = 0;
                    /*
                     * There are only two cases:
                     * head or tail
                     */
                    unsigned nextState_1 = (s + a > target_) ? target_ : s + a;
                    double p_1 = ph_;
                    unsigned r_1 = (nextState_1 >= target_) ? 1 : 0;
                    unsigned nextState_2 = s < a ? 0 : s - a;
                    double p_2 = 1 - ph_;
                    unsigned r_2 = (nextState_2 >= target_) ? 1 : 0;
                    sum += (p_1 * (r_1 + gamma_ * valueFunc_[nextState_1]))
                           + (p_2 * (r_2 + gamma_ * valueFunc_[nextState_2]));
                    if (sum > maxValue)
                        maxValue = sum;
                }
                valueFunc_[s] = maxValue;
                delta = std::max(delta, std::fabs(raw - valueFunc_[s]));
            } while(delta > theta_);
            /*
             * policy
             * \pi(s) = \argmax_z \sum_{s', r} p(s', r|s, a) [r + \gamma V(s')]
             */
            double maxValue = 0;
            for (unsigned a = 0; a <= maxWager; ++a) {
                unsigned nextState_1 = (s + a > target_) ? target_ : s + a;
                double p_1 = ph_;
                unsigned r_1 = (nextState_1 >= target_) ? 1 : 0;
                unsigned nextState_2 = (s < a) ? 0 : s - a;
                double p_2 = 1 - ph_;
                unsigned r_2 = (nextState_2 >= target_) ? 1 : 0;
                double tmpValue = (p_1 * (r_1 + gamma_ * valueFunc_[nextState_1]))
                                  + (p_2 * (r_2 + gamma_ * valueFunc_[nextState_2]));
                if (tmpValue > maxValue) {
                    maxValue = tmpValue;
                    policy_[s-1] = a;
                }
            }
        }
    }

private:
    const unsigned target_;
    const double ph_;
    const double theta_;
    const double gamma_;
    std::vector<double> valueFunc_;
    std::vector<unsigned> policy_;
};

#endif // CASINO_H

main.cpp

#include <iostream>
#include "Casino.hpp"

using namespace std;

int main()
{
    const unsigned target = 100;
    const double ph = 0.4;

    Casino casino(target, ph);

    const auto valueFunc = casino.ValueFunction();
    cout << "value function:\n";
    for (const auto& i : valueFunc)
        cout << i << ", ";

    const auto policy = casino.Policy();
    cout << "\npolicy:\n";
    for (const auto& i : policy)
        cout << i << ", ";
}

可视化后的结果：

参考

《Reinforcement Learning An Introduction》(second edition)