Dueling Network —— Dueling Network Architectures for Deep Reinforcement Learning

• 论文下载地址

• 论文介绍

  

  图9. Dueling Network 模型结果示意图

  Dueling Network与传统DQN的区别在于神经网络结构的不同，Dueling Netowrk在传统DQN的基础上只进行了微小的改动，但能大幅提升DQN的表现。从图9中可以看出，在传统DQN中，DQN的神经网络直接输出Q函数的值，即某个状态下不同动作对应的动作价值，输出层的前一层是全连接层。

  Dueling Network对DQN的结构改进主要在全连接层上，它在全连接层和输出层之间进行修改，将全连接层改为两条流，其中一条输出关于状态的价值，另外一条输出关于动作的优势函数的值，最终将两条流合并得到Q动作价值。

  在某些情况下，Dueling Network可以了解哪些状态有价值或没有价值，而不必了解每个动作对状态的影响（在一些状态中，不管选择哪个动作的影响都不大），这在agent的行为不会以任何方式影响到环境的情况下特别有用。
  

  图10. 不同情况下agent的侧重点
  如图10所示，agent注意力集中的部分被标记为橙色，当agent前面没有车时，agent自身动作对于环境并没有太大差异，此时agent更加关注状态价值，当agent前面有车时（agent需要躲避车辆或者超车），agent需要关注不同动作优势值的差异。

