Dueling DQN的理论基础及其代码实现【Pytorch + Pendulum-v0】

AlphaGuaGua

已于 2022-11-09 21:13:24 修改

阅读量2.1k

点赞数 4

分类专栏： # Reinforcement Learning 文章标签：深度学习强化学习深度强化学习 DQN

于 2022-07-09 17:59:49 首次发布

本文链接：https://blog.csdn.net/qq_37085158/article/details/125696767

版权

Reinforcement Learning 专栏收录该内容

14 篇文章 8 订阅

订阅专栏

Dueling DQN 理论基础

Dueling DQN是一种基于DQN的改进算法，它的主要突破点在于利用模型结构将值函数表示成更细致的形式，使得模型能够拥有更好的表现。

首先我们可以给出如下公式并定义一个新变量：
$q(s_t,a_t)=v(s_t)+A(s_t+a_t)$
也就是说，基于状态和行动的值函数 $q$ 可以分解成基于状态的值函数 $v$ 和优势函数 $A$ 。由于存在
$E_{a_t}[q(s_t,a_t)]=v(s_t)$
所以如果所有状态行动的值函数不相同，一些状态行动价值 $q (s, a)$ 必然高于状态的价值 $v (s)$ ，当然也会有一些状态行动对低于价值，于是优势函数可以表示出当前行动和平均表现之间的区别：如果由于平均表现，那么优势函数为正，反之则为负。

既然概念上又这样天然的分解，那么在设计模型时就可以考虑采用这样的结构：在保持网络主体结构不变的基础上，将原本网络中的单一输出变成两路输出，一个输出用于输出 $v$ ，它是一个一维标量；另一个输出用于输出 $A$ ，它的维度和行动数量相同，最后将两部分的输出加起来就是原本的 $q$ 值。
改变输出结构后，只需要对模型做很少的改变即可实现功能：模型前面部分可以保持不变，模型后面的部分从一路输出变为两路输出，最后合并为一个结果。

仅仅做这样的分解并不能获得好的效果，因为当 $q$ 值一定时， $v$ 和 $a$ 有无穷种可行的组合（例如，对于同样的 $Q$ 值，如果将 $V$ 值加上任意大小的常数 $C$ ，再将所有 $A$ 值减去 $C$ ，则得到的值依然不变，这就导致了训练的不稳定性。），而实际上只有很小一部分的组合是合乎情理、接近真实数值的。为了解决 $q$ 值和 $v$ 值建模不唯一性的问题，就需要对优势函数 $A$ 做限定。显然 $A$ 函数的期望值为0：
$E_a[A(s_t,a_t)]=E_a(q(s_t,a_t)-v(s_t))=v(s_t)-v(s_t)=0$
那么我们就可以对输出的 $A$ 值进行约束，例如将公式变成：
$q(s_t,a_t)=v(s_t)+(A(s_t,a_t)-\dfrac{1}{|A|}\sum\limits_{a'}A(s_t,a_t'))$
让每一个 $A$ 值减去当前状态下所有 $A$ 值的平均数，就可以保证前面提到的期望值为0的约束，从而增加了 $v$ 和 $A$ 的输出稳定性。

另外一种约束是减去当前状态下的 $A$ 值的最大值。
$q(s_t, a_t)=v(s_t)+(A(s_t,a_t)-\max\limits_{a'}A(s_t,a_t'))$

进行这样的分解有很多好处：

