安卓 动态生成 格子 交互_强化学习纲要总结2：马尔科夫决策过程和动态规划...

专栏地址：

强化学习日积月累​www.zhihu.com

上节讲到强化学习由下面这3部分组成：

• Policy: agent's behavior function：为了得到action
• Value function: how good is each state or action：为了得到状态和动作的价值
• Model: agent's state representation of the environment：决定了下一个状态

这幅图介绍了Agent和Environment之间的交互，这个交互过程，其实是可以通过马尔科夫决策过程 (MDP)来表示。所以，马尔科夫决策过程 (MDP)是强化学习里面的一个基本框架。

在MDP的假设中，环境是Fully Observable的，即完全可观测的。

那么，再具体介绍MDP之前，先介绍马尔科夫链和马尔科夫奖励过程：

马尔可夫链

可以参考下面的链接：

科技猛兽：你一定从未看过如此通俗易懂的马尔科夫链蒙特卡罗方法(MCMC)解读(上)​zhuanlan.zhihu.com

首先介绍一下马尔可夫链的性质，如果说一个状态转移序列，满足马尔可夫，就是说下一状态只取决于当前状态，和之前的状态都是不相关的。

假如有一个状态历史序列：

当且仅当满足以下条件时，State

是马尔可夫链：

即下一状态仅和当前状态有关。

例子

比如上边这个例子，图中给出了从一个状态到另一个状态（或者保持不变）的概率，这样我们就可以用一个状态转移矩阵来表示。

马尔可夫奖励过程（Markov Reward Process）

马尔可夫奖励过程指的是马尔可夫链加上一个奖励函数。

说白了就是在走每一步时会获得奖励或者惩罚。

还是这个例子，比如到达

有一个+5的奖励，到达

有一个+10的奖励，那奖励R就可以表征为：

这里几个概念定义一下：

Horizon

指的是一个episode里的最大步数。可以理解为单次任务结束用了多少步。

Return

累计折扣收益：

，有种说法是可以等于1。整体来讲是更加重视眼前收益。

Value Function：正式定义一个状态的价值(Present value of future rewards)

是

的期望，指的是从当前状态开始，有可能获得多大的价值。

还是刚才的例子，计算以下Return：

对于轨迹

对于轨迹

对于轨迹

那么怎么计算

呢，可以从

出法，推演很多次取平均，这就是蒙特卡罗方法。之后会讲到。

我们这里采用了具体的推导，利用的是贝尔曼等式。

中间经历了如下转换：

写成矩阵形式就是：

得到：

，可以直接求得

，但是复杂度太大。

因此我们采用迭代的方法：

1. 动态规划 Dynamic Programming
2. 蒙特卡罗方法 Monte-Carlo
3. 时间差分 Temporal-Difference

首先介绍一下蒙特卡罗方法：

这种方法的核心思想就是进行推演，生成大量数据，然后取平均，这其实是一种求期望的方法。

迭代法、动态规划法

感觉这其实就是数值分析中的迭代求解法，把Bellman Equation变成Bellman Update，其利用的假设是

的值稳定时，会收敛到唯一的值。这也是假设了马尔科夫链有平稳分布(实际上大多数强化学习场景都满足)。

马尔可夫决策过程（MDP）

接下来就是重头戏，马尔可夫决策过程。相比于MRP,MDP多了决策，也就是action，这样就形成了五元组

，具体定义如下

Policy在MDP中的定义为：在某一状态

下应该采取哪一个action。

在这里，给定一个policy后，我们就可以把MDP问题转化为MRP问题。因为有了policy，我们就知道状态

下，采取动作

的概率是多少。转移函数和回报函数如下：

这里我们看一下MRP和MDP的区别：

我们可以理解为MRP只有环境，它自己在那推演。MDP中间多了一个决策过程。也就是强化学习要学的。

Value function for MDP

状态值函数在MDP和MRP中的定义类似，只不过是在策略

下的期望。

此处又引入一个动作值函数，指的是在该状态下，采取某一个特定action后的期望收益。

显然，我们可以知道

和

的联系：

根据贝尔曼方程，我们可以得到：

这就是当前状态和未来状态的关联。

我们还可以得到状态值和动作值函数的关系：

两个式子结合，得到去掉期望后当前状态和未来状态的关联：

用以下两个如能比较方便的理解：

这里有两层加和，里面一次加和能从叶子节点backup到黑色的

节点（也就是

值）。外边一层加和能backup到根节点。

动作值函数也一样：

马尔可夫决策的预测和控制，是MDP的核心问题。

1 Prediction

指的是给定一个马尔可夫决策

和一个策略

（或者直接给定

），我们把它的value function

计算出来。

2 Control

指的是寻找一个最佳的策略。他的输入是MDP

，输出是最佳价值函数

和最佳策略

这两个问题可以用 动态规划来解决。