• 理论分析

  假设在Atari游戏中，智能体在时间步$t$根据由$M$个视频帧组成的$s_t=(x_{t-M+1},...,x_t)\in S$，从动作空间 A = { 1 , . . . , ∣ A ∣ } \mathcal{A}=\{1,...,|\mathcal{A}|\} A={1,...,∣A∣}选择动作$a_t$ ，并观测由模拟器产生的奖励信号$r_t$ 。

  在一局游戏中，把从起始到结束的所有奖励记作$r_1,...,r_t,...,r_n$，定义折扣回报率为$\gamma \in [0,1]$。折扣回报的定义如公式(1)所示：$$R_t=r_t+\gamma \cdot r_{t+1}+{\gamma }^2\cdot r_{t+2}+\cdots +{\gamma }^{n-t}\cdot r_n\text{\hspace{1em}(1)}$$在游戏尚未结束的$t$时刻，$R_t$是一个随机变量，其随机性来自于$t$时刻之后的所有状态和动作。动作价值函数的定义如公式(2)所示：$$Q_{\pi }\left(s_t,a_t\right)=\mathbb{E}\left[R_t\mid S_t=s_t,A_t=a_t\right]\text{\hspace{1em}(2)}$$公式(2)中的期望消除了$t$时刻之后的所有状态$S_{t+1},...,S_n$ 与所有动作$A_{t+1},...,A_n$，期望只与当前的状态$s_t$和动作$a_t$相关。上面介绍的状态动作价值函数可以用动态规划递归计算，如公式(3)所示：$$Q_{\pi }(s_t,a_t)={\mathbb{E}}_{S_{t+1}}\left[r+\gamma {\mathbb{E}}_{A_{t+1}}\left[Q_{\pi }\left(s_{t+1},a_{t+1}\right)\right]\mid S_t=s_t,A_t=a_t\right]\text{\hspace{1em}(3)}$$ 动作价值函数$Q_{\pi }(s_t,a_t)$依赖于$s_t$、$a_t$和$\pi$，不依赖于$t+1$时刻及之后的状态和动作，因为随机变量$S_{t+1},A_{t+1},...,S_n,A_n$ 都被期望消除了。

  为了消除策略$\pi$的影响，只评价当前状态$s_t$和动作$a_t$的好坏，引出了最优动作价值函数，如公式(4)所示：$$Q_{\star }\left(s_t,a_t\right)=\underset{\pi }{\max }{Q}_{\pi }\left(s_t,a_t\right),\forall s_t\in \mathcal{S},a_t\in \mathcal{A}\text{\hspace{1em}(4)}$$最优动作价值函数可以理解为有很多种策略函数$\pi$可以选择，我们选择最好的策略函数，如公式(5)所示：$${\pi }^{\star }=\underset{\pi }{\mathrm{argmax}}{Q}_{\pi }\left(s_t,a_t\right),\forall s_t\in \mathcal{S},a_t\in \mathcal{A}\text{\hspace{1em}(5)}$$

  状态价值函数的定义如公式(6)所示：$$\begin{array}{rl}{V}_{\pi }\left(s_t\right)& ={\mathbb{E}}_{A_t\sim \pi \left(\cdot \mid s_t\right)}\left[Q_{\pi }\left(s_t,A_t\right)\right]\\ & =\sum _{a\in \mathcal{A}}\pi \left(a\mid s_t\right)\cdot Q_{\pi }\left(s_t,a\right).\end{array}\text{\hspace{1em}(6)}$$公式(6)中把动作$A_t$作为随机变量，然后关于$A_t$求期望，把$A_t$消掉。状态价值函数$V_{\pi }(s_t)$只依赖于策略$\pi$与当前状态$s_t$，不依赖于动作。状态价值函数$V_{\pi }(s_t)$也是折扣回报$R_t$的期望，如公式(7)所示：$$V_{\pi }\left(s_t\right)={\mathbb{E}}_{A_t,S_{t+1},A_{t+1},\cdots ,S_n,A_n}\left[R_t\mid S_t=s_t\right]\text{\hspace{1em}(7)}$$公式(7)中消除了$R_t$依赖的随机变量$A_t,S_{t+1},A_{t+1},...,S_n,A_n$，状态价值函数值越大，表示当前状态$S_t$回报的期望越大，用状态价值可以衡量策略$\pi$与状态$s_t$的好坏。

  为了消除策略$\pi$的影响，只评价当前状态$s_t$的好坏，引出了最优状态价值函数，如公式(8)所示：$$V_{\star }(s)=\underset{\pi }{\max }{V}_{\pi }(s),\forall s\in \mathcal{S}\text{\hspace{1em}(8)}$$

  我们定义优势函数，将状态值函数和状态动作值函数联系起来，如公式(9)所示：$$A_{\pi }(s,a)=Q_{\pi }(s,a)-V_{\pi }(s)\text{\hspace{1em}(9)}$$ 公式(9)中，$V(s)$可以理解为在该状态$s$下所有可能动作所对应的动作值函数乘以采取该动作的概率之和；通俗来说，值函数$V(s)$是该状态下所有动作值函数关于动作概率的期望。而动作价值函数$Q(s,a)$是单个动作所对应的值函数，$Q(s,a)-V(s)$表示当前动作值函数相对于平均值的大小。

  所以优势函数表示的是当前动作值函数相比于当前状态值函数的优势，如果优势值大于零，表示当前动作比平均动作好，如果优势函数值小于0，表示当前动作比平均动作差。优势函数表示在当前状态下各个动作的相对好坏程度。

  根据优势函数的定义，我们可以知道优势函数有以下性质，如公式(10)所示：$${\mathbb{E}}_{a\sim \pi (s)}\left[A^{\pi }(s,a)\right]={\mathbb{E}}_{a\sim \pi (s)}\left[Q_{\pi }(s,a)-V_{\pi }(s)\right]={\mathbb{E}}_{a\sim \pi (s)}\left[Q_{\pi }(s,a)\right]-V_{\pi }(s)=V_{\pi }(s)-V_{\pi }(s)=0\text{\hspace{1em}(10)}$$

  优势函数刻画的是某个动作相对于平均值函数的“优势”。例如，在状态$s$下有3个动作$a_1$，$a_2$，$a_3$，对应的$Q$函数分别为$$Q(s,a_1)=0.9$$$$Q(s,a_2)=1$$$$Q(s,a_3)=1.1$$状态$s$的状态值函数为：$$V(s)={\mathbb{E}}_a[Q(s,a)]=(0.9+1+1.1)/3=1.0$$根据优势函数的定义，三个动作的优势函数值分别为：$$A(s,a_1)=-0.1$$$$A(s,a_2)=0$$$$A(s,a_3)=0.1$$因此$a_1$对于平均水平（由$V$定义）的优势为-0.1，表示该动作低于平均的值函数水平，$a_2$等于平均水平，$a_3$的优势高于平均水平，因此如果按照贪心策略来选择动作，应该选择动作$a_3$，最优动作的选择可以仅通过优势函数$A(s,a)$得到，即如公式(11)所示：$$a^{\ast }=arg\underset{a}{\max }A(s,a)=arg\underset{a}{\max }[A(s,a)+V(s)]=arg\underset{a}{\max }Q(s,a)\text{\hspace{1em}(11)}$$

  Dueling Network的核心思想是将动作值$Q(s,a)$的计算分解成两部分：状态值和优势函数，即如公式(12)所示：$$Q(s,a)=V(s)+A(s,a)\text{\hspace{1em}(12)}$$但是Dueling Network并不是直接基于公式(12)实现的，因为这会导致不唯一性。假如基于公式(12)实现Dueling Network，那么$V(s)$和$A(s,a)$可以随意上下波动，比如一个增大100，另一个减小100，这样的上下波动不影响最终的输出，如公式(13)所示：$$\begin{array}{rl}V\left(s;{\tilde{\mathbf{w}}}^V\right)& \triangleq V\left(s;{\mathbf{w}}^V\right)+100,\\ A\left(s,a;{\tilde{\mathbf{w}}}^A\right)& \triangleq A\left(s,a;{\mathbf{w}}^A\right)-100\\ V\left(s;{\mathbf{w}}^V\right)+A\left(s,a;{\mathbf{w}}^A\right)& =V\left(s;{\tilde{\mathbf{w}}}^V\right)+A\left(s,a;{\tilde{\mathbf{w}}}^A\right)\end{array}\text{\hspace{1em}(13)}$$这意味着$V$和$D$的参数可以很随意的变化却不会影响输出的$Q$，这会导致训练过程中参数的不稳定，这不是我们希望看到的。为了解决这个问题，论文中强制令动作的优势函数的最大值最大只能为0，即对每个动作的优势函数减去最优动作的优势函数值，如公式(14)所示：$$Q(s,a;\theta ,\alpha ,\beta )=V(s;\theta ,\beta )+\left(A(s,a;\theta ,\alpha )-\underset{a^{\prime }\in |\mathcal{A}|}{\max }A\left(s,a^{\prime };\theta ,\alpha \right)\right)\text{\hspace{1em}(14)}$$在公式(12)的基础上加上${\max }_{a^{\prime }\in |\mathcal{A}|}A\left(s,a^{\prime };\theta ,\alpha \right)$之后，它使得$V$和$A$不能随意上下波动。假如让$V$变大00，让$A$变小100，则Dueling Network的输出会增大100，不会再是公式(13)展示的结果，其影响如公式(15)所示：$$V\left(s;{\mathbf{w}}^V\right)+A\left(s,a;{\mathbf{w}}^A\right)-ma{x}_{a}A(s,a;{\mathbf{w}}^A)+100=V\left(s;{\tilde{\mathbf{w}}}^V\right)+A\left(s,a;{\tilde{\mathbf{w}}}^A\right)-ma{x}_{a}A(s,a;{\tilde{\mathbf{w}}}^A)\text{\hspace{1em}(15)}$$基于当前状态$s$的最优动作$a^{\star }$的获取如公式(16)所示：$$a^{\star }=argma{x}_{a^{\prime }\in \mathcal{A}}Q(s,a^{\prime };\theta ,\alpha ,\beta )=argma{x}_{a^{\prime }\in \mathcal{A}}A(s,a^{\prime };\theta ,\alpha ,\beta )\text{\hspace{1em}(16)}$$根据公式(14)和公式(16)，可以得到$$Q\left(s,a^{\ast };\theta ,\alpha ,\beta \right)=V(s;\theta ,\beta )$$除了使用$max$方法外，论文中提到可以使用期望的方式来求解$Q$动作价值函数，如公式(17)所示：$$\begin{array}{rl}& Q(s,a;\theta ,\alpha ,\beta )=V(s;\theta ,\beta )+\left(A(s,a;\theta ,\alpha )-\frac{1}{|\mathcal{A}|}\sum _{a^{\prime }}A\left(s,a^{\prime };\theta ,\alpha \right)\right)\end{array}\text{\hspace{1em}(17)}$$公式(14)和公式(17)使用了两种不同的方式来展示Dueling Network的工作原理，两个公式分别通过求解最大值或者期望的形式使得Dueling Network训练过程更加稳定（这也使得$V$和$A$失去了其原始语义，因为它们现在偏离目标一个常量）。

  Dueling Network的优势在于其能够有效学习状态值函数$V$，随着Dueling Network更新$Q$动作价值函数，$V$状态价值函数也会更新，这与传统的DQN或者Double DQN是不相同的，传统的DQN或者Double DQN只更新对应动作的$Q$动作价值函数，其它动作的$Q$并不会更新。在Dueling Network中，更新$V$可以影响其它动作的$Q$动作价值函数，使得Dueling Network能够有更好的训练效果。

