【强化学习】11 —— Double DQN算法与Dueling DQN算法

Q-learning中的过高估计

普通的 DQN 算法通常会导致对值的过高估计（overestimation）。传统 DQN 优化的 TD 误差目标为$$r+\gamma \underset{a^{\prime }}{\max }{Q}_{{\omega }^{-}}\left(s^{\prime },a^{\prime }\right)$$
其中${\max }_{a^{\prime }}{Q}_{{\omega }^{-}}\left(s^{\prime },a^{\prime }\right)$可以变为这种形式$$Q_{{\omega }^{-}}\left(s^{\prime },\arg \underset{a^{\prime }}{\max }{Q}_{{\omega }^{-}}\left(s^{\prime },a^{\prime }\right)\right)$$即$max$操作实际可以被拆解为两部分：首先选取状态$s^{\prime }$下的最优动作$a^{\ast }=\arg {\max }_{a^{\prime }}{Q}_{{\omega }^{-}}\left(s^{\prime },a^{\prime }\right)$，接着计算该动作对应的价值$Q_{{\omega }^{-}}\left(s^{\prime },a^{\ast }\right)$。但$max$ 操作使得 𝑄 函数的值越来越大，甚至高于真实值。原因如下：假设有随机变量 $X_1$, $X_2$，取$max$之后的期望大于等于先取期望再取$max$操作，$$\mathbb{E}[\max (X_1,X_2)]\ge \max (\mathbb{E}[X_1],\mathbb{E}[X_2])$$𝑄 函数的值被视作在状态 𝑠′，动作 𝑎′ 下的回报期望值。于是有$$\begin{array}{rl}\underset{a^{\prime }\in A}{\max }{Q}_{{\theta }^{\prime }}(s_{t+1},a^{\prime })& =Q_{{\theta }^{\prime }}(s_{t+1},\arg \underset{a^{\prime }}{\max }{Q}_{{\theta }^{\prime }}(s_{t+1},a^{\prime }))\\ & =\mathbb{E}[R|s_{t+1},\arg \underset{a^{\prime }}{\max }{Q}_{{\theta }^{\prime }}(s_{t+1},a^{\prime }),{\theta }^{\prime }]\\ & \ge \max (\mathbb{E}[R|s_{t+1},a_1,{\theta }^{\prime }],\mathbb{E}[R|s_{t+1},a_2,{\theta }^{\prime }],\cdots ),a_i\in A\end{array}$$
举个例子：
如图所示，x轴为状态，有10个候选行动；左列紫线是真实价值函数，绿点是训练数据点，绿线是拟合的价值函数。中间黑色虚线是取最大值后的估计。可以看到由于数据点的分布，使得拟合出的价值函数无法与真实的价值函数吻合，甚至在部分区域产生了明显的偏差。’

此外，Q函数的过高估计程度随着候选行动数量增大变得更严重.下图中𝑄′函数是另一组独立训练的价值函数。可以看到红色部分的误差明显大于蓝色。

Double DQN

为了解决这一问题，Double DQN 算法提出利用两个独立训练的神经网络估算${\max }_{a^{\prime }}{Q}_{\ast }\left(s^{\prime },a^{\prime }\right)$。具体做法是将原有的$Q_{{\omega }^{-}}\left(s^{\prime },\arg {\max }_{a^{\prime }}{Q}_{{\omega }^{-}}\left(s^{\prime },a^{\prime }\right)\right)$更改为$Q_{{\omega }^{-}}\left(s^{\prime },\arg {\max }_{a^{\prime }}{Q}_{\omega }\left(s^{\prime },a^{\prime }\right)\right)$，即利用一套神经网络$Q_{\omega }$的输出选取价值最大的动作，但在使用该动作的价值时，用另一套神经网络$Q_{{\omega }^{-}}$计算该动作的价值。这样，即使其中一套神经网络的某个动作存在比较严重的过高估计问题，由于另一套神经网络的存在，这个动作最终使用的值不会存在很大的过高估计问题。