通过这样的分解，不但可以得到给定状态和行动的 $q$ 值，还可以同时得到 $v$ 值和 $A$ 值。这样如果在某些场景需要使用 $v$ 值时，同样可以获得 $v$ 值而不用再训练一个网络。
通过显式地给出 $v$ 函数地输出值，每一次更新时，都会显式地更新 $v$ 函数，这样 $v$ 函数的更新频率就会得到确定性的增加 。
从网络训练的角度来看，原本需要训练 $∣ A ∣$ 个取值为 $[0,\infty]$ 的数值，变成了训练一个取值为 $[0,\infty]$ 的数值和 $∣ A ∣$ 个均值为0，实际取值为 $[- C, C]$ 的数值，对网络训练来说，后者显然是更友好且容易的。
对于一些强化学习的问题来说， $A$ 值得取值范围远比 $v$ 值小，这样将两者分开训练更容易保持行动之间的排列顺序。由于 $A$ 值得数值范围比较小，因此它对模型更新更敏感，这样模型在更新时会更容易考量与其他行动得相对变化量，也就不会因为某一次得更新使得原本得行动排序被意外打破。比如在下面的驾驶车辆游戏中，智能体注意力集中的部位被显示为橙色，当智能体前面没有车时，车辆自身动作并没有太大差异，此时智能体更关注状态价值，而当智能体前面有车时（智能体需要超车），智能体开始关注不同动作优势值的差异。

Dueling DQN 代码实现

Dueling DQN 与 DQN 相比的差异只是在网络结构上，大部分代码依然可以继续沿用。我们定义状态价值函数和优势函数的复合神经网络VAnet。

class Qnet(nn.Module):
    def __init__(self, state_dim, hidden_dim, action_dim):
        super(Qnet, self).__init__()
        self.layer = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, action_dim)
        )

    def forward(self, s):
        s = self.layer(s)
        return s


class VAnet(nn.Module):
    def __init__(self, state_dim, hidden_dim, action_dim):
        super(VAnet, self).__init__()
        self.fc1 = nn.Linear(state_dim, hidden_dim)   # 共享网络部分
        self.fc_A = nn.Linear(hidden_dim, action_dim)
        self.fc_V = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        A = self.fc_A(F.relu(self.fc1(x)))
        V = self.fc_V(F.relu(self.fc1(x)))
        Q = V + A - A.mean(1).view(-1, 1)  # Q值由V值和A值计算得到
        return Q

DQN算法包括Double DQN和Dueling DQN

