[RL]策略梯度REINFORCE

我思故我在Fighting

于 2024-02-13 23:12:14 发布

阅读量759

点赞数 19

文章标签：人工智能神经网络 python

本文链接：https://blog.csdn.net/qq_61897765/article/details/136110231

版权

(摘自李宏毅EasyRL)
DQN 是基于价值（value-based）的方法，我们今天要说的是基于策略（policy-based）的方法。对比两者，基于值函数的方法主要是学习值函数，然后根据值函数导出一个策略，学习过程中并不存在一个显式的策略；而基于策略的方法则是直接显式地学习一个目标策略。策略梯度是基于策略的方法的基础，本节从策略梯度算法说起。

一、策略梯度算法

智能体在Video Game中，Actor：摇杆，【向左、向右、开火】；Env(游戏的主机):【控制游戏的画面、负责控制怪兽的移动】；reward（得到多少分数）：【打败一只怪兽得到 20 分】。围棋（GO），Actor—— Alpha Go，决定棋子落在哪；Env——对手；Reward Function——围棋的规则
在这里插入图片描述

在强化学习里， Env与Reward Function在开始学习之前给定,我们只需要调整Actor里的策略Policy，使得Actor得到最大Reward。Actor里面的Policy决定了Actor的Action，（给定一个输入，输出Actor要执行的Action）

策略 π：用深度学习来做强化学习，策略π就可以建模成一个网络。网络参数用 θ 表示，网络的输入：智能体看到的东西【游戏画面（由像素pixels组成）】。用向量vector或矩阵matrix来表示智能体的观测observation。策略网络输出：智能体action，有几个动作，输出层就有几个神经元。
在这里插入图片描述

例子：假设可执行action有 3 个，输出层就有 3 个神经元，一一对应。输入一个观测observation后，网络给每个action一个分数。可以把这个分数当作概率，Actor根据概率分布来决定action。

例子Playing Video Game

首先Actor看到Video Game的初始画面s1，根据内部的网络（policy）来决定action。假设a1是right，执行之后会得到reward，会看到一个新的游戏画面 s2。把 s2 输入给Actor，Actor决定执行fire，它杀了一只alien，就得到五分。这个过程反复地持续，直到飞船被毁或是把所有的怪兽都清空，游戏就结束了。
在这里插入图片描述

一场游戏——一个回合。这场游戏所有reward都加起来，就是总奖励（total reward），也就是回报R ，Actor目标：最大化total reward。
在这里插入图片描述

Actor, Environment, Reward

首先，Env是一个函数，一开始先“吐”出一个状态（游戏画面 s1），Actor看到游戏画面 s1 以后，它“吐”出动作 a1。Env把动作 a1 当作输入，再“吐”出新的游戏画面 s2。Actor看到新的游戏画面 s2，再采取新的动作 a2 … 这个过程一直持续下去到Env觉得应该停止。在一场游戏里，把Env输出的 s 与Actor输出的动作 a 全部组合起来，就是一个轨迹，即Trajectory τ = {s1, a1, s2, a2, · · · , st , at}
在这里插入图片描述

给定Actor的参数 θ，可以计算某个Trajectoryτ 发生的概率为 $p_θ (τ)$

Env输出 s1 的概率 p(s1)，根据 s1 执行 a1 的概率 pθ (a1|s1) 由策略里面的网络参数 θ 决定。策略网络的输出是一个分布，Actor根据这个分布进行采样出action。接下来Env根据 a1 与 s1 产生 s2，计算一个轨迹 τ 出现的概率有多大。

某个轨迹出现概率取决于Env的动作和Actor的动作。Env的动作是设定好的我们无法控制。我们只能控制 pθ(at |st)。它取决于Actor的参数 θ。

Reward

对奖励函数输入 s1、a1，它会输出 r1；输入 s2、a2，奖励函数会输出 r2。把某一回合轨迹所有的Reward 都加起来，就得到 R(τ ) 。我们要调整Actor内部的参数 θ，使得 R(τ ) 的值越大越好。 R(τ) 是一个随机变量，可以求期望计算Expected Reward

根据 θ 算出轨迹 τ 出现的概率分布，乘以τ 对应的total reward 。从分布 pθ(τ ) 采样一个轨迹 τ，计算 R(τ ) 的期望值。

