深度 Q 网络给出相同的 Q 值并且没有改善答案

【问题标题】：Deep Q Network gives same Q values and doesn't improve深度 Q 网络给出相同的 Q 值并且没有改善
【发布时间】：2020-04-18 21:41:20
【问题描述】：

我正在尝试建立一个深度 Q 网络来玩蛇。我遇到了一个代理不学习的问题，它在训练周期结束时的表现是反复杀死自己。经过一番调试，我发现网络预测的 Q 值每次都相同。动作空间是 [up, right, down, left]，网络预测 [0, 0, 1, 0]。训练损失确实会随着时间的推移而下降，但似乎并没有什么不同。这是训练代码：

def train(self):
    tf.logging.set_verbosity(tf.logging.ERROR)
    self.build_model()
    for episode in range(self.max_episodes):
        self.current_episode = episode
        env = SnakeEnv(self.screen)
        episode_reward = 0
        for timestep in range(self.max_steps):
            env.render(self.screen)
            state = self.screenshot()
            #state = env.get_state()
            action = None
            epsilon = self.current_eps
            if epsilon > random.random():
                action = np.random.choice(env.action_space) #explore
            else:
                values = self.policy_model.predict(state) #exploit
                action = np.argmax(values)
            experience = env.step(action)
            if(experience['done'] == True):
                episode_reward += experience['reward']
                break
            episode_reward += experience['reward']
            self.push_memory(Experience(experience['state'], experience['action'], experience['reward'], experience['next_state']))
            self.decay_epsilon(episode)
            if self.can_sample_memory():
                memory_sample = self.sample_memory()
                X = []
                Y = []
                for memory in memory_sample:
                    memstate = memory.state
                    action = memory.action
                    next_state = memory.next_state
                    reward = memory.reward
                    max_q = reward + (self.discount_rate * self.replay_model.predict(next_state)) #bellman equation
                    X.append(memstate)
                    Y.append(max_q)
                X = np.array(X)
                X = X.reshape([-1, 600, 600, 2])
                Y = np.array(Y)
                Y = Y.reshape([self.batch_size, 4])
                self.policy_model.fit(X, Y)
        food_eaten = experience["food_eaten"]
        print("Episode: ", episode, " Total Reward: ", episode_reward, " Food Eaten: ", food_eaten)
        if episode % self.target_update == 0:
            self.replay_model.set_weights(self.policy_model.get_weights())
    self.policy_model.save_weights('weights.hdf5')
    pygame.quit()

这是网络架构：

    self.policy_model = Sequential()
    self.policy_model.add(Conv2D(8, (5, 5), padding = 'same', activation = 'relu', data_format = "channels_last", input_shape = (600, 600, 2)))
    self.policy_model.add(Conv2D(16, (5, 5), padding="same", activation="relu"))
    self.policy_model.add(Conv2D(32, (5, 5), padding="same", activation="relu"))
    self.policy_model.add(Flatten())
    self.policy_model.add(Dense(16, activation = "relu"))
    self.policy_model.add(Dense(5, activation = "softmax"))
    rms = keras.optimizers.RMSprop(lr = self.learning_rate) 
    self.policy_model.compile(optimizer = rms, loss = 'mean_squared_error')

这里是超参数：

learning_rate = 1e-4
discount_rate = 0.99
eps_start = 1
eps_end = .01
eps_decay = 1e-5
memory_size = 100000
batch_size = 2
max_episodes = 1000
max_steps = 100000
target_update = 100

我已经让它训练了整整 1000 集，但最后还是很糟糕。我的训练算法有问题吗？

编辑：忘记提到代理会因前往食物而获得 0.5 的奖励，因进食而获得 1 的奖励，因死亡而获得 -1 的奖励

编辑 2：刚刚读到一些 DQN 使用 4 个连续帧的堆栈作为单个样本。考虑到动作有多简单，是否有必要在我的环境中实施？

【问题讨论】：

标签： python keras deep-learning reinforcement-learning q-learning

【解决方案1】：

强化学习算法需要非常低的优化器学习率（例如 1.e-4 或更低），以免学习速度过快和过拟合环境的子空间（看起来像您的问题）。在这里，您似乎使用了优化器的默认学习率（rmsprop，默认为 0.001）。

无论如何，这可能是一个可能的原因:)

【讨论】：

【解决方案2】：

注意ε衰减。随着时间的推移，它设定了勘探勘探权衡。如果您的 epsilon 衰减太大，它将开始利用状态动作空间中非常小的（未探索的）空间。至少在我的大部分时间里，不良政策的早期收敛是由太大的 epsilon 衰减引起的。

【讨论】：