id="Double%20DQN%20%E7%9A%84%E7%9B%AE%E6%A0%87%20Q%20%E5%80%BC%E8%AE%A1%E7%AE%97%E9%80%BB%E8%BE%91"

name="Double%20DQN%20%E7%9A%84%E7%9B%AE%E6%A0%87%20Q%20%E5%80%BC%E8%AE%A1%E7%AE%97%E9%80%BB%E8%BE%91">Double

DQN

值计算逻辑

分为两步：

1. 选动作：用当前

   网络（q_net）找到下一状态s′下

   src="https://i-blog.csdnimg.cn/direct/1320886df1634a57a9873cba64f87333.png"

   width="86">：

   src="https://i-blog.csdnimg.cn/direct/9a981e5ac25a406c945fca950bf97b98.png"

   width="622">

2. 评价值：用目标

   alt=""

   src="https://i-blog.csdnimg.cn/direct/d8a6405601ae4b56a1bd497a21ad4d13.png"

   值：

   src="https://i-blog.csdnimg.cn/direct/61cbe7133aa74b7a85ee7875b0ecd322.png"

   “分离”

   id="%EF%BC%88%E4%B8%89%EF%BC%89Double%20DQN%20%E4%B8%8E%E5%8E%9F%E5%A7%8B%20DQN%20%E7%9A%84%E6%A0%B8%E5%BF%83%E5%AF%B9%E6%AF%94"

   name="%EF%BC%88%E4%B8%89%EF%BC%89Double%20DQN%20%E4%B8%8E%E5%8E%9F%E5%A7%8B%20DQN%20%E7%9A%84%E6%A0%B8%E5%BF%83%E5%AF%B9%E6%AF%94">（三）Double

   DQN

   的核心对比

   DQN类的update函数是区分两种算法的核心，我把关键代码和原理对应起来，进行讲解：

   id="1.%20%E5%8E%9F%E5%A7%8B%20DQN%20%E7%9A%84%E5%AE%9E%E7%8E%B0%EF%BC%88%E4%BB%A3%E7%A0%81%E7%89%87%E6%AE%B5%EF%BC%89"

   name="1.%20%E5%8E%9F%E5%A7%8B%20DQN%20%E7%9A%84%E5%AE%9E%E7%8E%B0%EF%BC%88%E4%BB%A3%E7%A0%81%E7%89%87%E6%AE%B5%EF%BC%89">1.

   DQN

   self.target_q_net(next_states).max(1)[0].view(-1,

   1)

   • 逻辑：直接从target_q_net（目标网络）中取下一状态的最大

     值，对应公式

     src="https://i-blog.csdnimg.cn/direct/b3b4ab92ed204a6aa65536001f6866e0.png"

     width="344">

   • 问题：目标网络既选动作，又评价值，放大误差。

   id="2.%20Double%20DQN%20%E7%9A%84%E5%AE%9E%E7%8E%B0%EF%BC%88%E4%BB%A3%E7%A0%81%E7%89%87%E6%AE%B5%EF%BC%89"

   name="2.%20Double%20DQN%20%E7%9A%84%E5%AE%9E%E7%8E%B0%EF%BC%88%E4%BB%A3%E7%A0%81%E7%89%87%E6%AE%B5%EF%BC%89">2.

   Double

   self.q_net(next_states).max(1)[1].view(-1,

   self.target_q_net(next_states).gather(1,

   max_action)

   • self.q_net(next_states).max(1)[1]：当前网络（q_net）计算下一状态的所有动作

     值，取最大

     值对应的动作索引（argmax）；

   • target_q_net(...).gather(1,

     max_action)：目标网络（target_q_net）根据当前网络选的动作索引，计算该动作的

     值（而非直接取最大值）；

   • 优势：选动作和评价值的网络分离，避免误差放大。

   id="%EF%BC%88%E5%9B%9B%EF%BC%89Double%20DQN%20%E7%9A%84%E5%AE%8C%E6%95%B4%E6%89%A7%E8%A1%8C%E6%B5%81%E7%A8%8B"

   name="%EF%BC%88%E5%9B%9B%EF%BC%89Double%20DQN%20%E7%9A%84%E5%AE%8C%E6%95%B4%E6%89%A7%E8%A1%8C%E6%B5%81%E7%A8%8B">（四）Double

   DQN

   的完整训练流程如下：

   1. 环境交互：智能体通过take_action函数选择动作（ε-

      贪心策略），与环境交互得到(s,a,r,s′,done)；

   2. 经验存储：将交互数据存入经验回放池ReplayBuffer；
   3. 批量采样：当回放池数据量足够时，采样一批数据；
   4. 更新网络：

      • 计算当前

      src="https://i-blog.csdnimg.cn/direct/ab3a2104156d4cf0b9f856ab4bbc4308.png"

      width="248">（当前网络对

      src="https://i-blog.csdnimg.cn/direct/88e3488467884726880f8f9fbd8e9bcc.png"

      损失（

      src="https://i-blog.csdnimg.cn/direct/df6c6bf4bd33429588d949b77de587da.png"

      width="502">）；

   5. 梯度下降：更新当前网络参数，每隔target_update步同步到目标网络；
   6. 循环迭代：重复上述步骤，直到训练结束。

   id="%EF%BC%88%E4%BA%94%EF%BC%89Double%20DQN%20%E7%9A%84Python%E4%BB%A3%E7%A0%81%E5%AE%8C%E6%95%B4%E5%AE%9E%E7%8E%B0"

   name="%EF%BC%88%E4%BA%94%EF%BC%89Double%20DQN%20%E7%9A%84Python%E4%BB%A3%E7%A0%81%E5%AE%8C%E6%95%B4%E5%AE%9E%E7%8E%B0"

   rgba(0,

   的Python代码完整实现

   先实现rl_utils库，它包含一些函数，如绘制移动平均曲线、计算优势函数等，不同的算法可以一起使用这些函数。

   rl_utils.py中的Python代码如下：

   collections.deque(maxlen=capacity)def

   add(self,

   done):self.buffer.append((state,

   action,

   np.cumsum(a[:window_size-1])[::2]

   rend

   (np.cumsum(a[:-window_size:-1])[::2]

   r)[::-1]return

   tqdm(total=int(num_episodes/10),

   desc='Iteration

   range(int(num_episodes/10)):episode_return

   0transition_dict

   agent.take_action(state)next_state,

   reward,

   env.step(action)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

   rewardreturn_list.append(episode_return)agent.update(transition_dict)if

   (i_episode+1)

   np.mean(return_list[-10:])})pbar.update(1)return

   return_list

   tqdm(total=int(num_episodes/10),

   desc='Iteration

   range(int(num_episodes/10)):episode_return

   0state

   agent.take_action(state)next_state,

   reward,

   env.step(action)replay_buffer.add(state,

   action,

   replay_buffer.sample(batch_size)transition_dict

   {'states':

   b_d}agent.update(transition_dict)return_list.append(episode_return)if

   (i_episode+1)

   np.mean(return_list[-10:])})pbar.update(1)return

   return_list

   td_delta.detach().numpy()advantage_list

   []advantage

   deltaadvantage_list.append(advantage)advantage_list.reverse()return

   dtype=torch.float)

   Double

   collections.deque(maxlen=capacity)

   队列，先进先出def

   将数据加入bufferself.buffer.append((state,

   action,

   从buffer中采样数据，数量为batch_sizetransitions

   batch_size)state,

   window_size):'''滑动平均函数'''cumulative_sum

   0))middle

   np.cumsum(a[:window_size-1])[::2]

   rend

   (np.cumsum(a[:-window_size:-1])[::2]

   r)[::-1]return

   Qnet(torch.nn.Module):'''只有一层隐藏层的Q网络'''def

   __init__(self,

   dqn_type='VanillaDQN'):self.action_dim

   action_dimself.q_net

   self.action_dim).to(device)self.target_q_net

   Qnet(state_dim,

   self.action_dim).to(device)self.optimizer

   torch.optim.Adam(self.q_net.parameters(),

   gammaself.epsilon

   np.random.randint(self.action_dim)else:#

   优化张量创建：先转numpy数组再创建张量，避免警告state

   torch.tensor(np.array([state]),

   dtype=torch.float32).to(self.device)action

   self.q_net(state).argmax().item()return

   actiondef

   torch.tensor(np.array([state]),

   dtype=torch.float32).to(self.device)return

   self.q_net(state).max().item()def

   update(self,

   torch.tensor(transition_dict['states'],

   dtype=torch.float32).to(self.device)actions

   torch.tensor(transition_dict['actions']).view(-1,

   torch.tensor(transition_dict['rewards'],

   torch.tensor(transition_dict['next_states'],

   dtype=torch.float32).to(self.device)dones

   torch.tensor(transition_dict['dones'],

   actions)if

   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:

   self.target_q_net(next_states).max(1)[0].view(-1,

   1)q_targets

   torch.mean(F.mse_loss(q_values,

   q_targets))self.optimizer.zero_grad()dqn_loss.backward()self.optimizer.step()if

   self.count

   0:self.target_q_net.load_state_dict(self.q_net.state_dict())self.count

   设置超参数

   agent.take_action(state)max_q_value

   0.005

   平滑处理max_q_value_list.append(max_q_value)

   dis_to_con(action,

   env.step([action_continuous])done

   terminated

   replay_buffer.sample(batch_size)transition_dict

   {'states':

   b_d}agent.update(transition_dict)return_list.append(episode_return)if

   (i_episode

   np.mean(return_list[-10:])})pbar.update(1)return

   return_list,

   plt.savefig('DQN_Pendulum_returns.png',

   dpi=300,

   list(range(len(max_q_value_list)))

   max_q_value_list)

   plt.savefig('DQN_Pendulum_q_value.png',

   dpi=300,

   plt.savefig('DoubleDQN_Pendulum_returns.png',

   dpi=300,

   list(range(len(max_q_value_list)))

   max_q_value_list)

   plt.savefig('DoubleDQN_Pendulum_q_value.png',

   dpi=300,

   id="%EF%BC%88%E5%85%AD%EF%BC%89%E7%A8%8B%E5%BA%8F%E8%BF%90%E8%A1%8C%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA%E4%B8%8E%E5%88%86%E6%9E%90"

   name="%EF%BC%88%E5%85%AD%EF%BC%89%E7%A8%8B%E5%BA%8F%E8%BF%90%E8%A1%8C%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA%E4%B8%8E%E5%88%86%E6%9E%90"

   rgba(0,

   id="%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA"

   name="%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA">结果展示

   Iteration

   100%|██████████|

   src="https://i-blog.csdnimg.cn/direct/b5250b21b5374454b51b678720d2e5e0.png"

   alt=""

   src="https://i-blog.csdnimg.cn/direct/cd5ad649003d4a27a2c8f17db9f2ec0e.png"

   100%|██████████|

   src="https://i-blog.csdnimg.cn/direct/567add2e358a4d7bb718f418351cb626.png"

   alt=""

   src="https://i-blog.csdnimg.cn/direct/9df5a1f484774b50aff1ef85bb77e805.png"

   width="1723">

   id="%E7%BB%93%E6%9E%9C%E5%88%86%E6%9E%90"

   name="%E7%BB%93%E6%9E%9C%E5%88%86%E6%9E%90"

   rgba(0,

   0)">结果分析

   根据代码运行结果我们可以发现，DQN

   DQN

   id="%EF%BC%88%E4%B8%83%EF%BC%89Double%20DQN%20%E7%9A%84%E4%BC%98%E5%8A%BF%E4%B8%8E%E9%80%82%E7%94%A8%E5%9C%BA%E6%99%AF"

   name="%EF%BC%88%E4%B8%83%EF%BC%89Double%20DQN%20%E7%9A%84%E4%BC%98%E5%8A%BF%E4%B8%8E%E9%80%82%E7%94%A8%E5%9C%BA%E6%99%AF">（七）Double

   DQN

   name="%E4%BC%98%E5%8A%BF">优势

   1. 缓解过估计：核心价值，让

      值估计更接近真实值；

   2. 收敛更稳定：过估计减少后，策略更新的信号更可靠，训练过程不易震荡；
   3. 兼容性强：可以和

      Dueling

      id="%E9%80%82%E7%94%A8%E5%9C%BA%E6%99%AF"

      name="%E9%80%82%E7%94%A8%E5%9C%BA%E6%99%AF">适用场景

      • 所有原始

        DQN

        值估计精度要求高的场景（比如稀疏奖励环境，过估计会导致智能体学不到有效策略）。

      id="%EF%BC%88%E5%85%AB%EF%BC%89%E5%85%B3%E9%94%AE%E6%80%BB%E7%BB%93"

      name="%EF%BC%88%E5%85%AB%EF%BC%89%E5%85%B3%E9%94%AE%E6%80%BB%E7%BB%93"

      rgba(0,

      0)">（八）关键总结

      1. 核心改进：Double

         DQN

         值过估计问题；

      2. 公式核心：

         • 原始

         src="https://i-blog.csdnimg.cn/direct/b7bc6b6ecfb34ef593e469e815e5a75e.png"

         DQN：

         src="https://i-blog.csdnimg.cn/direct/f0c787c9451c444d8d0a83eda9fbc927.png"

         width="908">；

      Double

      DQN

      id="%E4%B8%89%E3%80%81Dueling%20DQN%20%E7%AE%97%E6%B3%95"

      name="%E4%B8%89%E3%80%81Dueling%20DQN%20%E7%AE%97%E6%B3%95">三、Dueling

      DQN

      id="%EF%BC%88%E4%B8%80%EF%BC%89Dueling%20DQN%20%E7%9A%84%E6%8F%90%E5%87%BA%E8%83%8C%E6%99%AF%EF%BC%9A%E4%BC%98%E5%8C%96%20Q%20%E5%80%BC%E7%9A%84%E5%AD%A6%E4%B9%A0%E7%BB%93%E6%9E%84"

      name="%EF%BC%88%E4%B8%80%EF%BC%89Dueling%20DQN%20%E7%9A%84%E6%8F%90%E5%87%BA%E8%83%8C%E6%99%AF%EF%BC%9A%E4%BC%98%E5%8C%96%20Q%20%E5%80%BC%E7%9A%84%E5%AD%A6%E4%B9%A0%E7%BB%93%E6%9E%84">（一）Dueling

      DQN

      值（Q(s,a)），但这种设计存在一个问题：

      Q

      值包含两个核心信息

      将这两个信息混在一起学习，会导致冗余和低效。

      举个例子：在

      “优化这个高价值状态”，原始

      无法区分这两种信息，学习效率会打折扣。

      Dueling

      DQN

      “动作优势”，让网络分别学习这两种信息，提升学习效率和泛化能力。

      id="%EF%BC%88%E4%BA%8C%EF%BC%89Dueling%20DQN%20%E7%9A%84%E6%A0%B8%E5%BF%83%E6%80%9D%E6%83%B3%EF%BC%9A%E6%8B%86%E5%88%86%20Q%20%E5%80%BC%E4%B8%BA%20V%20(s)%20%E5%92%8C%20A%20(s%2Ca)"

      name="%EF%BC%88%E4%BA%8C%EF%BC%89Dueling%20DQN%20%E7%9A%84%E6%A0%B8%E5%BF%83%E6%80%9D%E6%83%B3%EF%BC%9A%E6%8B%86%E5%88%86%20Q%20%E5%80%BC%E4%B8%BA%20V%20(s)%20%E5%92%8C%20A%20(s%2Ca)">（二）Dueling

      DQN

      id="1.%20%E6%A0%B8%E5%BF%83%E5%85%AC%E5%BC%8F%EF%BC%9AQ%20%E5%80%BC%E7%9A%84%E6%8B%86%E8%A7%A3%E4%B8%8E%E9%87%8D%E6%9E%84"

      name="1.%20%E6%A0%B8%E5%BF%83%E5%85%AC%E5%BC%8F%EF%BC%9AQ%20%E5%80%BC%E7%9A%84%E6%8B%86%E8%A7%A3%E4%B8%8E%E9%87%8D%E6%9E%84">1.

      核心公式：Q

      动作价值）拆分为两部分：Q(s,a)=V(s)+A(s,a)

      • V(s)：状态价值函数

        只和状态s有关，输出一个标量，表示

        “处于状态s本身有多好”（和动作无关）；

      • A(s,a)：动作优势函数

        “在状态s下选动作a比选其他动作好多少”。

      id="2.%20%E5%85%B3%E9%94%AE%E6%94%B9%E8%BF%9B%EF%BC%9A%E8%A7%A3%E5%86%B3%20%E2%80%9C%E4%B8%8D%E5%8F%AF%E8%AF%86%E5%88%AB%E6%80%A7%E2%80%9D%20%E9%97%AE%E9%A2%98"

      name="2.%20%E5%85%B3%E9%94%AE%E6%94%B9%E8%BF%9B%EF%BC%9A%E8%A7%A3%E5%86%B3%20%E2%80%9C%E4%B8%8D%E5%8F%AF%E8%AF%86%E5%88%AB%E6%80%A7%E2%80%9D%20%E9%97%AE%E9%A2%98">2.

      关键改进：解决

      会存在「不可识别性」：比如给V(s)加一个常数，同时给A(s,a)减同一个常数，Q(s,a)的值不变，但V和A的含义被破坏。

      因此

      Dueling

      src="https://i-blog.csdnimg.cn/direct/3df95b2b26c149ff87391c7ebdcafa27.png"

      alt=""

      src="https://i-blog.csdnimg.cn/direct/3f759ece2ce842f9987c453a91f73586.png"

      width="274">：当前状态下所有动作优势值的均值；

   4. 作用：让优势函数A(s,a)表示

      id="%EF%BC%88%E4%B8%89%EF%BC%89Dueling%20DQN%20%E7%9A%84%E7%BD%91%E7%BB%9C%E7%BB%93%E6%9E%84"

      name="%EF%BC%88%E4%B8%89%EF%BC%89Dueling%20DQN%20%E7%9A%84%E7%BD%91%E7%BB%9C%E7%BB%93%E6%9E%84">（三）Dueling

      DQN

      的网络结构

      VAnet类是

      Dueling

      id="1.%20%E5%8E%9F%E5%A7%8B%20DQN%20%E7%9A%84%20Qnet%EF%BC%88%E5%8D%95%E5%B1%82%E9%9A%90%E8%97%8F%E5%B1%82%EF%BC%89"

      name="1.%20%E5%8E%9F%E5%A7%8B%20DQN%20%E7%9A%84%20Qnet%EF%BC%88%E5%8D%95%E5%B1%82%E9%9A%90%E8%97%8F%E5%B1%82%EF%BC%89">1.

      DQN

      id="2.%20Dueling%20DQN%20%E7%9A%84%20VAnet%EF%BC%88%E6%8B%86%E5%88%86%20V%20%E5%92%8C%20A%EF%BC%89"

      name="2.%20Dueling%20DQN%20%E7%9A%84%20VAnet%EF%BC%88%E6%8B%86%E5%88%86%20V%20%E5%92%8C%20A%EF%BC%89">2.

      Dueling

      代码逐行解析：

      • self.fc1：所有分支共享的特征提取层（避免重复学习状态特征）；
      • self.fc_A：输出每个动作的优势值A(s,a)，形状是[batch_size,

        action_dim]；

      • self.fc_V：输出状态价值V(s)，形状是[batch_size,

        1]；

      • A.mean(1).view(-1,

        1)：计算每个样本的优势值均值（mean(1)按行求均值，view保证维度匹配）；

      • Q

        A.mean(1).view(-1,

        id="%EF%BC%88%E5%9B%9B%EF%BC%89Dueling%20DQN%20%E7%9A%84%E8%AE%AD%E7%BB%83%E9%80%BB%E8%BE%91%EF%BC%88%E5%92%8C%E5%8E%9F%E5%A7%8B%20DQN%20%E7%9A%84%E5%BC%82%E5%90%8C%EF%BC%89"

        name="%EF%BC%88%E5%9B%9B%EF%BC%89Dueling%20DQN%20%E7%9A%84%E8%AE%AD%E7%BB%83%E9%80%BB%E8%BE%91%EF%BC%88%E5%92%8C%E5%8E%9F%E5%A7%8B%20DQN%20%E7%9A%84%E5%BC%82%E5%90%8C%EF%BC%89">（四）Dueling

        DQN

        的异同）

        DQN类的初始化和更新逻辑是兼容

        Dueling

        id="1.%20%E5%88%9D%E5%A7%8B%E5%8C%96%E6%97%B6%E7%9A%84%E7%BD%91%E7%BB%9C%E9%80%89%E6%8B%A9"

        name="1.%20%E5%88%9D%E5%A7%8B%E5%8C%96%E6%97%B6%E7%9A%84%E7%BD%91%E7%BB%9C%E9%80%89%E6%8B%A9">1.

        self.action_dim).to(device)self.target_q_net

        VAnet(state_dim,

        self.action_dim).to(device)self.target_q_net

        Qnet(state_dim,

        self.action_dim).to(device)

        DQN

        用Qnet；

      • 注意：无论是VAnet还是Qnet，最终输出的都是[batch_size,

        值，因此后续的take_action、update逻辑完全复用（这是

        Dueling

        id="2.%20%E8%AE%AD%E7%BB%83%20%2F%20%E6%9B%B4%E6%96%B0%E9%80%BB%E8%BE%91"

        name="2.%20%E8%AE%AD%E7%BB%83%20%2F%20%E6%9B%B4%E6%96%B0%E9%80%BB%E8%BE%91">2.

        更新逻辑

        Dueling

        dones)；

      • 损失计算：MSE

        损失（

        src="https://i-blog.csdnimg.cn/direct/3d377d97a2bb4b4690935cd31fe1b8ff.png"

        width="498">）；

      • 梯度下降更新网络。

      核心差异：只是self.q_net的内部结构不同（拆分

      id="%EF%BC%88%E4%BA%94%EF%BC%89Dueling%20DQN%20%E7%9A%84Python%E4%BB%A3%E7%A0%81%E5%AE%8C%E6%95%B4%E5%AE%9E%E7%8E%B0"

      name="%EF%BC%88%E4%BA%94%EF%BC%89Dueling%20DQN%20%E7%9A%84Python%E4%BB%A3%E7%A0%81%E5%AE%8C%E6%95%B4%E5%AE%9E%E7%8E%B0"

      rgba(0,

      collections.deque(maxlen=capacity)

      队列,先进先出def

      将数据加入bufferself.buffer.append((state,

      action,

      从buffer中采样数据,数量为batch_sizetransitions

      batch_size)state,

      np.cumsum(a[:window_size-1])[::2]

      rend

      (np.cumsum(a[:-window_size:-1])[::2]

      r)[::-1]return

      self.fc_A(F.relu(self.fc1(x)))V

      self.fc_V(F.relu(self.fc1(x)))Q

      A.mean(1).view(-1,

      __init__(self,state_dim,hidden_dim,action_dim,learning_rate,gamma,epsilon,target_update,device,dqn_type='VanillaDQN'):self.action_dim

      action_dimif

      hidden_dim,self.action_dim).to(device)self.target_q_net

      VAnet(state_dim,

      hidden_dim,self.action_dim).to(device)else: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)self.optimizer

      torch.optim.Adam(self.q_net.parameters(),lr=learning_rate)self.gamma

      gammaself.epsilon

      np.random.randint(self.action_dim)else:#

      优化张量创建：先转numpy数组再创建张量，消除效率警告state

      torch.tensor(np.array([state]),

      dtype=torch.float32).to(self.device)action

      self.q_net(state).argmax().item()return

      actiondef

      torch.tensor(np.array([state]),

      dtype=torch.float32).to(self.device)return

      self.q_net(state).max().item()def

      update(self,

      torch.tensor(transition_dict['states'],dtype=torch.float32).to(self.device)actions

      torch.tensor(transition_dict['actions']).view(-1,

      torch.tensor(transition_dict['rewards'],dtype=torch.float32).view(-1,

      torch.tensor(transition_dict['next_states'],dtype=torch.float32).to(self.device)dones

      torch.tensor(transition_dict['dones'],dtype=torch.float32).view(-1,

      actions)if

      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:max_next_q_values

      self.target_q_net(next_states).max(1)[0].view(-1,

      1)q_targets

      torch.mean(F.mse_loss(q_values,

      q_targets))self.optimizer.zero_grad()dqn_loss.backward()self.optimizer.step()if

      self.count

      0:self.target_q_net.load_state_dict(self.q_net.state_dict())self.count

      超参数设置

      agent.take_action(state)max_q_value

      0.005

      平滑处理max_q_value_list.append(max_q_value)

      dis_to_con(action,

      env.step([action_continuous])done

      terminated

      replay_buffer.sample(batch_size)transition_dict

      {'states':

      b_d}agent.update(transition_dict)return_list.append(episode_return)if

      (i_episode

      np.mean(return_list[-10:])})pbar.update(1)return

      return_list,

      使用本地定义的ReplayBuffer，避免rl_utils依赖

      agent

      plt.savefig('DuelingDQN_Pendulum_returns.png',

      dpi=300,

      list(range(len(max_q_value_list)))

      max_q_value_list)

      plt.savefig('DuelingDQN_Pendulum_q_value.png',

      dpi=300,

      id="%EF%BC%88%E5%85%AD%EF%BC%89%E7%A8%8B%E5%BA%8F%E8%BF%90%E8%A1%8C%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA%E4%B8%8E%E5%88%86%E6%9E%90"

      name="%EF%BC%88%E5%85%AD%EF%BC%89%E7%A8%8B%E5%BA%8F%E8%BF%90%E8%A1%8C%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA%E4%B8%8E%E5%88%86%E6%9E%90"

      rgba(0,

      id="%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA"

      name="%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA">结果展示

      Iteration

      100%|██████████|

      src="https://i-blog.csdnimg.cn/direct/e07042b152cc4424b1c567700fd9e582.png"

      alt=""

      src="https://i-blog.csdnimg.cn/direct/5052f1eef18245ffbd210e57989f8a33.png"

      width="1750">

      id="%E7%BB%93%E6%9E%9C%E5%88%86%E6%9E%90"

      name="%E7%BB%93%E6%9E%9C%E5%88%86%E6%9E%90">结果分析

      根据代码运行结果我们可以发现，相比于传统的

      DQN，Dueling

      id="%EF%BC%88%E4%B8%83%EF%BC%89Dueling%20DQN%20%E7%9A%84%E4%BC%98%E5%8A%BF%E4%B8%8E%E9%80%82%E7%94%A8%E5%9C%BA%E6%99%AF"

      name="%EF%BC%88%E4%B8%83%EF%BC%89Dueling%20DQN%20%E7%9A%84%E4%BC%98%E5%8A%BF%E4%B8%8E%E9%80%82%E7%94%A8%E5%9C%BA%E6%99%AF">（七）Dueling

      DQN

      id="%E6%A0%B8%E5%BF%83%E4%BC%98%E5%8A%BF"

      name="%E6%A0%B8%E5%BF%83%E4%BC%98%E5%8A%BF">核心优势

      1. 学习效率更高：拆分

         “动作的相对优势”，避免信息混叠导致的冗余学习；

      2. 泛化能力更强：对于

         “状态价值主导”

         只需微调动作选择；

      3. 框架兼容好：可以和

         Double

         DQN），进一步提升性能；

      4. 计算开销低：仅增加了一个线性层（fc_V），几乎不增加训练时间。

      id="%E9%80%82%E7%94%A8%E5%9C%BA%E6%99%AF"

      name="%E9%80%82%E7%94%A8%E5%9C%BA%E6%99%AF">适用场景

      • 状态价值主导的环境：比如

        Pendulum（摆杆位置决定核心价值）、迷宫类环境（是否靠近终点决定核心价值）；

      • 动作空间较大的环境：拆分后

        (s,a)

        值，降低学习难度；

      • 希望提升收敛速度的场景：Dueling

        DQN

        id="%EF%BC%88%E5%85%AB%EF%BC%89Dueling%20DQN%20vs%20Double%20DQN%EF%BC%9A%E6%A0%B8%E5%BF%83%E5%8C%BA%E5%88%AB"

        name="%EF%BC%88%E5%85%AB%EF%BC%89Dueling%20DQN%20vs%20Double%20DQN%EF%BC%9A%E6%A0%B8%E5%BF%83%E5%8C%BA%E5%88%AB">（八）Dueling

        DQN

        DQN：核心区别

        很多人会混淆这两种算法，这里做清晰对比：

        维度	Double DQN	Dueling DQN
        核心目标	缓解 “选动作” “动作优势”）
        改进层面	目标 网络的内部结构
        对代码的修改点	update函数中目标 Qnet）
        兼容性	可与 Dueling 等结合

        id="%EF%BC%88%E4%B9%9D%EF%BC%89%E5%85%B3%E9%94%AE%E6%80%BB%E7%BB%93"

        name="%EF%BC%88%E4%B9%9D%EF%BC%89%E5%85%B3%E9%94%AE%E6%80%BB%E7%BB%93">（九）关键总结

        1. 核心思想：Dueling

           DQN

           值拆分为状态价值V(s)（和动作无关）和动作优势A(s,a)（和动作有关），并通过中心化处理（A−Aˉ）解决不可识别性问题；

        2. 代码核心：VAnet类是关键

           共享特征提取层

           值；

        3. 训练逻辑：对外输出的

           值格式和原始

           更新流程无需修改；

        4. 核心优势：学习效率更高、收敛更快，且可与

           Double

           id="%E5%9B%9B%E3%80%81%E6%80%BB%E7%BB%93"

           name="%E5%9B%9B%E3%80%81%E6%80%BB%E7%BB%93">四、总结

           在传统的

           DQN

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

           从

           Double

           的方法原理中，我们也能感受到深度强化学习的研究是在关注深度学习和强化学习有效结合：一是在深度学习的模块的基础上，强化学习方法如何更加有效地工作，并避免深度模型学习行为带来的一些问题，例如使用

           Double

           解决Q值过高估计的问题；二是在强化学习的场景下，深度学习模型如何有效学习到有用的模式，例如设计

           Dueling

           网络架构来高效地学习状态价值函数以及动作优势函数。