使用梯度上升（gradient ascent）来最大化期望奖励。先计算期望奖励 $KaTeX parse error: Expected 'EOF', got '̅' at position 3: R ̲̅_θ$ 的梯度。 $KaTeX parse error: Expected 'EOF', got '̅' at position 3: R ̲̅_θ$ 求梯度，
在这里插入图片描述

直观地理解，在采样到的数据里，某一个状态 $s_t$ 要执行某动作 $a_t$ ， $s_t , a_t)$ 是整个轨迹 $τ$ 的里的某一状态动作对。假设在 $s_t$ 执行 $a_t$ 后整个回合 $τ$ 的奖励是正的，就要增加在 $s_t$ 执行 $a_t$ 的概率。反之，在 $s_t$ 执行 $a_t$ 会导致 $τ$ 的奖励为负，就要减少在 $s_t$ 执行 $a_t$ 的概率。

求出期望奖励的梯度方向之后，将参数往梯度方向更新。把 $θ$ 加上梯度 $\nabla R ¯ θ$
在这里插入图片描述

实际上要计算梯度，拿已经训练好的智能体先与环境交互，交互完以后，就可以得到大量游戏的数据，会记录在第一场游戏里面，我们在状态 $s_1$ 采取动作 $a_1$ ，在状态 $s_2$ 采取动作 $a_2$ 。整场游戏结束以后，得到的奖励是 $R(τ _1 )$ 。采样另外一场游戏每个状态动作对，得到的奖励 $R(τ _2 )$ 。

把每一个 $s$ 与 $a$ 的对拿进来，计算在某一个状态下采取某一个动作的对数概率（log probability）对这个概率取梯度，在梯度前面乘一个权重，就是这场游戏的奖励。我们计算出梯度后，就可以更新模型。

更新完模型以后，我们要重新采样数据再更新模型。一般策略梯度（policy gradient，PG）采样的数据只会用一次。我们采样这些数据，然后用这些数据更新参数，再丢掉这些数据。接着重新采样数据，才能去更新参数
在这里插入图片描述

Implementation实现细节

稍微总结一下

基于策略的方法首先需要将策略参数化。假设目标策略是一个随机性策略，可以用一个线性模型或者神经网络模型来为这样一个策略函数建模，把它当作图像分类问题，输入某个状态，然后输出一个动作的概率分布。我们的目标是要寻找一个最优策略并最大化这个策略在环境中的期望回报。

有了目标函数，我们将目标函数对策略求导，得到导数后，就可以用梯度上升方法来最大化这个目标函数，从而得到最优策略。

在 PyTorch 里调用现成的函数来自动计算损失函数，自动求梯度。这是一般的分类问题，强化学习与分类问题唯一不同的地方是损失前面乘一个权重——整场游戏得到的总奖励 $R (τ)$ ，而不是在状态 $s$ 采取动作 $a$ 的时候得到的奖励，即
在这里插入图片描述

把每一笔训练数据，都使用 $R (τ)$ 进行加权。

二、略梯度实现技巧

技巧 1：添加基线

第一个技巧：添加基线（baseline）。理想状态：如果给定状态 $s$ 采取动作 $a$ ，整场游戏得到正的奖励，就要增加 $(s, a)$ 的概率。整场游戏得到负的奖励，就要减小 $(s, a)$ 的概率。

但在很多游戏里面，奖励总是正的，最低都是 $0$ 。所以采样到的不管是好的坏的动作概率都会提升。理想状态是对某个状态有 $a, b, c$ 这三个动作都能被采样到， $R (τ)$ 总是正的，这 3 个动作对数概率都提高。但是它们前面的权重 R(τ ) 有大有小，权重小的概率提高的少；权重大的概率提高的多。因为对数概率是一个概率，所以提高少的，在做完归一化（normalize）以后，动作 $b$ 的概率就是下降的；提高多的，该动作的概率才会上升。
在这里插入图片描述

刚才是理想状态，实际上真正在学习的时候，只是采样了少量的 s 与 $a$ 的对。有一些动作可能从来都没有被采样到。比如在这没有sample到动作 $a$ 。但现在所有动作的奖励都是正的， $b, c$ 概率都要提高，归一化后 $a$ 的概率就要下降。但 $a$ 不一定是一个不好的动作，只是没有被采样到。

通过使奖励不总是正的解决这个问题。可以把奖励减 $b$ ， $b$ 称为基线。可以让 $R (τ) - b$ 这一项有正有负。如果得到的总奖励 $R (τ) > b$ ，就让 $(s, a)$ 的概率上升。如果 $R (τ) < b$ ，说明不是好动作，就让 $(s, a)$ 的概率下降。

