参考资料：

https://morvanzhou.github.io/

非常感谢莫烦老师的教程

http://mnemstudio.org/path-finding-q-learning-tutorial.htm

http://www.cnblogs.com/dragonir/p/6224313.html

这篇文章也是用非常简单的说明将 Q-Learning 的过程给讲解清楚了

http://www.cnblogs.com/jinxulin/tag/%E5%A2%9E%E5%BC%BA%E5%AD%A6%E4%B9%A0/

还有感谢这位园友，将增强学习的原理讲解的非常清晰

深度增强学习（DRL）漫谈 - 从DQN到AlphaGo

这篇文章详细描写了 DQN 的演变过程，建议先看看 

目录：

Deep Q-Network 学习笔记（一）—— Q-Learning

Deep Q-Network 学习笔记（二）—— Q-Learning与神经网络结合使用

这里将使用 tensorflow 框架重写上一篇的示例。

一、思路

Q-Learning与神经网络结合使用就是 Deep Q-Network，简称 DQN。在现实中，状态的数量极多，并且需要人工去设计特征，而且一旦特征设计不好，则得不到想要的结果。

神经网络正是能处理解决这个问题，取代原来 Q 表的功能。

当神经网络与Q-Learning结合使用的时候，又会碰到几个问题：

1.loss 要怎么计算？

增强学习是试错学习(Trail-and-error)，由于没有直接的指导信息，智能体要以不断与环境进行交互，通过试错的方式来获得最佳策略。

Q-Learning正是其中的一种，所以Q值表中表示的是当前已学习到的经验。而根据公式计算出的 Q 值是智能体通过与环境交互及自身的经验总结得到的一个分数（即：目标 Q 值）。

最后使用目标 Q 值(target_q)去更新原来旧的 Q 值(q)。

而目标 Q 值与旧的 Q 值的对应关系，正好是监督学习神经网络中结果值与输出值的对应关系。

所以，loss = (target_q - q)^2

即：整个训练过程其实就是 Q 值(q)向目标 Q 值(target_q)逼近的过程。

2.训练样本哪来？

在 DQN 中有 Experience Replay 的概念，就是经验回放。

就是先让智能体去探索环境，将经验（记忆）池累积到一定程度，在随机抽取出一批样本进行训练。

为什么要随机抽取？因为智能体去探索环境时采集到的样本是一个时间序列，样本之间具有连续性，如果每次得到样本就更新Q值，受样本分布影响，会对收敛造成影响。

从现在开始，一定要理清楚算法的所有思路，比如什么时候该做什么，怎么随机选择动作，神经网络的参数是否调试完成等等，各种问题调试都没结果的，就因为这个卡在这里大半个星期才搞定。

二、模拟流程

1.随机初始化一个状态 s，初始化记忆池，设置观察值。