在传统的 DQN 算法中，本来就存在两套$Q$函数的神经网络——目标网络和训练网络，只不过$Q_{{\omega }^{-}}\left(s^{\prime },\arg {\max }_{a^{\prime }}{Q}_{{\omega }^{-}}\left(s^{\prime },a^{\prime }\right)\right)$的计算只用到了其中的目标网络，那么我们恰好可以直接将训练网络作为 Double DQN 算法中的第一套神经网络来选取动作，将目标网络作为第二套神经网络计算值，这便是 Double DQN 的主要思想。由于在 DQN 算法中将训练网络的参数记为$\omega$，将目标网络的参数记为${\omega }^{-}$，这与本节中 Double DQN 的两套神经网络的参数是统一的，因此，我们可以直接写出如下 Double DQN 的优化目标：$$r+\gamma Q_{{\omega }^{-}}\left(s^{\prime },\arg \underset{a^{\prime }}{\max }{Q}_{\omega }\left(s^{\prime },a^{\prime }\right)\right)$$

Double DQN代码实践

Pendulum环境

Pendulum环境文档
本节采用的环境是倒立摆（Inverted Pendulum），该环境下有一个处于随机位置的倒立摆。环境的状态包括倒立摆角度的正弦值$sin\theta$，余弦值$cos\theta$，角速度$\dot{\theta }$；动作为对倒立摆施加的力矩$\tau$.每一步都会根据当前倒立摆的状态的好坏给予智能体不同的奖励，该环境的奖励函数为$r=-(thet{a}^2+0.1\ast thet{a}_d{t}^2+0.001\ast torqu{e}^2)$.倒立摆向上保持直立不动时奖励为 0，倒立摆在其他位置时奖励为负数(最大回报为零,倒立摆是垂直的，速度为零，没有施加扭矩)。环境本身没有终止状态，运行 200 步后游戏自动结束。

Pendulum环境的状态空间

标号	名称	最小值	最大值
0	x = cos(theta)	-1.0	1.0
1	y = sin(theta)	-1.0	1.0
2	Angular Velocity	-8.0	8.0

Pendulum环境的动作空间

标号	名称	最小值	最大值
0	力矩	-2.0	2.0

力矩大小是在$[-2,2]$范围内的连续值。为了能够应用 DQN，我们需要采用离散化动作的技巧。例如，下面的代码将连续的动作空间离散为 11 个动作。动作$[0,1,2,\dots ,9,10]$分别代表力矩为$[-2,-1.6,-1.2,\dots ,1.2,1.6,2.0]$。

代码

PS:
torch.max()[0]， 只返回最大值的每个数
troch.max()[1]， 只返回最大值的每个索引