动态规划（Dynamic Programming）指的是先寻找子问题的最佳解，然后再子问题逐步添加，最终得到原始问题的最佳解。由之前的贝尔曼方程可知，MDP可以拆分为一个个子问题。

Policy Iteration

1 Policy evaluation on MDP

是指给定策略

以后，寻找当前策略下的各个状态的value。

贝尔曼方程可以写为：

把贝尔曼方程用作更新

的方法，使用下式更新状态函数，直至收敛。

这是一个经典的Grid World的例子。我们有一个4x4的16宫格。只有左上和右下的格子是终止格子。该位置的价值固定为0，个体如果到达了该2个格子，则停止移动，此后每轮奖励都是0。个体在16宫格其他格的每次移动，得到的即时奖励R都是-1。注意个体每次只能移动一个格子，且只能上下左右4种移动选择，不能斜着走, 如果在边界格往外走，则会直接移动回到之前的边界格。衰减因子我们定义为

。由于这里每次移动，下一格都是固定的，因此所有可行的的状态转化概率P=1。这里给定的策略是随机策略，即每个格子里有25%的概率向周围的4个格子移动。

首先我们初始化所有格子的状态价值为0，如上图k=0的时候。现在我们开始策略迭代了。由于终止格子的价值固定为0，我们可以不将其加入迭代过程。在k=1的时候，我们利用上面的贝尔曼方程先计算第二行第一个格子的价值：

第二行第二个格子的价值是：

其他的格子都是类似的，第一轮的状态价值迭代的结果如上图k=1的时候。现在我们第一轮迭代完了。开始动态规划迭代第二轮了。还是看第二行第一个格子的价值：

第二行格子的价值是：

最终得到的结果是上图k=2的时候。第三轮的迭代如下：

最终得到的结果是上图k=3的时候。就这样一直迭代下去，直到每个格子的策略价值改变很小为止。这时我们就得到了所有格子的基于随机策略的状态价值。

可以看到，动态规划的策略评估计算过程并不复杂，但是如果我们的问题是一个非常复杂的模型的话，这个计算量还是非常大的。

下图为另一个例子不断迭代过程中的可视化结果：

一开始所有状态的价值都是0，前几次迭代开始有一些状态价值不为0，随着迭代的进行，越来越多的状态价值得到更新，直到第6幅图的稳定状态，所有状态的价值趋于稳定。

2 Policy Improvement on MDP

根据第一步 Policy evaluation 我们获得了每个状态的价值，是通过贝尔曼方程不断地迭代，一直到收敛，收敛的结果就是每个状态的价值。这一步我们要根据这些价值找到一个更好的策略，具体做法是：

首先根据值函数我们可以把动作值计算出来：

我们的新策略就是对于所有状态，选择能使

值最大的那个action：

经过argmax重新选择action后，我们新的策略

对应的值函数会大于等于原来的。

在决定这一步的策略

时，我们只是取：

这样取的好处是能够保证：

。

注意上面这式子的含义，即：如果每一步的策略都按照贪心的方式来选择，那么最终的结果是：

证明：这里用

来指代

，用

来指代

。

所以，Policy Iteration其实是两个步骤迭代进行：

1. Policy Evaluation on MDP：Evaluate the policy
   （根据当前的
   计算
   值）
2. Policy Improvement on MDP：根据上一步得到的
   ，利用贪心算法得到新的策略。
   

下图可以比较形象地表示这个循环迭代的过程：

当我们的策略停止提升后，会得到以下等式：

这时MDP到达最佳状态，贝尔曼最优等式得到满足：

这时，

这时我们的贝尔曼最优等式为：

两个式子结合得到：

这个式子提供了

和

求解的一种迭代方法，也是q-learning的原理。

Value Iteration

Policy Iteration需要进行Policy Evaluation 的过程，但是这一过程不要不断地迭代直到状态函数收敛。Value Iteration省去了这一复杂的过程，首先通过一个循环找到最优的价值函数，再直接根据这个最优的价值函数提取出最优的策略。

Policy Iteration和Value Iteration对比

Prediction 的问题需要求出各个状态的价值函数，可以通过Policy Evaluation这一步完成。

Control 的问题需要求出最优策略，有Policy Iteration和Value Iteration这2种方法。

Policy Iteration由Policy Evaluation和Policy Improvement两部分组成。两步交替迭代进行，比较直观。

Value Iteration则是直接利用贝尔曼最优等式迭代求解，最后再有一个policy extraction，由动作值获得最终策略。

如果是Prediction问题，可直接用贝尔曼期望等式迭代求解。

如果是Control问题，可用贝尔曼期望等式+策略迭代更新的方法或直接使用贝尔曼最优等式进行值迭代。

第1种方法Policy Iteration对于上面的例子的可视化结果：

