Keras深度强化学习--Dueling DQN实现

从DQN到Nature DQN再到Double DQN，这些Deep Q-learning算法的改进点在于TD-error的计算和Q值的计算，而在网络结构上并没有变化，其Deep与RL结合的程度只是使用了基本的DNN网络作为函数近似。而Dueling DQN并没有对外部计算做出改动，而是将RL的思想纳入到DNN网络结构中，通过对网络结构的改动达到提升DQN性能的目的。

Paper：
Dueling DQN:Dueling Network Architectures for Deep Reinforcement Learning

Github：https://github.com/xiaochus/Deep-Reinforcement-Learning-Practice

环境

Python 3.6
Tensorflow-gpu 1.8.0
Keras 2.2.2
Gym 0.10.8

算法原理

DQN与Dueling DQN的网络结构对比如下所示。DQN直接使用一个常规网络生成Q值；而Dueling DQN的网络结构在最后出现了两个分支，这两个分支的值合并后生成一个Q值。

DQN and Dueling

Dueling DQN网络结构中的这个分支可以用下列公式表达。网络的两个分支上分支产生一个advantage值，下分支产生action对应的value值，这两个值相加后才得到最终的action的Q值。

其余的部分Dueling DQN与Nature DQN完全一致，其损失函数以及外部Q值的更新方式如下所示：

那么为什么要使用Advantage值呢？通过Advantage我们可以直观地了解哪些状态是（或不是）有价值的，而不必了解每个action对每个状态的影响。这在action不以任何相关方式影响环境的情况下特别有用。

下图显示了DuelingDQN在Atari游戏中不同时间步的value和advantage显着性图（红色覆盖部分）。在一个时间步（最左边的一对图像）中，我们看到价值网络流关注道路，尤其是新车出现的地平线，同时它也注重value得分。另一方面，优势网络流并不太关注视觉输入，因为当前面没有车辆时，它的动作选择实际上是无关紧要的。然而，在第二个时间步（最右边的一对图像）中，优势流引起注意，因为前面有一辆汽车，因此其选择的动作非常相关。因此value学会关注道路，advantage只有在前方有车时才会学会注意，以避免碰撞。

dueling

网络在使用Q=S+A计算Q值会出现一个可识别性问题：给定一个Q值，我们无法得到唯一的V和A。比如，V和A分别加上和减去一个值能够得到同样的Q值，但反过来显然无法由Q得到唯一的V和A。如果直接使用该等式，会使得模型的性能变差。

为了解决这个问题，作者提出两个解决方法：

1、强制优势函数在所选择的操作中没有任何优势

2、使用优势函数的平均值代替上述的最优值

采用这种方法，虽然使得值函数V和优势函数A不再完美的表示值函数和优势函数(在语义上的表示)，但是这种操作提高了稳定性。而且，并没有改变值函数V和优势函数A的本质表示。

算法实现

Dueling DQN与Nature DQN的区别仅在于DNN模型的区别，下面是Dueling DQN使用的DNN模型，可以看出我们使用了value和advantage分支来合并计算Q值。

    def build_model(self):
        """basic model.
        """
        inputs = Input(shape=(4,))
        x = Dense(16, activation='relu')(inputs)
        x = Dense(16, activation='relu')(x)

        value = Dense(2, activation='linear')(x)
        a = Dense(2, activation='linear')(x)
        meam = Lambda(lambda x: K.mean(x, axis=1, keepdims=True))(a)
        advantage = Subtract()([a, meam])

        q = Add()([value, advantage])

        model = Model(inputs=inputs, outputs=q)

        model.compile(loss='mse', optimizer=Adam(1e-3))

        return model

完整代码：

# -*- coding: utf-8 -*-
import os
import numpy as np

from keras.layers import Input, Dense, Add, Subtract, Lambda
from keras.models import Model
from keras.optimizers import Adam
import keras.backend as K

from NatureDQN import NDQN


class DuelingDQN(NDQN):
    """Dueling DQN.
    """
    def __init__(self):
        super(DuelingDQN, self).__init__()

    def load(self):
        if os.path.exists('model/dueling.h5'):
            self.model.load_weights('model/dueling.h5')

    def build_model(self):
        """basic model.
        """
        inputs = Input(shape=(4,))
        x = Dense(16, activation='relu')(inputs)
        x = Dense(16, activation='relu')(x)

        value = Dense(2, activation='linear')(x)
        a = Dense(2, activation='linear')(x)
        meam = Lambda(lambda x: K.mean(x, axis=1, keepdims=True))(a)
        advantage = Subtract()([a, meam])

        q = Add()([value, advantage])

        model = Model(inputs=inputs, outputs=q)

        model.compile(loss='mse', optimizer=Adam(1e-3))

        return model

    def train(self, episode, batch):
        """training 
        Arguments:
            episode: game episode
            batch： batch size

        Returns:
            history: training history
        """
        history = {'episode': [], 'Episode_reward': [], 'Loss': []}

        count = 0
        for i in range(episode):
            observation = self.env.reset()
            reward_sum = 0
            loss = np.infty
            done = False

            while not done:
                # chocie action from ε-greedy.
                x = observation.reshape(-1, 4)
                action = self.egreedy_action(x)
                observation, reward, done, _ = self.env.step(action)
                # add data to experience replay.
                reward_sum += reward
                self.remember(x[0], action, reward, observation, done)

                if len(self.memory_buffer) > batch:
                    X, y = self.process_batch(batch)
                    loss = self.model.train_on_batch(X, y)

                    count += 1
                    # reduce epsilon pure batch.
                    self.update_epsilon()

                    # update target_model every 20 episode
                    if count != 0 and count % 20 == 0:
                        self.update_target_model()

            if i % 5 == 0:
                history['episode'].append(i)
                history['Episode_reward'].append(reward_sum)
                history['Loss'].append(loss)

                print('Episode: {} | Episode reward: {} | loss: {:.3f} | e:{:.2f}'.format(i, reward_sum, loss, self.epsilon))

        self.model.save_weights('model/dueling.h5')

        return history


if __name__ == '__main__':
    model = DuelingDQN()

    history = model.train(600, 32)
    model.save_history(history, 'dueling.csv')

    model.load()
    model.play('dqn')

训练与测试结果如下，在使用与DQN同样的参数的情况下，可以看出Dueling DQN收敛的更好，在每次测试中都能够拿到200的分数。

play...
Reward for this episode was: 200.0
Reward for this episode was: 200.0
Reward for this episode was: 200.0
Reward for this episode was: 200.0
Reward for this episode was: 200.0
Reward for this episode was: 200.0
Reward for this episode was: 200.0
Reward for this episode was: 200.0
Reward for this episode was: 200.0
Reward for this episode was: 200.0

Traning