【RL 第4章】Deep Q-Learning（DQN）

最新推荐文章于 2024-07-06 09:57:48 发布

LiWilling in NPU

最新推荐文章于 2024-07-06 09:57:48 发布

阅读量270

点赞数

分类专栏： RL 文章标签：深度学习人工智能

本文链接：https://blog.csdn.net/qq_51542439/article/details/128674181

版权

RL 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

#本来是不想写这章的，因为Willing不确定这章对于我们项目是否会有帮助(￣△￣；)，或者Willing凭直觉来看这章的帮助将会很小，但还是写了一写，这章目测要用到OpenAi的Gym库，这个因为Willing的Python版本问题，暂时没跑出来结果（后文会讲），但还是把代码给大家放上去。总的来说，还是感觉写一写能好些，之前参与过CNN的项目，这个也算是Willing遇见的第二种神经网络了(・-・*)

在本章中，我们会将之前所讲过的Q-Learning算法融入进神经网络中，从而诞生出我们今天所讲的内容——DQN网络。

在前几张（Q-Learning和Sarsa）中，我们训练得到这样一张Q表（如下图），它可以让我们根据当前位置，做出收益最大的选择，也就是相当于一张“行动指南”，但是，之前所讲的例子的State仅仅只有6个，一张图还能勉强放下，若是在生活中，遇到超超超超级多的State时（下文会提到），我们还能用Q表去算吗？在本章中，我们已经没有明确数目的State了，换句话讲，我们将训练一个Ai帮助我们去打游戏。

相信米娜桑都玩过上面这款游戏：Flappy Bird。在前几章，我们知道一共就有6个State，即6个房间，但在这个游戏中，只有一帧帧游戏画面，又有多少个State呢？

可能有同学会问了：游戏画面不是由像素点构成吗？我们可以取像素点为State呀？好的，那我们可以这样处理：首先，我们将图片设定为84x84，接下来，我们取连续的四帧为一个batch，也就是说，这四张图片一共包含了84x84x4个像素点，因为是灰度图片，每一个像素点取值为0~255中的一个，即有256种可能，所以说，如果用像素点作为State，一共有：256^（84x84x4)个State！！！！拜托~这也太多了吧╥﹏╥...

这么多的State，我们肯定是不用Q表来做的，但是，大家仔细想一想，我们训练出一个Q表的目的，不就是让它帮助我们做一次决策，也就是说，我们输入当前的状态State，它输出我们如何去走，这样，即便Q表是没法做出来，但我们可以交给神经网络去做。

上图就是我们构建的神经网络的具体内容，我们用80x80x4的内容为batch，经过中间很多卷积和池化的操作（这里就不具体解释啦，不了解的朋友可以观看李永乐老师这期视频：李永乐老师讲神经网络）最后神经网络会输出往上飞还是往下飞，收益是最大的。

ok了，上面这个案例是关于DQN在训练Ai玩游戏上的应用，如果有大佬对后面代码部分感兴趣，可以点击链接用强化学习训练Flappy Bird自行学习，老师是带着大家一行一行撸代码的，需要用到tensorflow、cv等，需要提前下载安装。

下面，Willing在网上也找到了一个摇摆车的案例，所使用的是gym库，也是通过DQN进行训练的，源代码如下：

import random
import gym
import numpy as np
from collections import deque
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam



EPISODES = 5000


class DQNAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.memory = deque(maxlen=2000)
        self.gamma = 0.95  # discount rate
        self.epsilon = 1.  # exploration rate
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.learning_rate = 0.001
        self.model = self._build_model()

    def _build_model(self):
        model = Sequential()
        model.add(Dense(24, input_dim=self.state_size, activation='relu'))
        model.add(Dense(24, activation='relu'))
        model.add(Dense(self.action_size, activation='linear'))
        model.compile(loss='mse',
                      optimizer=Adam(lr=self.learning_rate))
        return model

    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))

    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return random.randrange(self.action_size)
        act_values = self.model.predict(state)
        return np.argmax(act_values[0])  # returns action

    def replay(self, batch_size):
        minibatch = random.sample(self.memory, batch_size)
        for state, action, reward, next_state, done in minibatch:
            target = reward
            if not done:
                target = (reward + self.gamma *
                          np.amax(self.model.predict(next_state)[0]))
            target_f = self.model.predict(state)

            # 根据公式更新Q表
            # Q(s,a) = R(s,a)+λmax{Q(s`,a`)}
            # target_f 当前状态的Q值 target下一状态的Q值
            target_f[0][action] = target

            self.model.fit(state, target_f, epochs=1, verbose=0)
        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

    def load(self, name):
        self.model.load_weights(name)

    def save(self, name):
        self.model.save_weights(name)


if __name__ == "__main__":
    env = gym.make('CartPole-v0')
    state_size = env.observation_space.shape[0]
    action_size = env.action_space.n
    agent = DQNAgent(state_size, action_size)
    agent.load('./weights/cartpole-dqn.h5')
    done = False
    batch_size = 32

    for e in range(EPISODES):
        state = env.reset()
        state = np.reshape(state, [1, state_size])
        for time in range(500):
            env.render()
            action = agent.act(state)
            next_state, reward, done, _ = env.step(action)
            reward = reward if not done else -10
            next_state = np.reshape(next_state, [1, state_size])
            agent.remember(state, action, reward, next_state, done)
            state = next_state
            if done:
                print("episode: {}/{}, score: {}, e: {:.2}"
                      .format(e, EPISODES, time, agent.epsilon))
                break
        # if len(agent.memory) > batch_size:
        #     agent.replay(batch_size)
        #     if e % 10 == 0:
        #         agent.save("./wei

Willing这边跑了一下，结果一堆报错(ಥ _ ಥ)，目前还在调试ing.....