$b$ 可以对 $R (τ)$ 的值取期望 $b \approx E [R (τ)]$ 。所以在训练的时候，我们会不断地把 $R (τ)$ 的值记录下来，不断地计算 $R (τ)$ 的平均值，把这个平均值当作 $b$ 来使用。这样就可以让我们在训练的时候， $R (τ) - b$ 是有正有负的。

技巧 2：分配合适的分数

给每一个动作分配合适的分数（credit）。

此前只要在同一个回合里面，所有的状态-动作对就使用同样的奖励项进行加权。这显然是不公平的，因为在同一场游戏里有些动作是好的，有些动作是不好的。假设整场游戏的结果是好的，但并不代表这场游戏里面每一个动作都是好的。得到 +3 不一定代表在 sb 执行 a2 是好的。因为这个正的分数，主要来自在 sa 执行了 a1，和它没关系，也许它反而是不好的，因为它导致接下来进入 sc，执行 a3 被扣分。所以整场游戏得到的结果是好的，不代表每一个动作都是好的。
在这里插入图片描述

在理想的状况下，如果采样数据够多可以解决这个问题。 $s_b, a_2)$ 被采样到很多。某一场游戏里，在 $s_b$ 执行 $a_2$ 得到 +3 分。但在另外一场游戏却得到−7 分因为在 $s_b$ 执行 $a_2$ 之前，在 $s_a$ 执行 $a_2$ 得到 −5 分，−5 分 $s_a, a_2)$ 先发生，与 $s_b, a_2)$ 是没有关系不是它造成的，在 $s_b$ 执行 $a_2$ 只会影响在接下来得到 −2 分。假设采样状态-动作对的次数够多，把所有产生这种情况的分数都集合起来，这可能不是一个问题。但现在采样的次数是不够多，所以要给每一个状态-动作对分配合理的分数，也就是它合理的贡献。

可以在计算某个状态-动作对的奖励的时候，不把整场游戏得到的奖励全部加起来，只计算从这个动作执行以后得到的奖励。之前发生的事情是与执行这个动作是没关系，之前得到的奖励不能算是这个动作的贡献。

在 $s_b$ 执行 $a_2$ 这件事情，也许它真正会导致我们得到的分数应该是 −2 分而不是 +3 分，因为前面的 +5 分并不是执行 $a_2$ 的功劳。同理，第二回合执行 $a_2$ 实际上不应该是扣 7 分，只扣两分而已。

原来的权重是整场游戏的奖励的总和，现在改成从某个时刻 $t$ 开始，假设这个动作是在 $t$ 开始执行的，从 $t$ 一直到游戏结束所有奖励的总和才能代表这个动作的好坏。接下来更进一步，我们把未来的奖励做一个折扣，因为一般的情况下，时间拖得越长，该动作的影响力就越小。

（ $b$ 可以是依赖状态（state-dependent）的，事实上 $b$ 通常是一个网络估计出来的，它是一个网络的输出。） $R − b_4$ 这一项称为优势函数（advantage function） $Aθ (s_t , a_t)$ ，表示某一个状态 $s_t$ 执行某一个动作 $a_t$ ，相较于其他可能的动作， $a t$ 相对来说有多好。

三、REINFORCE：蒙特卡洛策略梯度

蒙特卡洛方法可以理解为算法完成一个回合之后，再利用这个回合的数据去学习，做一次更新。因为已经获得整个回合的数据，所以也能够获得每一个步骤的奖励，我们可以很方便地计算每个步骤的未来总奖励，即回报 Gt 。Gt 是未来总奖励，代表从这个步骤开始，我们能获得的奖励之和。G1 代表我们从第一步开始，往后能够获得的总奖励。G2 代表从第二步开始，往后能够获得的总奖励。相比蒙特卡洛方法一个回合更新一次，时序差分方法是每个步骤更新一次，即每走一步，更新一次，时序差分方法的更新频率更高。时序差分方法使用 Q 函数来近似地表示未来总奖励 Gt。

策略梯度中最经典的一个算法 REINFORCE。REINFORCE 用的是回合更新的方式，算法完成一个回合之后，利用这个回合的数据去学习，计算每个步骤的未来总奖励 $G_t$ ，每个代入，做一次更新。
在这里插入图片描述
主要代码解释

完整代码