• 基于gym的Dueling Network代码实现：

  • requirement:

    • python: 3.8
    • gym: 0.17.3
    • tensorflow: 2.9

  • code（代码主要参考书籍【动手学强化学习】(张伟楠，沈键，俞勇)，京东购买链接 ｜ 当当购买链接）

  import gym
  import random
  import tf_rl_utils
  import collections
  import numpy as np
  from tqdm import tqdm
  import tensorflow as tf
  import matplotlib.pyplot as plt
  
  
  class ReplayBuffer:
      """
      经验回放池
      """
      def __init__(self, capacity):
          self.buffer = collections.deque(maxlen=capacity)  # 队列,先进先出
  
      def add(self, state, action, reward, next_state, done):  # 将数据加入buffer
          self.buffer.append((state, action, reward, next_state, done))
  
      def sample(self, batch_size):  # 从buffer中采样数据,数量为batch_size
          transitions = random.sample(self.buffer, batch_size)
          state, action, reward, next_state, done = zip(*transitions)
          return np.array(state), action, reward, np.array(next_state), done
  
      def size(self):  # 目前buffer中数据的数量
          return len(self.buffer)
  
  
  class VAnet(tf.keras.Model):
      """ 只有一层隐藏层的A网络和V网络 """
      def __init__(self, hidden_dim, action_dim):
          super(VAnet, self).__init__()
          self.fc1 = tf.keras.layers.Dense(hidden_dim, activation=tf.keras.activations.relu)  # 共享网络部分
          self.fc_A = tf.keras.layers.Dense(action_dim)
          self.fc_V = tf.keras.layers.Dense(1)
  
      def call(self, x):
          A = self.fc_A(self.fc1(x))
          V = self.fc_V(self.fc1(x))
          Q = V + A - tf.reduce_mean(A, axis=1, keepdims=True)  # Q值由V值和A值计算得到
          return Q
  
  
  class DQN:
      def __init__(self, hidden_dim, action_dim, learning_rate, gamma,
                   epsilon, target_update, dqn_type='VanillaDQN'):
          self.action_dim = action_dim
          self.q_net = VAnet(hidden_dim, self.action_dim)  # Q网络
          # 目标网络
          self.target_q_net = VAnet(hidden_dim, self.action_dim)
          # 使用Adam优化器
          self.optimizer = tf.optimizers.Adam(learning_rate=learning_rate)
          self.gamma = gamma  # 折扣因子
          self.epsilon = epsilon  # epsilon-贪婪策略
          self.target_update = target_update  # 目标网络更新频率
          self.count = 0  # 计数器,记录更新次数
          self.dqn_type = dqn_type
  
      def take_action(self, state):  # epsilon-贪婪策略采取动作
          if np.random.random() < self.epsilon:
              action = np.random.randint(self.action_dim)
          else:
              state = tf.cast(tf.expand_dims(state, axis=0), dtype=tf.float32)
              action = tf.argmax(self.q_net.call(state), axis=1).numpy()[0]
          return action
  
      def max_q_value(self, state):
          state = tf.cast(tf.expand_dims(state, axis=0), dtype=tf.float32)
          return tf.reduce_max(self.q_net.call(state)).numpy()
  
      def update(self, transition_dict):
          states = tf.cast(transition_dict['states'], dtype=tf.float32)
          actions = tf.reshape(transition_dict['actions'], shape=(-1))
          rewards = tf.reshape(tf.cast(transition_dict['rewards'], dtype=tf.float32), shape=(-1, 1))
          next_states = tf.cast(transition_dict['next_states'], dtype=tf.float32)
          dones = tf.reshape(tf.cast(transition_dict['dones'], dtype=tf.float32), shape=(-1, 1))
          with tf.GradientTape() as tape:
              q_values = tf.gather(self.q_net.call(states), actions, batch_dims=1)  # Q值
              # 下个状态的最大Q值
              if self.dqn_type == 'DoubleDQN':  # DQN与Double DQN的区别
                  max_action = tf.argmax(self.q_net.call(next_states), axis=1, output_type=tf.int32)
                  max_next_q_values = tf.reshape(tf.gather(self.target_q_net.call(next_states), max_action, batch_dims=1), shape=(-1,1))  # Q值
              else:
                  max_next_q_values = tf.reduce_max(self.target_q_net.call(next_states), axis=1, keepdims=True)
              q_targets = rewards + self.gamma * max_next_q_values * (1 - dones)  # TD误差目标
              loss_func = tf.keras.losses.MeanSquaredError()
              dqn_loss = tf.reduce_mean(loss_func(q_values, q_targets))  # 均方误差损失函数
          grads = tape.gradient(dqn_loss, self.q_net.trainable_variables)
          self.optimizer.apply_gradients(zip(grads, self.q_net.trainable_variables))
          if self.count % self.target_update == 0:
              self.target_q_net.set_weights(self.q_net.get_weights())  # 更新目标网络
          self.count += 1
  
  
  lr = 1e-2
  num_episodes = 200
  hidden_dim = 128
  gamma = 0.98
  epsilon = 0.01
  target_update = 50
  buffer_size = 5000
  minimal_size = 1000
  batch_size = 64
  
  
  env_name = 'Pendulum-v0'
  env = gym.make(env_name)
  state_dim = env.observation_space.shape[0]
  action_dim = 11  # 将连续动作分成11个离散动作
  
  
  def dis_to_con(discrete_action, env, action_dim):  # 离散动作转回连续的函数
      action_lowbound = env.action_space.low[0]  # 连续动作的最小值
      action_upbound = env.action_space.high[0]  # 连续动作的最大值
      return action_lowbound + (discrete_action / (action_dim - 1)) * (action_upbound - action_lowbound)
  
  
  def train_DQN(agent, env, num_episodes, replay_buffer, minimal_size,
                batch_size):
      return_list = []
      max_q_value_list = []
      max_q_value = 0
      for i in range(10):
          with tqdm(total=int(num_episodes / 10),
                    desc='Iteration %d' % i) as pbar:
              for i_episode in range(int(num_episodes / 10)):
                  episode_return = 0
                  state = env.reset()
                  done = False
                  while not done:
                      action = agent.take_action(state)
                      max_q_value = agent.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, env,
                                                     agent.action_dim)
                      next_state, reward, done, _ = env.step([action_continuous])
                      replay_buffer.add(state, action, reward, next_state, done)
                      state = next_state
                      episode_return += reward
                      if replay_buffer.size() > minimal_size:
                          b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(
                              batch_size)
                          transition_dict = {
                              'states': b_s,
                              'actions': b_a,
                              'next_states': b_ns,
                              'rewards': b_r,
                              'dones': b_d
                          }
                          agent.update(transition_dict)
                  return_list.append(episode_return)
                  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)
      return return_list, max_q_value_list
  
  random.seed(0)
  np.random.seed(0)
  env.seed(0)
  tf.random.set_seed(0)
  replay_buffer = ReplayBuffer(buffer_size)
  agent = DQN(hidden_dim, action_dim, lr, gamma, epsilon, target_update, "DoubleDQN")
  return_list, max_q_value_list = train_DQN(agent, env, num_episodes,
                                            replay_buffer, minimal_size,
                                            batch_size)
  
  episodes_list = list(range(len(return_list)))
  mv_return = tf_rl_utils.moving_average(return_list, 5)
  plt.plot(episodes_list, mv_return)
  plt.xlabel('Episodes')
  plt.ylabel('Returns')
  plt.title('Double DQN on {}'.format(env_name))
  plt.show()
  
  

• result