2.循环遍历（是永久遍历还是只遍历一定次数这个自己设置）：

  （1）根据策略选择一个行为（a）。

  （2）执行该行动(a)，得到奖励（r）、执行该行为后的状态 s`和游戏是否结束 done。

  （3）保存 s, a, r, s`, done 到记忆池里。

  （4）判断记忆池里的数据是否足够（即：记忆池里的数据数量是否超过设置的观察值），如果不够，则转到（5）步。

         ① 在记忆池里随机抽取出一部分数据做为训练样本。

         ② 将所有训练样本的 s`做为神经网络的输入值，进行批量处理，得到 s`状态下每个行为的 q 值的表。

         ③ 根据公式计算出 q 值表对应的 target_q 值表。

             公式：Q(s, a) = r + Gamma * Max[Q(s`, all actions)]

         ④ 使用 q 与 target_q 训练神经网络。

  （5）判断游戏是否结束。

         ① 游戏结束，给 s 随机设置一个状态。

         ① 未结束，则当前状态 s 更新为 s`。

三、代码实现

首先，创建一个类来实现 DQN。

import tensorflow as tfimport numpy as npfrom collections import dequeimport randomclass DeepQNetwork:
    r = np.array([[-1, -1, -1, -1, 0, -1],
                  [-1, -1, -1, 0, -1, 100.0],
                  [-1, -1, -1, 0, -1, -1],
                  [-1, 0, 0, -1, 0, -1],
                  [0, -1, -1, 1, -1, 100],
                  [-1, 0, -1, -1, 0, 100],
                  ])    # 执行步数。
    step_index = 0    # 状态数。
    state_num = 6    # 动作数。
    action_num = 6    # 训练之前观察多少步。
    OBSERVE = 1000.    # 选取的小批量训练样本数。
    BATCH = 20    # epsilon 的最小值，当 epsilon 小于该值时，将不在随机选择行为。
    FINAL_EPSILON = 0.0001    # epsilon 的初始值，epsilon 逐渐减小。
    INITIAL_EPSILON = 0.1    # epsilon 衰减的总步数。
    EXPLORE = 3000000.    # 探索模式计数。
    epsilon = 0    # 训练步数统计。
    learn_step_counter = 0    # 学习率。
    learning_rate = 0.001    # γ经验折损率。
    gamma = 0.9    # 记忆上限。
    memory_size = 5000    # 当前记忆数。
    memory_counter = 0    # 保存观察到的执行过的行动的存储器，即：曾经经历过的记忆。
    replay_memory_store = deque()    # 生成一个状态矩阵（6 X 6），每一行代表一个状态。
    state_list = None    # 生成一个动作矩阵。
    action_list = None    # q_eval 网络。
    q_eval_input = None
    action_input = None
    q_target = None
    q_eval = None
    predict = None
    loss = None
    train_op = None
    cost_his = None
    reward_action = None    # tensorflow 会话。
    session = None    def __init__(self, learning_rate=0.001, gamma=0.9, memory_size=5000):
        self.learning_rate = learning_rate
        self.gamma = gamma
        self.memory_size = memory_size        # 初始化成一个 6 X 6 的状态矩阵。
        self.state_list = np.identity(self.state_num)        # 初始化成一个 6 X 6 的动作矩阵。
        self.action_list = np.identity(self.action_num)        # 创建神经网络。        self.create_network()        # 初始化 tensorflow 会话。
        self.session = tf.InteractiveSession()        # 初始化 tensorflow 参数。        self.session.run(tf.initialize_all_variables())        # 记录所有 loss 变化。
        self.cost_his = []    def create_network(self):        """
        创建神经网络。
        :return:        """
        pass

    def select_action(self, state_index):        """
        根据策略选择动作。
        :param state_index: 当前状态。
        :return:        """
        pass

    def save_store(self, current_state_index, current_action_index, current_reward, next_state_index, done):        """
        保存记忆。
        :param current_state_index: 当前状态 index。
        :param current_action_index: 动作 index。
        :param current_reward: 奖励。
        :param next_state_index: 下一个状态 index。
        :param done: 是否结束。
        :return:        """
        pass

    def step(self, state, action):        """
        执行动作。
        :param state: 当前状态。
        :param action: 执行的动作。
        :return:        """
        pass

    def experience_replay(self):        """
        记忆回放。
        :return:        """
        pass

    def train(self):        """
        训练。
        :return:        """
        pass

    def pay(self):        """
        运行并测试。
        :return:        """
        passif __name__ == "__main__":
    q_network = DeepQNetwork()
    q_network.pay()

1.将状态与动作初始化成以下矩阵，以方便处理。

            图 3.1

 四、创建神经网络

然后，创建一个神经网络，并使用该神经网络来替换掉 Q 值表（上一篇中的 Q 矩阵）

神经网络的输入是 Agent 当前的状态，输出是 Agent 当前状态可以执行的动作的 Q 值表。

由于总共有 6 个状态和 6 种动作，所以，这里将创建一个简单 3 层的神经网络，输入层的参数是 6 个和输出层输出 6 个值，运行并调试好参数，确认能正常运行。

 测试代码：

import tensorflow as tfimport numpy as np

input_num = 6output_num = 6x_data = np.linspace(-1, 1, 300).reshape((-1, input_num))  # 转为列向量noise = np.random.normal(0, 0.05, x_data.shape)
y_data = np.square(x_data) + 0.5 + noise

xs = tf.placeholder(tf.float32, [None, input_num])  # 样本数未知，特征数为 6，占位符最后要以字典形式在运行中填入ys = tf.placeholder(tf.float32, [None, output_num])

neuro_layer_1 = 3w1 = tf.Variable(tf.random_normal([input_num, neuro_layer_1]))
b1 = tf.Variable(tf.zeros([1, neuro_layer_1]) + 0.1)
l1 = tf.nn.relu(tf.matmul(xs, w1) + b1)

neuro_layer_2 = output_num
w2 = tf.Variable(tf.random_normal([neuro_layer_1, neuro_layer_2]))
b2 = tf.Variable(tf.zeros([1, neuro_layer_2]) + 0.1)
l2 = tf.matmul(l1, w2) + b2# reduction_indices=[0] 表示将列数据累加到一起。# reduction_indices=[1] 表示将行数据累加到一起。loss = tf.reduce_mean(tf.reduce_sum(tf.square((ys - l2)), reduction_indices=[1]))# 选择梯度下降法train = tf.train.GradientDescentOptimizer(0.001).minimize(loss)# train = tf.train.AdamOptimizer(1e-1).minimize(loss)init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)for i in range(100000):
    sess.run(train, feed_dict={xs: x_data, ys: y_data})    if i % 1000 == 0:        print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))

