【动手学强化学习】part2-动态规划算法

阐述、总结【动手学强化学习】章节内容的学习情况，复现并理解代码。

---

一、什么是动态规划？

1.1概念

**动态规划（dynamic programming）**是程序设计算法中非常重要的内容，能够高效解决一些经典问题，例如背包问题和最短路径规划。动态规划的基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到目标问题的解。动态规划会保存已解决的子问题的答案，在求解目标问题的过程中，需要这些子问题答案时就可以直接利用，避免重复计算。

基于动态规划的强化学习算法主要有两种：一是策略迭代（policy iteration），二是价值迭代（value iteration）。

1.2适用条件

需要“白盒”环境（model-based）！！！基于动态规划的这两种强化学习算法要求事先知道环境的状态转移函数和奖励函数，也就是需要知道整个马尔可夫决策过程。策略迭代和价值迭代通常只适用于有限马尔可夫决策过程，即状态空间和动作空间是离散且有限的。

二、算法示例

2.1问题建模

CliffWalking悬崖漫步环境

• 目标：要求一个智能体从起点出发，避开悬崖行走，最终到达目标位置。
  

根据MDP过程进行建模：

• 状态空间：4×12 的网格世界，每一个网格表示一个状态。起点是左下角的状态，目标是右下角的状态。
• 动作空间：可以采取 4 种动作：上、下、左、右。
• 折扣因子：取0.9。
• 奖励函数：智能体采取动作后触碰到边界墙壁则状态不发生改变，否则就会相应到达下一个状态。环境中有一段悬崖，智能体掉入悬崖或
  到达目标状态都会结束动作并回到起点，也就是说掉入悬崖或者达到目标状态是终止状态。智能体每走一步的奖励是 −1，掉入悬崖的奖励是−100。
• 状态转移函数：

2.2策略迭代（policyiteration）算法

• 🌟算法类型
  环境依赖：✅model-based ❌model-free
  价值估计：❌non-incremental ❌incremental（基于环境模型直接估计）
  学习方式：❌on-policy ❌off-policy（有环境模型，不需要与环境交互采样）
  价值表征：✅tabular representation ❌function representation
  策略表征：✅value-based ❌policy-based

2.2.1伪代码

• 算法流程简述：
  ①初始化：根据环境，初始化各state的state value，一般设置为0；policy同时也初始化，一般设置为每个state选取各action的概率相等
  ②价值评估（policy evaluation，PE）：循环迭代计算，毕竟当前policy下稳态state value
  ③策略提升（policy improvement）：依据当前statevalue值，根据环境模型（$p(r|s,a)$、$p(s^{\prime }|s,a)$）计算各(s,a)对action value，并以greedy policy策略将各state中action value最大的值进行policy优化
  ④终止判断：判断最近两次policy是否相等，若是则停止算法输出policy，若否则重复执行②③步。

2.2.2完整代码

# =============================================================================
# 
# 悬崖漫步是一个非常经典的强化学习环境，它要求一个智能体从起点出发，避开悬崖行走，最终到达目标位置。
# state:如图 4-1 所示，有一个 4×12 的网格世界，每一个网格表示一个状态,智能体的起点是左下角的状态，目标是右下角的状态.
# action:智能体在每一个状态都可以采取 4 种动作：上、下、左、右。
# goal:如果智能体采取动作后触碰到边界墙壁则状态不发生改变，否则就会相应到达下一个状态。环境中有一段悬崖，智能体掉入悬崖或
# 到达目标状态都会结束动作并回到起点，也就是说掉入悬崖或者达到目标状态是终止状态。
# reward:智能体每走一步的奖励是 −1，掉入悬崖的奖励是−100。
# =============================================================================

import copy


class CliffWalkingEnv:
    """ 悬崖漫步环境"""
    def __init__(self, ncol=12, nrow=4):
        self.ncol = ncol  # 定义网格世界的列
        self.nrow = nrow  # 定义网格世界的行
        # 转移矩阵P[state][action] = [(p, next_state, reward, done)]包含下一个状态和奖励
        self.P = self.createP()

    def createP(self):
        
# =============================================================================
#         转移矩阵P[s][a] = [(p, next_state, reward, done)]包含下一个状态和奖励
#         p:s到next_state的状态转移概率，在这里都取1
#         reward:s到next_state的即时奖励
#         done：是否到达终点或悬崖
# =============================================================================
        
        # 初始化
        P = [[[] for j in range(4)] for i in range(self.nrow * self.ncol)]
        # 4种动作, change[0]:上,change[1]:下, change[2]:左, change[3]:右。坐标系原点(0,0)
        # 定义在左上角
        change = [[0, -1], [0, 1], [-1, 0], [1, 0]]
        for i in range(self.nrow):
            for j in range(self.ncol):
                for a in range(4):
                    # 位置在悬崖或者目标状态,因为无法继续交互,任何动作奖励都为0
                    if i == self.nrow - 1 and j > 0:
                        # 除了4行1列的元素的done状态都设置为True，其都为悬崖，除4行12列为终点
                        P[i * self.ncol + j][a] = [(1, i * self.ncol + j, 0,
                                                    True)]
                        continue
                    # 其他位置
                    next_x = min(self.ncol - 1, max(0, j + change[a][0]))
                    next_y = min(self.nrow - 1, max(0, i + change[a][1]))
                    next_state = next_y * self.ncol + next_x
                    reward = -1
                    done = False
                    # 下一个位置在悬崖或者终点
                    if next_y == self.nrow - 1 and next_x > 0:
                        done = True
                        if next_x != self.ncol - 1:  # 下一个位置在悬崖
                            reward = -100
                    P[i * self.ncol + j][a] = [(1, next_state, reward, done)]
        return P
    
class PolicyIteration:
    """ 策略迭代算法 """
    def __init__(self, env, theta, gamma):
        self.env = env
        self.v = [0] * self.env.ncol * self.env.nrow  # 初始化价值为0
        #🌟初始策略是均匀分布的
        self.pi = [[0.25, 0.25, 0.25, 0.25]
                   for i in range(self.env.ncol * self.env.nrow)]  # 初始化为均匀随机策略
        self.theta = theta  # 策略评估收敛阈值
        self.gamma = gamma  # 折扣因子

    def policy_evaluation(self):  # 策略评估
        cnt = 1  # 计数器
        while 1:
            max_diff = 0
            new_v = [0] * self.env.ncol * self.env.nrow
            for s in range(self.env.ncol * self.env.nrow):
                qsa_list = []  # 开始计算状态s下的所有Q(s,a)价值。4x12各state，4个action
                for a in range(4):
                    qsa = 0
                    for res in self.env.P[s][a]:
                        p, next_state, r, done = res
                        # 🌟这里在计算action value
                        qsa += p * (r + self.gamma * self.v[next_state] * (1 - done))
                        # 本章环境比较特殊,奖励和下一个状态有关,所以需要和状态转移概率相乘
                    qsa_list.append(self.pi[s][a] * qsa)
                # 🌟这里更新state value
                new_v[s] = sum(qsa_list)  # 状态价值函数和动作价值函数之间的关系
                max_diff = max(max_diff, abs(new_v[s] - self.v[s])) #这里判断阈值是否继续进行迭代