class DQN:
    ''' DQN算法 '''
    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,
                 epsilon, target_update_rate, device, numOfEpisodes, env,
                 buffer_size, minimal_size, batch_size, DQNtype="DQN"):
        self.action_dim = action_dim
        # Q网络
        self.q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)
        # 目标网络
        self.target_q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)
        # 使用Adam优化器
        self.optimizer = torch.optim.Adam(self.q_net.parameters(),
                                          lr=learning_rate)
        self.gamma = gamma
        self.epsilon = epsilon
        # 目标网络更新频率
        self.target_update_rate = target_update_rate
        # 计数器,记录更新次数
        self.count = 0
        self.device = device
        self.numOfEpisodes = numOfEpisodes
        self.env = env
        self.buffer_size = buffer_size
        self.minimal_size = minimal_size
        self.batch_size = batch_size
        self.DQNtype = DQNtype

    # Choose A from S using policy derived from Q (e.g., epsilon-greedy)
    def ChooseAction(self, state):
        if np.random.random() < self.epsilon:
            action = np.random.randint(self.action_dim)
        else:
            state = torch.tensor(np.array([state]), dtype=torch.float).to(self.device)
            action = self.q_net(state).argmax().item()
        return action

    def Update(self, transition_dict):
        states = torch.tensor(transition_dict['states'],
                              dtype=torch.float).to(self.device)
        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(self.device)
        rewards = torch.tensor(transition_dict['rewards'],
                               dtype=torch.float).view(-1, 1).to(self.device)
        next_states = torch.tensor(transition_dict['next_states'],
                                   dtype=torch.float).to(self.device)
        terminateds = torch.tensor(transition_dict['terminateds'],
                                   dtype=torch.float).view(-1, 1).to(self.device)
        truncateds = torch.tensor(transition_dict['truncateds'],
                                   dtype=torch.float).view(-1, 1).to(self.device)
        #Q值
        q_values = self.q_net(states).gather(1, actions)
        # 下个状态的最大Q值
        if self.DQNtype == "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)
        # TD误差目标
        q_targets = rewards + self.gamma * max_next_q_values * (1 - terminateds + truncateds)
        # 均方误差损失函数
        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))
        # PyTorch中默认梯度会累积,这里需要显式将梯度置为0
        self.optimizer.zero_grad()
        # 反向传播更新参数
        dqn_loss.backward()
        self.optimizer.step()

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

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

    # 离散动作转回连续的函数
    def dis_to_con(self, discrete_action, env, action_dim):
        action_lowbound = env.action_space.low[0]
        actoin_upbound = env.action_space.high[0]
        return action_lowbound + (discrete_action / (action_dim - 1)) \
                               * (actoin_upbound - action_lowbound)

    def DQNtrain(self):
        replay_buffer = util.ReplayBuffer(self.buffer_size)
        returnList = []
        max_q_valueList = []
        max_q_value = 0
        for i in range(10):
            with tqdm(total=int(self.numOfEpisodes / 10), desc='Iteration %d' % i) as pbar:
                for episode in range(int(self.numOfEpisodes / 10)):
                    # initialize state
                    state, info = self.env.reset()
                    terminated = False
                    truncated = False
                    episodeReward = 0
                    # Loop for each step of episode:
                    while (not terminated) or (not truncated):
                        action = self.ChooseAction(state)
                        # 平滑处理
                        max_q_value = self.max_q_value(state) * 0.005 + max_q_value * 0.995
                        max_q_valueList.append(max_q_value)
                        action_continuous = self.dis_to_con(action, self.env, self.action_dim)
                        next_state, reward, terminated, truncated, info = self.env.step([action_continuous])
                        replay_buffer.add(state, action, reward, next_state, terminated, truncated)
                        if terminated or truncated:
                            break
                        state = next_state
                        episodeReward += reward
                        # 当buffer数据的数量超过一定值后,才进行Q网络训练
                        if replay_buffer.size() > self.minimal_size:
                            b_s, b_a, b_r, b_ns, b_te, b_tr = replay_buffer.sample(self.batch_size)
                            transition_dict = {
                                'states': b_s,
                                'actions': b_a,
                                'next_states': b_ns,
                                'rewards': b_r,
                                'terminateds': b_te,
                                'truncateds': b_tr
                            }
                            self.Update(transition_dict)
                    returnList.append(episodeReward)
                    if (episode + 1) % 10 == 0:  # 每10条序列打印一下这10条序列的平均回报
                        pbar.set_postfix({
                            'episode':
                                '%d' % (self.numOfEpisodes / 10 * i + episode + 1),
                            'return':
                                '%.3f' % np.mean(returnList[-10:])
                        })
                    pbar.update(1)
        return returnList, max_q_valueList

结果

如图所示,DQN相比DoubleDQN能够获得更多的回报。

如图所示，DQN算法会产生过高估计（超越黄色虚线0），甚至部分Q值超过了10。而DoubleDQN算法则能有效缓解过高估计这一问题。

Dueling DQN