执行后 loss 一直持续减少，确认该神经网络正常运行就行了，注意调好学习率和神经网络的层数及神经元个数。

确认正常后，开始实现 DeepQNetwork 类中的 def create_network(self) 函数：

    def create_network(self):        """
        创建神经网络。
        :return:        """
        self.q_eval_input = tf.placeholder(shape=[None, self.state_num], dtype=tf.float32)
        self.action_input = tf.placeholder(shape=[None, self.action_num], dtype=tf.float32)
        self.q_target = tf.placeholder(shape=[None], dtype=tf.float32)

        neuro_layer_1 = 3
        w1 = tf.Variable(tf.random_normal([self.state_num, neuro_layer_1]))
        b1 = tf.Variable(tf.zeros([1, neuro_layer_1]) + 0.1)
        l1 = tf.nn.relu(tf.matmul(self.q_eval_input, w1) + b1)

        w2 = tf.Variable(tf.random_normal([neuro_layer_1, self.action_num]))
        b2 = tf.Variable(tf.zeros([1, self.action_num]) + 0.1)
        self.q_eval = tf.matmul(l1, w2) + b2        # 取出当前动作的得分。
        self.reward_action = tf.reduce_sum(tf.multiply(self.q_eval, self.action_input), reduction_indices=1)
        self.loss = tf.reduce_mean(tf.square((self.q_target - self.reward_action)))
        self.train_op = tf.train.GradientDescentOptimizer(self.learning_rate).minimize(self.loss)

        self.predict = tf.argmax(self.q_eval, 1)

这里说明一下 loss 的计算，由于状态是根据图 3.1 的矩阵的方式显示的，比如，当前状态如果是在 1 号房间，

则输入参数（q_eval_input）的值是：[[0, 1, 0, 0, 0, 0]]

由于 Agent 执行了动作 3，也就是移动到了 3 号房间，

所以 Agent 的动作参数（action_input）的值是：[[0, 0, 0, 1, 0, 0]]

因为神经网络的输出结果（q_eval）是 Agent 当前状态下可执行的动作的价值，由于每个状态都有 6 个动作，而状态数也是 6 个，所以

神经网络的输出结果（q_eval）与输入参数是一样的，所以输出的格式也一样，

假设输出结果（q_eval）是：[[0.81, 0.5, 0.24, 0.513, 0.9, 0.71]]

tf.multiply(self.q_eval, self.action_input)

就是矩阵的点积，也就是每个元素分别相乘。

这里表示的就是获得 Agent 执行了 action_input 的价值（Q 值）。

也就是 q = q_eval * action_input = [[0, 0, 0, 0.513, 0, 0]]

所以：

self.reward_action = tf.reduce_sum(tf.multiply(self.q_eval, self.action_input), reduction_indices=1)

也就相当于：q = SUM(q_eval * action_input) = SUM([[0, 0, 0, 0.513, 0, 0, 0]]) = 0.513

