强化学习------Actor-Critic(A2C)算法(附pytorch代码)_a2c 代码

一、前言

Actor-Critic算法是一种基于策略梯度（Policy Gradient）和价值函数（Value Function）的强化学习方法，通常被用于解决连续动作空间和高维状态空间下的强化学习问题。该算法将一个Actor网络和一个Critic网络组合在一起，通过Actor网络产生动作，并通过Critic网络估计状态值函数或状态-动作值函数，最终通过策略梯度算法训练Actor网络和Critic网络。Actor-Critic算法的优点是在处理大型状态空间时具有较高的效率和可扩展性。

二、算法原理

Actor-Critic算法中的Actor网络用于学习策略，用于生成动作。Critic网络则用于学习值函数，用于评估状态或状态动作对的价值。Actor和Critic网络之间的交互便是Actor-Critic算法的核心机制。
Actor-Critic算法中，我们有两个更新任务：Actor网络的策略梯度更新和Critic网络的值函数更新。

在Actor-Critic算法中使用的策略梯度方法是REINFORCE算法，该算法的公式如下：

${\nabla }_{\theta }J(\theta )=E_t[{\nabla }_{\theta }log\pi (a_t\mid s_t)(Q^{\pi }(s_t,a_t)-b_t)]$

其中$J(\theta )$表示目标策略的性能，${\nabla }_{\theta }J(\theta )$表示策略梯度，$\pi (a_t\mid s_t)$表示在状态$s_t$ 下选择动作$a_t$ 的概率。

虽然REINFORCE算法在Actor-Critic算法中被广泛使用，但它存在两个问题***：高方差和计算效率低***。
为了解决这两个问题，我们可以引入一个基准函数$B(s_t)$,并将奖励$Q^{\pi }(s_t,a_t)-B(s_t)$作为更新中的优势函数$A^{\pi }(s_t,a_t)$ ，公式变为：

${\nabla }_{\theta }J(\theta )=E_t[{\nabla }_{\theta }log\pi (a_t\mid s_t)A^{\pi }(s_t,a_t)]$

其中，$A^{\pi }(s_t,a_t)=Q^{\pi }(s_t,a_t)-B(s_t)$表示相对于基准函数的优势函数。

参数化的值函数可以通过状态价值函数V(s)或动作价值函数Q(s,a)来表示，取决于我们需要估计的是状态价值函数还是状态-动作价值函数。对于Critic网络的值函数更新，我们可以使用TD误差来计算当前状态值和下一时刻状态值之间的误差：

$\delta =r+\gamma V(s^{\prime })-V(s)$

其中r是当前时刻的奖励，γ是折扣因子，$V(s^{\prime })$是下一时刻的状态值，$V(s)$是当前时刻的状态值。

我们可以使用每个状态s的TD(Temporal Difference)误差$\delta$的平方来衡量当前值函数$V(s)$的误差，并用该误差更新Critic网络的参数。

整体算法流程如下：

三、算法代码

伪代码如下：

算法代码如下：

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from torch.distributions import Categorical


class Actor(nn.Module):
    '''
    演员Actor网络
    '''
    def __init__(self, action_dim, state_dim):
        super(Actor, self).__init__()
        self.fc1 = nn.Linear(state_dim, 300)
        self.fc2 = nn.Linear(300, action_dim)

        self.ln = nn.LayerNorm(300)

    def forward(self, s):
        if isinstance(s, np.ndarray):
            s = torch.FloatTensor(s)
        x = self.ln(F.relu(self.fc1(s)))
        out = F.softmax(self.fc2(x), dim=-1)

        return out


class Critic(nn.Module):
    '''
    评论家Critic网络
    '''
    def __init__(self, state_dim):
        super(Critic, self).__init__()
        self.fc1 = nn.Linear(state_dim, 300)
        self.fc2 = nn.Linear(300, 1)

        self.ln = nn.LayerNorm(300)

    def forward(self, s):
        if isinstance(s, np.ndarray):
            s = torch.FloatTensor(s)
        x = self.ln(F.relu(self.fc1(s)))
        out = self.fc2(x)

        return out


class Actor_Critic:
    def __init__(self, env):
        self.gamma = 0.99
        self.lr_a = 3e-4
        self.lr_c = 5e-4

        self.env = env
        self.action_dim = self.env.action_space.n             #获取描述行动的数据维度
        self.state_dim = self.env.observation_space.shape[0]  #获取描述环境的数据维度

        self.actor = Actor(self.action_dim, self.state_dim)   #创建演员网络
        self.critic = Critic(self.state_dim)                  #创建评论家网络

        self.actor_optim = torch.optim.Adam(self.actor.parameters(), lr=self.lr_a)
        self.critic_optim = torch.optim.Adam(self.critic.parameters(), lr=self.lr_c)

        self.loss = nn.MSELoss()

    def get_action(self, s):
        a = self.actor(s)
        dist = Categorical(a)
        action = dist.sample()             #可采取的action
        log_prob = dist.log_prob(action)   #每种action的概率

        return action.detach().numpy(), log_prob

    def learn(self, log_prob, s, s_, rew):
        #使用Critic网络估计状态值
        v = self.critic(s)
        v_ = self.critic(s_)

        critic_loss = self.loss(self.gamma * v_ + rew, v)
        self.critic_optim.zero_grad()
        critic_loss.backward()
        self.critic_optim.step()

        td = self.gamma * v_ + rew - v          #计算TD误差
        loss_actor = -log_prob * td.detach()
        self.actor_optim.zero_grad()
        loss_actor.backward()
        self.actor_optim.step()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

四、训练示例

我们将以OpenAI Gym中的CartPole（倒立摆）游戏为应用场景，基于pytorch实现一个基础的Actor-Critic算法，让算法去玩这个游戏。
程序共分为两个文件：

• train.py文件：主要负责调用算法实现整体功能
• model.py文件：主要实现一个完整的Actor-Critic算法（上面的代码）

train.py代码如下：

import gym
from model import Actor_Critic
import matplotlib.pyplot as plt


if __name__ == "__main__":
    env = gym.make('CartPole-v0')
    model = Actor_Critic(env)  #实例化Actor_Critic算法类
    reward = []
    for episode in range(200):
        s = env.reset()  #获取环境状态
        env.render()     #界面可视化
        done = False     #记录当前回合游戏是否结束
        ep_r = 0
        while not done:
            # 通过Actor_Critic算法对当前环境做出行动
            a,log_prob = model.get_action(s)

            # 获得在做出a行动后的最新环境
            s_,rew,done,_  = env.step(a)

            #计算当前reward
            ep_r += rew

            #训练模型
            model.learn(log_prob,s,s_,rew)

            #更新环境
            s = s_
        reward.append(ep_r)
        print(f"episode:{episode} ep_r:{ep_r}")
    plt.plot(reward)
    plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

训练效果如下：