• 一开始所有状态的价值都初始化为0，策略都是随机的(图中的箭头朝向4个方向)

• 执行一次Policy Evaluation和Policy Improvement，分别得到左图和右图。我们发现策略已经有了更新。

• 再执行一次Policy Evaluation和Policy Improvement，分别得到左图和右图。我们发现策略已经有了更新。

• 重复上述过程，最终得到最优策略，如下右图箭头所示：

接着我们看看Policy Iteration的代码：

def policy_iteration(env, gamma = 1.0):
    """ Policy-Iteration algorithm """
    policy = np.random.choice(env.env.nA, size=(env.env.nS))  # initialize a random policy
    max_iterations = 200000
    gamma = 1.0
    for i in range(max_iterations):
        old_policy_v = compute_policy_v(env, policy, gamma)
        new_policy = extract_policy(old_policy_v, gamma)
        if (np.all(policy == new_policy)):
            print ('Policy-Iteration converged at step %d.' %(i+1))
            break
        policy = new_policy
    return policy

我们发现和上面介绍的算法一致，Policy Iteration分为2步：

Policy Evaluation：old_policy_v = compute_policy_v(env, policy, gamma) Policy Improvement：new_policy = extract_policy(old_policy_v, gamma)

def compute_policy_v(env, policy, gamma=1.0):
    """ Iteratively evaluate the value-function under policy.
    Alternatively, we could formulate a set of linear equations in iterms of v[s] 
    and solve them to find the value function.
    """
    v = np.zeros(env.env.nS)
    eps = 1e-10
    while True:
        prev_v = np.copy(v)
        for s in range(env.env.nS):
            policy_a = policy[s]
            v[s] = sum([p * (r + gamma * prev_v[s_]) for p, s_, r, _ in env.env.P[s][policy_a]])
        if (np.sum((np.fabs(prev_v - v))) <= eps):
            # value converged
            break
    return v

这个函数构成Policy Evaluation，通过不断地迭代，返回

。

def extract_policy(v, gamma = 1.0):
    """ Extract the policy given a value-function """
    policy = np.zeros(env.env.nS)
    for s in range(env.env.nS):
        q_sa = np.zeros(env.env.nA)
        for a in range(env.env.nA):
            q_sa[a] = sum([p * (r + gamma * v[s_]) for p, s_, r, _ in  env.env.P[s][a]])
        policy[s] = np.argmax(q_sa)
    return policy

这个函数构成Policy Improvement，更新一步策略。

接着我们看看Value Iteration的源码：

首先通过一个循环找到最优的价值函数，再直接根据这个最优的价值函数提取出最优的策略。

主函数：

if __name__ == '__main__':

    env_name  = 'FrozenLake-v0' # 'FrozenLake8x8-v0'
    env = gym.make(env_name)
    gamma = 1.0
    optimal_v = value_iteration(env, gamma);
    policy = extract_policy(optimal_v, gamma)
    policy_score = evaluate_policy(env, policy, gamma, n=1000)
    print('Policy average score = ', policy_score)

value_iteration只有一个迭代过程，函数如下：

def value_iteration(env, gamma = 1.0):
    """ Value-iteration algorithm """
    v = np.zeros(env.env.nS)  # initialize value-function
    max_iterations = 100000
    eps = 1e-20
    for i in range(max_iterations):
        prev_v = np.copy(v)
        for s in range(env.env.nS):
            q_sa = [sum([p*(r + gamma * prev_v[s_]) for p, s_, r, _ in env.env.P[s][a]]) for a in range(env.env.nA)] 
            v[s] = max(q_sa)
        if (np.sum(np.fabs(prev_v - v)) <= eps):
            print ('Value-iteration converged at iteration# %d.' %(i+1))
            break
    return v

注意这句话

q_sa = [sum([p*(r + gamma * prev_v[s_]) for p, s_, r, _ in env.env.P[s][a]]) for a in range(env.env.nA)] 
v[s] = max(q_sa)

其实是2层循环，它对应的表达式是：

所以value_iteration得到了最优的价值函数。

接下来是同样的extract_policy函数提取最优的策略，在Value Iteration方法中只做一步就行。

def extract_policy(v, gamma = 1.0):
    """ Extract the policy given a value-function """
    policy = np.zeros(env.env.nS)
    for s in range(env.env.nS):
        q_sa = np.zeros(env.action_space.n)
        for a in range(env.action_space.n):
            for next_sr in env.env.P[s][a]:
                # next_sr is a tuple of (probability, next state, reward, done)
                p, s_, r, _ = next_sr
                q_sa[a] += (p * (r + gamma * v[s_]))
        policy[s] = np.argmax(q_sa)
    return policy

next_sr 是一个在

状态下采取动作

时的所有可能的情况，把它们都考虑以后作为动作

的一个评价，遍历所有的动作得到状态

下的最优策略。