即：Agent 在 1 号房间执行移动到 3 号房间动作时，神经网络给出的价值（q 值）是 0.513 分

而 q_target 在前面也提过，是 Agent 经过环境体验后，根据公式计算出来的目标 q 值，假设该值是 1.03 分

所以：

self.loss = tf.reduce_mean(tf.square((self.q_target - self.reward_action)))

就相当于：

loss = ((1.03 - 0.513)^2) / 1 = 0.267289

然后，learning_rate 也就是学习率，经过调试，这里是设置成 0.001 比较好。

五、搜索动作策略

这里是 DQN 需要注意的地方之一，这里的方法将直接影响到 DQN 是否可以收敛，或者是否是陷入局部最小值等情况。

现在在这里选择了最直接的方法，使用随机的方式来选择行动。

使用随机的方式来选择行动，可以让 Agent 能得到更多的探索机会，这样在训练时才能有效的跳出陷入局部最小值的情况，当训练时，可以减少探索机会。

流程如下：

    1.初始化 epsilon 变量，并设置它的最小值（FINAL_EPSILON）与最大值（INITIAL_EPSILON），并将 epsilon 的初始值设置成 INITIAL_EPSILON。

    2.随机生成一个数 n。

    3.判断 n 是否小于 epsilon，如果 n 小于 epsilon 则转到 4，否则转到 5。

    4.使用随机策略（增加探索机会），转到 6。

       随机选择一个在 Agent 当前状态下可以执行的动作。

    5.使用神经网络直接计算出结果（实际应用时也是应用这方法），转到6。

       神经网络会输出在当前状态下所有动作的 Q 值，选择其中最有价值（Q 值最大）的动作返回。

    6.判断是否开始训练，如果是，则逐步减少 epsilon 来减少探索机会，否则跳过。

开始实现 DeepQNetwork 类中的 def select_action(self, state_index) 函数：

    def select_action(self, state_index):        """
        根据策略选择动作。
        :param state_index: 当前状态。
        :return:        """
        current_state = self.state_list[state_index:state_index + 1]        if np.random.uniform() < self.epsilon:
            current_action_index = np.random.randint(0, self.action_num)        else:
            actions_value = self.session.run(self.q_eval, feed_dict={self.q_eval_input: current_state})
            action = np.argmax(actions_value)
            current_action_index = action        # 开始训练后，在 epsilon 小于一定的值之前，将逐步减小 epsilon。
        if self.step_index > self.OBSERVE and self.epsilon > self.FINAL_EPSILON:
            self.epsilon -= (self.INITIAL_EPSILON - self.FINAL_EPSILON) / self.EXPLORE        return current_action_index

六、保存记忆

 这里使用了一个先进先出的队列，设置好队列的 size，直接将“当前状态”、“执行动作”、“奖励分数”、“下一个状态”和“游戏是否结束”保存进去就行了。

 开始实现 DeepQNetwork 类中的 def save_store(self, current_state_index, current_action_

http://www.cnblogs.com/cjnmy36723/p/7018860.html

延伸阅读

• Go语言学习笔记（二）十分钟上手 2017-07-25 16:09:40.183
• 函数响应式编程及ReactiveObjC学习笔记 (二) 2017-07-24 14:54:16.417
• Django 学习笔记（二）第一个网页 2017-07-11 16:14:35.22
• Vue.js学习笔记（二） - 常用模板语法 2017-07-11 10:06:31.377
• thinkphp5.0学习笔记（二）API后台处理与命名空间 2017-06-19 14:30:16.103
• docker - 关于network的一些理解 2017-06-02 16:47:16.497
• LCD驱动移植在在mini2440(linux2.6.29)和FS4412(linux3.14.78)上实现对比（deep dive） 2017-05-12 15:59:24.977
• Python 学习笔记二 2017-05-10 16:47:24.21
• Neural Networks and Deep Learning(神经网络与深度学习) - 学习笔记 2017-05-08 17:15:13.003
• [Keras] Develop Neural Network With Keras Step-By-Step 2017-04-13 15:47:41.497

Go语言学习笔记（二）十分钟上手