第七篇：强化学习策略迭代 代码实现

你好，我是郭震(zhenguo)

今天介绍强化学习第7篇：强化学习策略迭代代码实现

首先，我们导入包：

import numpy as np

其次，定义迷宫状态空间大小，在这里是9个空格，所以状态数9。

动作空间大小，最多为4个，上、下、左、右

num_states = 9
num_actions = 4

定义迷宫的奖励矩阵，它是二维数组，维度含义：[num_states][num_actions]

rewards = np.array([
    [-1, -1, -1, -1],
    [-1, 0, -1, 1],
    [-1, -1, -1, -1],
    [1, -1, -1, -1],
    [-1, -1, -1, -1],
    [-1, 0, -1, 1],
    [-1, -1, -1, -1],
    [-1, 0, -1, 1],
    [-1, 1, -1, 1],
])

接下来，初始化策略和值函数：

policy = np.ones((num_states, num_actions)) / num_actions
values = np.zeros(num_states)

策略迭代两步：

• 1）策略评估函数

• 2）策略改进

迭代第一步：策略评估

主要就是更新values，核心一行代码下面：

v += policy[s][a] * (rewards[s][a] + values[next_state])

这是贝尔曼方程！贝尔曼方程是动态规划和强化学习中的基本方程，由Richard Bellman提出。

贝尔曼方程表达了状态或状态-动作对的值与按照特定策略获得的预期回报之间的关系。

贝尔曼方程的一般形式如下：

其中， 表示状态 的值函数，即按照某个策略获得的预期回报。 表示选择能够使得值最大化的动作 。 表示对所有可能的下一个状态 和奖励 进行求和。 表示在状态 下执行动作 后转移到状态 且获得奖励 的概率。 是折扣因子，用于平衡当前和未来的奖励。

通过求解贝尔曼方程，我们可以计算出每个状态的值函数 ，从而确定最优策略。

# 
def policy_evaluation():
    global values
    delta = 1e-6  # 停止迭代的阈值
    max_iterations = 1000  # 最大迭代次数
    for _ in range(max_iterations):
        new_values = np.zeros(num_states)
        for s in range(num_states):
            v = 0
            for a in range(num_actions):
                next_state = get_next_state(s, a)  # 获取下一个状态
                v += policy[s][a] * (rewards[s][a] + values[next_state])
            new_values[s] = v
        if np.max(np.abs(new_values - values)) < delta:
            break
        values = new_values

定义获取下一个状态的函数:

def get_next_state(state, action):
    if state == 1 and action == 3:
        return 3
    elif state == 3 and action == 0:
        return 1
    else:
        return state

迭代第二步：策略改进

主要更新策略 policy 数组

# 定义策略改进函数
def policy_improvement():
    global policy
    for s in range(num_states):
        q_values = np.zeros(num_actions)
        for a in range(num_actions):
            next_state = get_next_state(s, a)  # 获取下一个状态
            q_values[a] = rewards[s][a] + values[next_state]
        best_action = np.argmax(q_values)
        new_policy = np.zeros(num_actions)
        new_policy[best_action] = 1
        policy[s] = new_policy

联合以上两步就得到策略迭代算法。

# 策略迭代算法
def policy_iteration():
    max_iterations = 30  # 最大迭代次数
    for _ in range(max_iterations):
        policy_evaluation()  # 策略评估
        policy_improvement()  # 策略改进

感谢你的点赞和转发，让我更新更有动力