Dueling DQN 是 DQN 另一种的改进算法，它在传统 DQN 的基础上只进行了微小的改动，但却能大幅提升 DQN 的表现。在强化学习中，我们将状态动作价值函数$Q$减去状态价值函数$V$的结果定义为优势函数$A$，即$A(s,a)=Q(s,a)-V(s)$.在同一个状态下，所有动作的优势值之和为 0，因为所有动作的动作价值的期望就是这个状态的状态价值。据此，在 Dueling DQN 中，Q 网络被建模为：$$Q_{\eta ,\alpha ,\beta }(s,a)=V_{\eta ,\alpha }(s)+A_{\eta ,\beta }(s,a)$$
其中，$V_{\eta ,\alpha }(s)$为状态价值函数，而$A_{\eta ,\beta }(s,a)$则为该状态下采取不同动作的优势函数，表示采取不同动作的差异性；$\eta$是状态价值函数和优势函数共享的网络参数，一般用在神经网络中，用来提取特征的前几层；而$\alpha ,\beta$分别为状态价值函数和优势函数的参数。

不同的Advantage聚合形式:

• $$Q_{\eta ,\alpha ,\beta }(s,a)=V_{\eta ,\alpha }(s)+A_{\eta ,\beta }(s,a)-\underset{a^{\prime }}{\max }{A}_{\eta ,\beta }\left(s,a^{\prime }\right)$$
• $$Q_{\eta ,\alpha ,\beta }(s,a)=V_{\eta ,\alpha }(s)+A_{\eta ,\beta }(s,a)-\frac{1}{|\mathcal{A}|}\sum _{a^{\prime }}{A}_{\eta ,\beta }\left(s,a^{\prime }\right)$$

Dueling DQN网络结构

Dueling DQN优点

• 能够处理与动作关联较小的状态
• Dueling DQN 能更高效学习状态价值函数。每一次更新时，$V$函数都会被更新，这也会影响到其他动作的$Q$值。而传统的 DQN 只会更新某个动作的$Q$值，其他动作的$Q$值就不会更新。因此，Dueling DQN 能够更加频繁、准确地学习状态价值函数。

Dueling DQN 代码实践

class VAnet(torch.nn.Module):
    ''' 只有一层隐藏层的A网络和V网络 '''
    def __init__(self, state_dim, hidden_dim, action_dim):
        super(VAnet, self).__init__()
        # 共享网络部分
        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)
        self.fc_A = torch.nn.Linear(hidden_dim, action_dim)
        self.fc_V = torch.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 = A + V - A.mean(1).view(-1, 1)
        return Q

class DQN:
    ''' DQN算法 '''
    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,
                 epsilon, target_update_rate, device, numOfEpisodes, env,
                 buffer_size, minimal_size, batch_size, DQNtype="DQN"):
        self.action_dim = action_dim
        if DQNtype == "DuelingDQN":
            self.q_net = VAnet(state_dim, hidden_dim, self.action_dim).to(device)
            self.target_q_net = VAnet(state_dim, hidden_dim, self.action_dim).to(device)
        else:
            # Q网络
            self.q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)
            # 目标网络
            self.target_q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)
        # 使用Adam优化器
        self.optimizer = torch.optim.Adam(self.q_net.parameters(),
                                          lr=learning_rate)
        self.gamma = gamma
        self.epsilon = epsilon
        # 目标网络更新频率
        self.target_update_rate = target_update_rate
        # 计数器,记录更新次数
        self.count = 0
        self.device = device
        self.numOfEpisodes = numOfEpisodes
        self.env = env
        self.buffer_size = buffer_size
        self.minimal_size = minimal_size
        self.batch_size = batch_size
        self.DQNtype = DQNtype

结果

同样，DQN相比Dueling DQN能够获得更多的回报。

Dueling DQN可以缓解过高估计这一问题。

参考

[1] 伯禹AI
[2] https://www.davidsilver.uk/teaching/
[3] 动手学强化学习
[4] Reinforcement Learning