class DQN:
    def __init__(self, args):
        self.args = args
        self.hidden_dim = args.hidden_size
        self.batch_size = args.batch_size
        self.lr = args.lr
        self.gamma = args.gamma  # 折扣因子
        self.epsilon = args.epsilon  # epsilon-贪婪策略
        self.target_update = args.target_update  # 目标网络更新频率
        self.count = 0  # 计数器,记录更新次数
        self.num_episodes = args.num_episodes
        self.minimal_size = args.minimal_size
        self.dqn_type = args.dqn_type

        self.env = gym.make(args.env_name)

        random.seed(args.seed)
        np.random.seed(args.seed)
        self.env.seed(args.seed)
        torch.manual_seed(args.seed)

        self.replay_buffer = ReplayBuffer(args.buffer_size)

        self.state_dim = self.env.observation_space.shape[0]
        self.action_dim = 11  # 将连续动作分成11个离散动作

        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

        #########################################################################################################
        if self.dqn_type == "DuelingDQN":  # Dueling DQN采取不一样的网络框架
            self.q_net = VAnet(self.state_dim, self.hidden_dim, self.action_dim).to(self.device)
            self.target_q_net = VAnet(self.state_dim, self.hidden_dim, self.action_dim).to(self.device)
        else:
            self.q_net = Qnet(self.state_dim, self.hidden_dim, self.action_dim).to(self.device)
            self.target_q_net = Qnet(self.state_dim, self.hidden_dim, self.action_dim).to(self.device)
        #########################################################################################################

        self.optimizer = Adam(self.q_net.parameters(), lr=self.lr)

    def select_action(self, state):  # epsilon-贪婪策略采取动作
        if np.random.random() < self.epsilon:
            action = np.random.randint(self.action_dim)
        else:
            state = torch.tensor([state], dtype=torch.float).to(self.device)
            action = self.q_net(state).argmax().item()
        return action

    def max_q_value(self, state):
        state = torch.tensor([state], dtype=torch.float).to(self.device)
        return self.q_net(state).max().item()

    def update(self, transition):
        states = torch.tensor(transition["states"], dtype=torch.float).to(self.device)
        actions = torch.tensor(transition["actions"]).view(-1, 1).to(self.device)
        rewards = torch.tensor(transition["rewards"], dtype=torch.float).view(-1, 1).to(self.device)
        next_states = torch.tensor(transition["next_states"], dtype=torch.float).to(self.device)
        dones = torch.tensor(transition["dones"], dtype=torch.float).view(-1, 1).to(self.device)

        q_values = self.q_net(states).gather(1, actions)  # Q value

        # 下个状态的最大Q值
        #########################################################################################################
        if self.dqn_type == 'DoubleDQN':
            max_action = self.q_net(next_states).max(1)[1].view(-1, 1)
            max_next_q_values = self.target_q_net(next_states).gather(1, max_action)
        else:  # DQN
            max_next_q_values = self.target_q_net(next_states).max(1)[0].view(-1, 1)
        #########################################################################################################

        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones)  # TD error

        loss = torch.mean(F.mse_loss(q_values, q_targets))  # 均方误差损失函数
        self.optimizer.zero_grad()  # PyTorch中默认梯度会累积,这里需要显式将梯度置为0
        loss.backward()  # 反向传播更新参数
        self.optimizer.step()

        if self.count % self.target_update == 0:
            self.target_q_net.load_state_dict(self.q_net.state_dict())  # 更新目标网络

        self.count += 1

    def train_DQN(self):
        return_list = []
        max_q_value_list = []
        max_q_value = 0
        for i in range(10):
            with tqdm(total=int(self.num_episodes / 10), desc=f'Iteration {i}') as pbar:
                for episode in range(self.num_episodes // 10):
                    episode_return = 0
                    state = self.env.reset()
                    while True:
                        action = self.select_action(state)
                        max_q_value = self.max_q_value(state) * 0.005 + max_q_value * 0.995  # 平滑处理
                        max_q_value_list.append(max_q_value)  # 保存每个状态的最大Q值

                        action_continuous = dis_to_con(action, self.env, self.action_dim)
                        next_state, reward, done, _ = self.env.step([action_continuous])

                        self.replay_buffer.add(state, action, reward, next_state, done)

                        if self.replay_buffer.size() > self.minimal_size:
                            s, a, r, s_, d = self.replay_buffer.sample(self.batch_size)
                            transitions = {"states": s, "actions": a, "rewards": r, "next_states": s_, "dones": d}
                            self.update(transitions)

                        state = next_state
                        episode_return += reward

                        if done: break

                    return_list.append(episode_return)
                    if (episode + 1) % 10 == 0:
                        pbar.set_postfix(
                            {
                                "episode": f"{self.num_episodes / 10 * i + episode + 1}",
                                "return": f"{np.mean(return_list[-10:]):3f}"
                            }
                        )
                    pbar.update(1)
        return return_list, max_q_value_list

代码运行结果

根据代码运行结果我们可以发现，相比于传统的 DQN，Dueling DQN 在多个动作选择下的学习更加稳定，得到的回报最大值也更大。由 Dueling DQN 的原理可知，随着动作空间的增大，Dueling DQN 相比于 DQN 的优势更为明显。

总的来说，Dueling DQN 能够很好地学习到不同动作的差异性，在动作空间较大的环境下非常有效。

$\quad$
$\quad$
$\quad$

参考：

《动手学强化学习》
《强化学习精要》

$\quad$
$\quad$
$\quad$
持续更新~有错误的话敬请指正!

AlphaGuaGua

关注

4
点赞
踩
13

收藏

觉得还不错? 一键收藏
打赏
1
评论
Dueling DQN的理论基础及其代码实现【Pytorch + Pendulum-v0】

Dueling DQN是一种基于DQN的改进算法，它的主要突破点在于利用模型结构将值函数表示成更细致的形式，使得模型能够拥有更好的表现。本文详细讲解了DuelingDQN的理论基础以及代码实现。
复制链接

扫一扫