import gym
import torch
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm
import warnings
warnings.filterwarnings("ignore",category=DeprecationWarning)

class PolicyNet(torch.nn.Module):
    def __init__(self, state_dim, hidden_dim, action_dim):
        """ 初始化q网络，为全连接网络
            input_dim: 输入的特征数即环境的状态维度
            output_dim: 输出的动作维度
        """
        super(PolicyNet, self).__init__()
        self.fc1 = torch.nn.Linear(state_dim, hidden_dim) # 输入层
        self.fc2 = torch.nn.Linear(hidden_dim,hidden_dim) # 隐藏层
        self.fc3 = torch.nn.Linear(hidden_dim, action_dim) # 输出层
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.softmax(self.fc3(x), dim=1)
        return x

class REINFORCE:
    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma, device, lr_decay_factor=0.9, lr_decay_step=100):

        self.policy_net = PolicyNet(state_dim, hidden_dim,action_dim).to(device)
        self.optimizer = torch.optim.Adam(self.policy_net.parameters(),lr=learning_rate)  # 使用Adam优化器
        self.lr_scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=lr_decay_step, gamma=lr_decay_factor)  # 学习率衰减调度器
        self.gamma = gamma  # 折扣因子
        self.device = device

    def take_action(self, state):  # 根据动作概率分布随机采样
        state = torch.tensor([state], dtype=torch.float).to(self.device)
        probs = self.policy_net(state)
        action_dist = torch.distributions.Categorical(probs)
        action = action_dist.sample()
        return action.item()

    def update(self, transition_dict):
        reward_list = transition_dict['rewards']
        state_list = transition_dict['states']
        action_list = transition_dict['actions']

        G = 0
        self.optimizer.zero_grad()
        for i in reversed(range(len(reward_list))):  # 从最后一步算起
            reward = reward_list[i]
            state = torch.tensor([state_list[i]],dtype=torch.float).to(self.device)
            action = torch.tensor([action_list[i]]).view(-1, 1).to(self.device)
            log_prob = torch.log(self.policy_net(state).gather(1, action))
            G = self.gamma * G + reward
            loss = -log_prob * G  # 每一步的损失函数
            loss.backward()  # 反向传播计算梯度
        self.optimizer.step()  # 梯度下降
        self.lr_scheduler.step()  # 更新学习率

learning_rate = 1e-3
num_episodes = 1000
hidden_dim = 64
gamma = 0.98
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")

env_name = "CartPole-v1"
env = gym.make(env_name)
env.reset(seed=0)
torch.manual_seed(0)
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.n

lr_decay_factor = 0.9  # 学习率衰减因子
lr_decay_step = 50  # 学习率衰减步数

# 创建代理
agent = REINFORCE(state_dim, hidden_dim, action_dim, learning_rate, gamma, device, lr_decay_factor, lr_decay_step)
# print(state_dim,action_dim)
# agent = REINFORCE(state_dim, hidden_dim, action_dim, learning_rate, gamma,device)

return_list = []
for i in range(10):
    with tqdm(total=int(num_episodes / 10), desc='Iteration %d' % i) as pbar:
        pbar.reset()
        for i_episode in range(int(num_episodes / 10)):
            episode_return = 0
            transition_dict = {
                'states': [],
                'actions': [],
                'next_states': [],
                'rewards': [],
                'dones': []
            }
            state = env.reset()
            done = False
            while not done:
                # env.render()
                action = agent.take_action(state)
                next_state, reward, done, _ = env.step(action)
                state_tensor = torch.tensor(state, dtype=torch.float).to(agent.device)
                transition_dict['states'].append(state)
                transition_dict['actions'].append(action)
                transition_dict['next_states'].append(next_state)
                transition_dict['rewards'].append(reward)
                transition_dict['dones'].append(done)
                state = next_state
                episode_return += reward
            return_list.append(episode_return)
            agent.update(transition_dict)
            if (i_episode + 1) % 10 == 0:
                pbar.set_postfix({
                    'episode':
                    '%d' % (num_episodes / 10 * i + i_episode + 1),
                    'return':
                    '%.3f' % np.mean(return_list[-10:])
                })
            pbar.update(1)
    # env.close()

在这里插入图片描述

episodes_list = list(range(len(return_list)))
plt.plot(episodes_list, return_list)
plt.xlabel('Episodes')
plt.ylabel('Returns')
plt.title('REINFORCE on {}'.format(env_name))
plt.show()