参考资料：

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。

  1. import tensorflow as tf
  2. import numpy as np
  3. from collections import deque
  4. import random
  5.  
  6. class DeepQNetwork:
  7.     r = np.array([[-1, -1, -1, -1, 0, -1],
  8.                   [-1, -1, -1, 0, -1, 100.0],
  9.                   [-1, -1, -1, 0, -1, -1],
  10.                   [-1, 0, 0, -1, 0, -1],
  11.                   [0, -1, -1, 1, -1, 100],
  12.                   [-1, 0, -1, -1, 0, 100],
  13.                   ])
  14.  
  15.     # 执行步数。
  16.     step_index = 0
  17.  
  18.     # 状态数。
  19.     state_num = 6
  20.  
  21.     # 动作数。
  22.     action_num = 6
  23.  
  24.     # 训练之前观察多少步。
  25.     OBSERVE = 1000.
  26.  
  27.     # 选取的小批量训练样本数。
  28.     BATCH = 20
  29.  
  30.     # epsilon 的最小值，当 epsilon 小于该值时，将不在随机选择行为。
  31.     FINAL_EPSILON = 0.0001
  32.  
  33.     # epsilon 的初始值，epsilon 逐渐减小。
  34.     INITIAL_EPSILON = 0.1
  35.  
  36.     # epsilon 衰减的总步数。
  37.     EXPLORE = 3000000.
  38.  
  39.     # 探索模式计数。
  40.     epsilon = 0
  41.  
  42.     # 训练步数统计。
  43.     learn_step_counter = 0
  44.  
  45.     # 学习率。
  46.     learning_rate = 0.001
  47.  
  48.     # γ经验折损率。
  49.     gamma = 0.9
  50.  
  51.     # 记忆上限。
  52.     memory_size = 5000
  53.  
  54.     # 当前记忆数。
  55.     memory_counter = 0
  56.  
  57.     # 保存观察到的执行过的行动的存储器，即：曾经经历过的记忆。
  58.     replay_memory_store = deque()
  59.  
  60.     # 生成一个状态矩阵（6 X 6），每一行代表一个状态。
  61.     state_list = None
  62.  
  63.     # 生成一个动作矩阵。
  64.     action_list = None
  65.  
  66.     # q_eval 网络。
  67.     q_eval_input = None
  68.     action_input = None
  69.     q_target = None
  70.     q_eval = None
  71.     predict = None
  72.     loss = None
  73.     train_op = None
  74.     cost_his = None
  75.     reward_action = None
  76.  
  77.     # tensorflow 会话。
  78.     session = None
  79.  
  80.     def __init__(self, learning_rate=0.001, gamma=0.9, memory_size=5000):
  81.         self.learning_rate = learning_rate
  82.         self.gamma = gamma
  83.         self.memory_size = memory_size
  84.  
  85.         # 初始化成一个 6 X 6 的状态矩阵。
  86.         self.state_list = np.identity(self.state_num)
  87.  
  88.         # 初始化成一个 6 X 6 的动作矩阵。
  89.         self.action_list = np.identity(self.action_num)
  90.  
  91.         # 创建神经网络。
  92.         self.create_network()
  93.  
  94.         # 初始化 tensorflow 会话。
  95.         self.session = tf.InteractiveSession()
  96.  
  97.         # 初始化 tensorflow 参数。
  98.         self.session.run(tf.initialize_all_variables())
  99.  
  100.         # 记录所有 loss 变化。
  101.         self.cost_his = []
  102.  
  103.     def create_network(self):
  104.         """
  105.         创建神经网络。
  106.         :return:
  107.         """
  108.         pass
  109.  
  110.     def select_action(self, state_index):
  111.         """
  112.         根据策略选择动作。
  113.         :param state_index: 当前状态。
  114.         :return:
  115.         """
  116.         pass
  117.  
  118.     def save_store(self, current_state_index, current_action_index, current_reward, next_state_index, done):
  119.         """
  120.         保存记忆。
  121.         :param current_state_index: 当前状态 index。
  122.         :param current_action_index: 动作 index。
  123.         :param current_reward: 奖励。
  124.         :param next_state_index: 下一个状态 index。
  125.         :param done: 是否结束。
  126.         :return:
  127.         """
  128.         pass
  129.  
  130.     def step(self, state, action):
  131.         """
  132.         执行动作。
  133.         :param state: 当前状态。
  134.         :param action: 执行的动作。
  135.         :return:
  136.         """
  137.         pass
  138.  
  139.     def experience_replay(self):
  140.         """
  141.         记忆回放。
  142.         :return:
  143.         """
  144.         pass
  145.  
  146.     def train(self):
  147.         """
  148.         训练。
  149.         :return:
  150.         """
  151.         pass
  152.  
  153.     def pay(self):
  154.         """
  155.         运行并测试。
  156.         :return:
  157.         """
  158.         pass
  159.  
  160. if __name__ == "__main__":
  161.     q_network = DeepQNetwork()
  162.     q_network.pay()

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

图 3.1

四、创建神经网络

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

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

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

测试代码：

  1. import tensorflow as tf
  2. import numpy as np
  3.  
  4. input_num = 6
  5. output_num = 6
  6. x_data = np.linspace(-1, 1, 300).reshape((-1, input_num))  # 转为列向量
  7.  
  8. noise = np.random.normal(0, 0.05, x_data.shape)
  9. y_data = np.square(x_data) + 0.5 + noise
  10.  
  11. xs = tf.placeholder(tf.float32, [None, input_num])  # 样本数未知，特征数为 6，占位符最后要以字典形式在运行中填入
  12. ys = tf.placeholder(tf.float32, [None, output_num])
  13.  
  14. neuro_layer_1 = 3
  15. w1 = tf.Variable(tf.random_normal([input_num, neuro_layer_1]))
  16. b1 = tf.Variable(tf.zeros([1, neuro_layer_1]) + 0.1)
  17. l1 = tf.nn.relu(tf.matmul(xs, w1) + b1)
  18.  
  19. neuro_layer_2 = output_num
  20. w2 = tf.Variable(tf.random_normal([neuro_layer_1, neuro_layer_2]))
  21. b2 = tf.Variable(tf.zeros([1, neuro_layer_2]) + 0.1)
  22. l2 = tf.matmul(l1, w2) + b2
  23.  
  24. # reduction_indices=[0] 表示将列数据累加到一起。
  25. # reduction_indices=[1] 表示将行数据累加到一起。
  26. loss = tf.reduce_mean(tf.reduce_sum(tf.square((ys - l2)), reduction_indices=[1]))
  27.  
  28. # 选择梯度下降法
  29. train = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
  30. # train = tf.train.AdamOptimizer(1e-1).minimize(loss)
  31.  
  32. init = tf.initialize_all_variables()
  33. sess = tf.Session()
  34. sess.run(init)
  35.  
  36. for i in range(100000):
  37.     sess.run(train, feed_dict={xs: x_data, ys: y_data})
  38.     if i % 1000 == 0:
  39.         print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))

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

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

  1.     def create_network(self):
  2.         """
  3.         创建神经网络。
  4.         :return:
  5.         """
  6.         self.q_eval_input = tf.placeholder(shape=[None, self.state_num], dtype=tf.float32)
  7.         self.action_input = tf.placeholder(shape=[None, self.action_num], dtype=tf.float32)
  8.         self.q_target = tf.placeholder(shape=[None], dtype=tf.float32)
  9.  
  10.         neuro_layer_1 = 3
  11.         w1 = tf.Variable(tf.random_normal([self.state_num, neuro_layer_1]))
  12.         b1 = tf.Variable(tf.zeros([1, neuro_layer_1]) + 0.1)
  13.         l1 = tf.nn.relu(tf.matmul(self.q_eval_input, w1) + b1)
  14.  
  15.         w2 = tf.Variable(tf.random_normal([neuro_layer_1, self.action_num]))
  16.         b2 = tf.Variable(tf.zeros([1, self.action_num]) + 0.1)
  17.         self.q_eval = tf.matmul(l1, w2) + b2
  18.  
  19.         # 取出当前动作的得分。
  20.         self.reward_action = tf.reduce_sum(tf.multiply(self.q_eval, self.action_input), reduction_indices=1)
  21.         self.loss = tf.reduce_mean(tf.square((self.q_target - self.reward_action)))
  22.         self.train_op = tf.train.GradientDescentOptimizer(self.learning_rate).minimize(self.loss)
  23.  
  24.         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]]

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

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

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

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

所以：

  1. 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 分

所以：

  1. 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 则转到，否则转到 5。

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

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

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

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

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

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

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

六、保存记忆

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

开始实现 DeepQNetwork 类中的 def save_store(self, current_state_index, current_action_index, current_reward, next_state_index, done) 函数：

  1.     def save_store(self, current_state_index, current_action_index, current_reward, next_state_index, done):
  2.         """
  3.         保存记忆。
  4.         :param current_state_index: 当前状态 index。
  5.         :param current_action_index: 动作 index。
  6.         :param current_reward: 奖励。
  7.         :param next_state_index: 下一个状态 index。
  8.         :param done: 是否结束。
  9.         :return:
  10.         """
  11.         current_state = self.state_list[current_state_index:current_state_index + 1]
  12.         current_action = self.action_list[current_action_index:current_action_index + 1]
  13.         next_state = self.state_list[next_state_index:next_state_index + 1]
  14.         # 记忆动作(当前状态， 当前执行的动作， 当前动作的得分，下一个状态)。
  15.         self.replay_memory_store.append((
  16.             current_state,
  17.             current_action,
  18.             current_reward,
  19.             next_state,
  20.             done))
  21.  
  22.         # 如果超过记忆的容量，则将最久远的记忆移除。
  23.         if len(self.replay_memory_store) > self.memory_size:
  24.             self.replay_memory_store.popleft()
  25.  
  26.         self.memory_counter += 1

七、执行动作

这里就是取得游戏是否结束状态，动作奖励和下一个状态并返回就可以了。

开始实现 DeepQNetwork 类中的 def step(self, state, action) 函数：

  1.     def step(self, state, action):
  2.         """
  3.         执行动作。
  4.         :param state: 当前状态。
  5.         :param action: 执行的动作。
  6.         :return:
  7.         """
  8.         reward = self.r[state][action]
  9.  
  10.         next_state = action
  11.  
  12.         done = False
  13.  
  14.         if action == 5:
  15.             done = True
  16.  
  17.         return next_state, reward, done

八、记忆回放

这是 DQN 的重点之一，在记忆池里随机抽取出一小批的数据当做训练样本，并计算出目标 Q 值来训练神经网络。

流程如下：

1. 初始化时先设置抽取的样本数。

2. 从记忆池里随机抽取出一批样本。

3. 由于每条样本中，都保存有当时的数据（当前状态，动作，奖励分数，下一个状态，是否结束），所以，为了计算出这些样本数据的目标 Q 值，就必须先取出样本中“下一个状态（next_state）”（注意：这里取到的是所有这批样本的“下一个状态”的列表！）。

4. 将 next_state （这是批数据！！）当做参数传入神经网络，得到 Agent 在 next_state 状态时所有可执行的动作的 Q 值表（q_next），q_next 表示这批样本中所有的 next_state 状态的 Q 值表的集合。

5. 现在，已经拿到了

        Agent 当时的状态（state），

        当时的动作（action），

        当时的状态（state）下执行动作（action）得到的奖励R(state, action)，

        当时的状态（state）下执行动作（action）后的状态（next_state）下所有可执行的动作的 Q 值表（q_next）。

现在就可以使用上面提到的公式来计算出目标 Q 值Q(state, action)。

Q(state, action) = R(state, action) + Gamma * Max{q_next}

6. 根据游戏状态判断，当前选择的动作是否是违规（不可执行）的动作，如果是，则不做经验计算，直接扣除分数，否则使用上面的公式来计算出Q(state, action)。违规的动作，在搜索动作的时候，是不应该能选择出来的，即：能走到这一步的都必须是有效动作！

7. 将计算得到的所有样本的 Q(state, action) 保存到集合中（q_target）。

8. 将这批样本的当前状态的集合，动作的集合与 q_target 传入神经网络并进行训练。

特别注意第 6 条的内容，如果这里处理不好，一样会得不到结果的，具体原因可以看上一篇 。

开始实现 DeepQNetwork 类中的 def experience_replay(self)函数：

  1.     def experience_replay(self):
  2.         """
  3.         记忆回放。
  4.         :return:
  5.         """
  6.         # 随机选择一小批记忆样本。
  7.         batch = self.BATCH if self.memory_counter > self.BATCH else self.memory_counter
  8.         minibatch = random.sample(self.replay_memory_store, batch)
  9.  
  10.         batch_state = None
  11.         batch_action = None
  12.         batch_reward = None
  13.         batch_next_state = None
  14.         batch_done = None
  15.  
  16.         for index in range(len(minibatch)):
  17.             if batch_state is None:
  18.                 batch_state = minibatch[index][0]
  19.             elif batch_state is not None:
  20.                 batch_state = np.vstack((batch_state, minibatch[index][0]))
  21.  
  22.             if batch_action is None:
  23.                 batch_action = minibatch[index][1]
  24.             elif batch_action is not None:
  25.                 batch_action = np.vstack((batch_action, minibatch[index][1]))
  26.  
  27.             if batch_reward is None:
  28.                 batch_reward = minibatch[index][2]
  29.             elif batch_reward is not None:
  30.                 batch_reward = np.vstack((batch_reward, minibatch[index][2]))
  31.  
  32.             if batch_next_state is None:
  33.                 batch_next_state = minibatch[index][3]
  34.             elif batch_next_state is not None:
  35.                 batch_next_state = np.vstack((batch_next_state, minibatch[index][3]))
  36.  
  37.             if batch_done is None:
  38.                 batch_done = minibatch[index][4]
  39.             elif batch_done is not None:
  40.                 batch_done = np.vstack((batch_done, minibatch[index][4]))
  41.  
  42.         # q_next：下一个状态的 Q 值。
  43.         q_next = self.session.run([self.q_eval], feed_dict={self.q_eval_input: batch_next_state})
  44.  
  45.         q_target = []
  46.         for i in range(len(minibatch)):
  47.             # 当前即时得分。
  48.             current_reward = batch_reward[i][0]
  49.  
  50.             # # 游戏是否结束。
  51.             # current_done = batch_done[i][0]
  52.  
  53.             # 更新 Q 值。
  54.             q_value = current_reward + self.gamma * np.max(q_next[0][i])
  55.  
  56.             # 当得分小于 -1 时，表示走了不可走的位置。
  57.             if current_reward <= -1:
  58.                 q_target.append(current_reward)
  59.             else:
  60.                 q_target.append(q_value)
  61.  
  62.         _, cost, reward = self.session.run([self.train_op, self.loss, self.reward_action],
  63.                                            feed_dict={self.q_eval_input: batch_state,
  64.                                                       self.action_input: batch_action,
  65.                                                       self.q_target: q_target})
  66.  
  67.         self.cost_his.append(cost)
  68.  
  69.         # if self.step_index % 1000 == 0:
  70.         #     print("loss:", cost)
  71.  
  72.         self.learn_step_counter += 1

九、训练

这部分在前面都分析过了，看看就行了。

实现 DeepQNetwork 类中的 def train(self)函数：

  1.     def train(self):
  2.         """
  3.         训练。
  4.         :return:
  5.         """
  6.         # 初始化当前状态。
  7.         current_state = np.random.randint(0, self.action_num - 1)
  8.         self.epsilon = self.INITIAL_EPSILON
  9.  
  10.         while True:
  11.             # 选择动作。
  12.             action = self.select_action(current_state)
  13.  
  14.             # 执行动作，得到：下一个状态，执行动作的得分，是否结束。
  15.             next_state, reward, done = self.step(current_state, action)
  16.  
  17.             # 保存记忆。
  18.             self.save_store(current_state, action, reward, next_state, done)
  19.  
  20.             # 先观察一段时间累积足够的记忆在进行训练。
  21.             if self.step_index > self.OBSERVE:
  22.                 self.experience_replay()
  23.  
  24.             if self.step_index > 10000:
  25.                 break
  26.  
  27.             if done:
  28.                 current_state = np.random.randint(0, self.action_num - 1)
  29.             else:
  30.                 current_state = next_state
  31.  
  32.             self.step_index += 1

十、执行并测试训练结果

实现 DeepQNetwork 类中的 def pay(self)函数：

  1.     def pay(self):
  2.         """
  3.         运行并测试。
  4.         :return:
  5.         """
  6.         self.train()
  7.  
  8.         # 显示 R 矩阵。
  9.         print(self.r)
  10.  
  11.         for index in range(5):
  12.  
  13.             start_room = index
  14.  
  15.             print("#############################", "Agent 在", start_room, "开始行动", "#############################")
  16.  
  17.             current_state = start_room
  18.  
  19.             step = 0
  20.  
  21.             target_state = 5
  22.  
  23.             while current_state != target_state:
  24.                 out_result = self.session.run(self.q_eval, feed_dict={
  25.                     self.q_eval_input: self.state_list[current_state:current_state + 1]})
  26.  
  27.                 next_state = np.argmax(out_result[0])
  28.  
  29.                 print("Agent 由", current_state, "号房间移动到了", next_state, "号房间")
  30.  
  31.                 current_state = next_state
  32.  
  33.                 step += 1
  34.  
  35.             print("Agent 在", start_room, "号房间开始移动了", step, "步到达了目标房间 5")
  36.  
  37.             print("#############################", "Agent 在", 5, "结束行动", "#############################")

十一、完整源码

  1. import tensorflow as tf
  2. import numpy as np
  3. from collections import deque
  4. import random
  5.  
  6. class DeepQNetwork:
  7.     r = np.array([[-1, -1, -1, -1, 0, -1],
  8.                   [-1, -1, -1, 0, -1, 100.0],
  9.                   [-1, -1, -1, 0, -1, -1],
  10.                   [-1, 0, 0, -1, 0, -1],
  11.                   [0, -1, -1, 1, -1, 100],
  12.                   [-1, 0, -1, -1, 0, 100],
  13.                   ])
  14.  
  15.     # 执行步数。
  16.     step_index = 0
  17.  
  18.     # 状态数。
  19.     state_num = 6
  20.  
  21.     # 动作数。
  22.     action_num = 6
  23.  
  24.     # 训练之前观察多少步。
  25.     OBSERVE = 1000.
  26.  
  27.     # 选取的小批量训练样本数。
  28.     BATCH = 20
  29.  
  30.     # epsilon 的最小值，当 epsilon 小于该值时，将不在随机选择行为。
  31.     FINAL_EPSILON = 0.0001
  32.  
  33.     # epsilon 的初始值，epsilon 逐渐减小。
  34.     INITIAL_EPSILON = 0.1
  35.  
  36.     # epsilon 衰减的总步数。
  37.     EXPLORE = 3000000.
  38.  
  39.     # 探索模式计数。
  40.     epsilon = 0
  41.  
  42.     # 训练步数统计。
  43.     learn_step_counter = 0
  44.  
  45.     # 学习率。
  46.     learning_rate = 0.001
  47.  
  48.     # γ经验折损率。
  49.     gamma = 0.9
  50.  
  51.     # 记忆上限。
  52.     memory_size = 5000
  53.  
  54.     # 当前记忆数。
  55.     memory_counter = 0
  56.  
  57.     # 保存观察到的执行过的行动的存储器，即：曾经经历过的记忆。
  58.     replay_memory_store = deque()
  59.  
  60.     # 生成一个状态矩阵（6 X 6），每一行代表一个状态。
  61.     state_list = None
  62.  
  63.     # 生成一个动作矩阵。
  64.     action_list = None
  65.  
  66.     # q_eval 网络。
  67.     q_eval_input = None
  68.     action_input = None
  69.     q_target = None
  70.     q_eval = None
  71.     predict = None
  72.     loss = None
  73.     train_op = None
  74.     cost_his = None
  75.     reward_action = None
  76.  
  77.     # tensorflow 会话。
  78.     session = None
  79.  
  80.     def __init__(self, learning_rate=0.001, gamma=0.9, memory_size=5000):
  81.         self.learning_rate = learning_rate
  82.         self.gamma = gamma
  83.         self.memory_size = memory_size
  84.  
  85.         # 初始化成一个 6 X 6 的状态矩阵。
  86.         self.state_list = np.identity(self.state_num)
  87.  
  88.         # 初始化成一个 6 X 6 的动作矩阵。
  89.         self.action_list = np.identity(self.action_num)
  90.  
  91.         # 创建神经网络。
  92.         self.create_network()
  93.  
  94.         # 初始化 tensorflow 会话。
  95.         self.session = tf.InteractiveSession()
  96.  
  97.         # 初始化 tensorflow 参数。
  98.         self.session.run(tf.initialize_all_variables())
  99.  
  100.         # 记录所有 loss 变化。
  101.         self.cost_his = []
  102.  
  103.     def create_network(self):
  104.         """
  105.         创建神经网络。
  106.         :return:
  107.         """
  108.         self.q_eval_input = tf.placeholder(shape=[None, self.state_num], dtype=tf.float32)
  109.         self.action_input = tf.placeholder(shape=[None, self.action_num], dtype=tf.float32)
  110.         self.q_target = tf.placeholder(shape=[None], dtype=tf.float32)
  111.  
  112.         neuro_layer_1 = 3
  113.         w1 = tf.Variable(tf.random_normal([self.state_num, neuro_layer_1]))
  114.         b1 = tf.Variable(tf.zeros([1, neuro_layer_1]) + 0.1)
  115.         l1 = tf.nn.relu(tf.matmul(self.q_eval_input, w1) + b1)
  116.  
  117.         w2 = tf.Variable(tf.random_normal([neuro_layer_1, self.action_num]))
  118.         b2 = tf.Variable(tf.zeros([1, self.action_num]) + 0.1)
  119.         self.q_eval = tf.matmul(l1, w2) + b2
  120.  
  121.         # 取出当前动作的得分。
  122.         self.reward_action = tf.reduce_sum(tf.multiply(self.q_eval, self.action_input), reduction_indices=1)
  123.         self.loss = tf.reduce_mean(tf.square((self.q_target - self.reward_action)))
  124.         self.train_op = tf.train.GradientDescentOptimizer(self.learning_rate).minimize(self.loss)
  125.  
  126.         self.predict = tf.argmax(self.q_eval, 1)
  127.  
  128.     def select_action(self, state_index):
  129.         """
  130.         根据策略选择动作。
  131.         :param state_index: 当前状态。
  132.         :return:
  133.         """
  134.         current_state = self.state_list[state_index:state_index + 1]
  135.  
  136.         if np.random.uniform() < self.epsilon:
  137.             current_action_index = np.random.randint(0, self.action_num)
  138.         else:
  139.             actions_value = self.session.run(self.q_eval, feed_dict={self.q_eval_input: current_state})
  140.             action = np.argmax(actions_value)
  141.             current_action_index = action
  142.  
  143.         # 开始训练后，在 epsilon 小于一定的值之前，将逐步减小 epsilon。
  144.         if self.step_index > self.OBSERVE and self.epsilon > self.FINAL_EPSILON:
  145.             self.epsilon -= (self.INITIAL_EPSILON - self.FINAL_EPSILON) / self.EXPLORE
  146.  
  147.         return current_action_index
  148.  
  149.     def save_store(self, current_state_index, current_action_index, current_reward, next_state_index, done):
  150.         """
  151.         保存记忆。
  152.         :param current_state_index: 当前状态 index。
  153.         :param current_action_index: 动作 index。
  154.         :param current_reward: 奖励。
  155.         :param next_state_index: 下一个状态 index。
  156.         :param done: 是否结束。
  157.         :return:
  158.         """
  159.         current_state = self.state_list[current_state_index:current_state_index + 1]
  160.         current_action = self.action_list[current_action_index:current_action_index + 1]
  161.         next_state = self.state_list[next_state_index:next_state_index + 1]
  162.         # 记忆动作(当前状态， 当前执行的动作， 当前动作的得分，下一个状态)。
  163.         self.replay_memory_store.append((
  164.             current_state,
  165.             current_action,
  166.             current_reward,
  167.             next_state,
  168.             done))
  169.  
  170.         # 如果超过记忆的容量，则将最久远的记忆移除。
  171.         if len(self.replay_memory_store) > self.memory_size:
  172.             self.replay_memory_store.popleft()
  173.  
  174.         self.memory_counter += 1
  175.  
  176.     def step(self, state, action):
  177.         """
  178.         执行动作。
  179.         :param state: 当前状态。
  180.         :param action: 执行的动作。
  181.         :return:
  182.         """
  183.         reward = self.r[state][action]
  184.  
  185.         next_state = action
  186.  
  187.         done = False
  188.  
  189.         if action == 5:
  190.             done = True
  191.  
  192.         return next_state, reward, done
  193.  
  194.     def experience_replay(self):
  195.         """
  196.         记忆回放。
  197.         :return:
  198.         """
  199.         # 随机选择一小批记忆样本。
  200.         batch = self.BATCH if self.memory_counter > self.BATCH else self.memory_counter
  201.         minibatch = random.sample(self.replay_memory_store, batch)
  202.  
  203.         batch_state = None
  204.         batch_action = None
  205.         batch_reward = None
  206.         batch_next_state = None
  207.         batch_done = None
  208.  
  209.         for index in range(len(minibatch)):
  210.             if batch_state is None:
  211.                 batch_state = minibatch[index][0]
  212.             elif batch_state is not None:
  213.                 batch_state = np.vstack((batch_state, minibatch[index][0]))
  214.  
  215.             if batch_action is None:
  216.                 batch_action = minibatch[index][1]
  217.             elif batch_action is not None:
  218.                 batch_action = np.vstack((batch_action, minibatch[index][1]))
  219.  
  220.             if batch_reward is None:
  221.                 batch_reward = minibatch[index][2]
  222.             elif batch_reward is not None:
  223.                 batch_reward = np.vstack((batch_reward, minibatch[index][2]))
  224.  
  225.             if batch_next_state is None:
  226.                 batch_next_state = minibatch[index][3]
  227.             elif batch_next_state is not None:
  228.                 batch_next_state = np.vstack((batch_next_state, minibatch[index][3]))
  229.  
  230.             if batch_done is None:
  231.                 batch_done = minibatch[index][4]
  232.             elif batch_done is not None:
  233.                 batch_done = np.vstack((batch_done, minibatch[index][4]))
  234.  
  235.         # q_next：下一个状态的 Q 值。
  236.         q_next = self.session.run([self.q_eval], feed_dict={self.q_eval_input: batch_next_state})
  237.  
  238.         q_target = []
  239.         for i in range(len(minibatch)):
  240.             # 当前即时得分。
  241.             current_reward = batch_reward[i][0]
  242.  
  243.             # # 游戏是否结束。
  244.             # current_done = batch_done[i][0]
  245.  
  246.             # 更新 Q 值。
  247.             q_value = current_reward + self.gamma * np.max(q_next[0][i])
  248.  
  249.             # 当得分小于 -1 时，表示走了不可走的位置。
  250.             if current_reward <= -1:
  251.                 q_target.append(current_reward)
  252.             else:
  253.                 q_target.append(q_value)
  254.  
  255.         _, cost, reward = self.session.run([self.train_op, self.loss, self.reward_action],
  256.                                            feed_dict={self.q_eval_input: batch_state,
  257.                                                       self.action_input: batch_action,
  258.                                                       self.q_target: q_target})
  259.  
  260.         self.cost_his.append(cost)
  261.  
  262.         # if self.step_index % 1000 == 0:
  263.         #     print("loss:", cost)
  264.  
  265.         self.learn_step_counter += 1
  266.  
  267.     def train(self):
  268.         """
  269.         训练。
  270.         :return:
  271.         """
  272.         # 初始化当前状态。
  273.         current_state = np.random.randint(0, self.action_num - 1)
  274.         self.epsilon = self.INITIAL_EPSILON
  275.  
  276.         while True:
  277.             # 选择动作。
  278.             action = self.select_action(current_state)
  279.  
  280.             # 执行动作，得到：下一个状态，执行动作的得分，是否结束。
  281.             next_state, reward, done = self.step(current_state, action)
  282.  
  283.             # 保存记忆。
  284.             self.save_store(current_state, action, reward, next_state, done)
  285.  
  286.             # 先观察一段时间累积足够的记忆在进行训练。
  287.             if self.step_index > self.OBSERVE:
  288.                 self.experience_replay()
  289.  
  290.             if self.step_index > 10000:
  291.                 break
  292.  
  293.             if done:
  294.                 current_state = np.random.randint(0, self.action_num - 1)
  295.             else:
  296.                 current_state = next_state
  297.  
  298.             self.step_index += 1
  299.  
  300.     def pay(self):
  301.         """
  302.         运行并测试。
  303.         :return:
  304.         """
  305.         self.train()
  306.  
  307.         # 显示 R 矩阵。
  308.         print(self.r)
  309.  
  310.         for index in range(5):
  311.  
  312.             start_room = index
  313.  
  314.             print("#############################", "Agent 在", start_room, "开始行动", "#############################")
  315.  
  316.             current_state = start_room
  317.  
  318.             step = 0
  319.  
  320.             target_state = 5
  321.  
  322.             while current_state != target_state:
  323.                 out_result = self.session.run(self.q_eval, feed_dict={
  324.                     self.q_eval_input: self.state_list[current_state:current_state + 1]})
  325.  
  326.                 next_state = np.argmax(out_result[0])
  327.  
  328.                 print("Agent 由", current_state, "号房间移动到了", next_state, "号房间")
  329.  
  330.                 current_state = next_state
  331.  
  332.                 step += 1
  333.  
  334.             print("Agent 在", start_room, "号房间开始移动了", step, "步到达了目标房间 5")
  335.  
  336.             print("#############################", "Agent 在", 5, "结束行动", "#############################")
  337.  
  338. if __name__ == "__main__":
  339.     q_network = DeepQNetwork()
  340.     q_network.pay()

Deep Q-Network 学习笔记（二）—— Q-Learning与神经网络结合使用（有代码实现）的更多相关文章

  1. python3.4学习笔记(二十五) Python 调用mysql redis实例代码

    python3.4学习笔记(二十五) Python 调用mysql redis实例代码 #coding: utf-8 __author__ = 'zdz8207' #python2.7 import ...

  2. [FML]学习笔记二 PAC Learning Model

    对于一个concept class C,如果存在一个算法A和一个多项式poly(.,.,.,.),有对于任意的ε>0.δ>0以及X的任意分布D和任何target concept C,当sa ...

  3. python3.4学习笔记(二十四) Python pycharm window安装redis MySQL-python相关方法

    python3.4学习笔记(二十四) Python pycharm window安装redis MySQL-python相关方法window安装redis,下载Redis的压缩包https://git ...

  4. Learning ROS for Robotics Programming Second Edition学习笔记(二) indigo tools

    中文译著已经出版,详情请参考:http://blog.csdn.net/ZhangRelay/article/category/6506865 Learning ROS for Robotics Pr ...

  5. 深度学习（二十六）Network In Network学习笔记

    深度学习(二十六)Network In Network学习笔记 Network In Network学习笔记 原文地址:http://blog.csdn.net/hjimce/article/deta ...

  6. WPF的Binding学习笔记(二)

    原文: http://www.cnblogs.com/pasoraku/archive/2012/10/25/2738428.htmlWPF的Binding学习笔记(二) 上次学了点点Binding的 ...

  7. Django学习笔记二

    Django学习笔记二 模型类,字段,选项,查询,关联,聚合函数,管理器, 一 字段属性和选项 1.1 模型类属性命名限制 1)不能是python的保留关键字. 2)不允许使用连续的下划线,这是由dj ...

  8. 学习笔记(二)--->《Java 8编程官方参考教程（第9版）.pdf》:第七章到九章学习笔记

    注:本文声明事项. 本博文整理者:刘军 本博文出自于: <Java8 编程官方参考教程>一书 声明:1:转载请标注出处.本文不得作为商业活动.若有违本之,则本人不负法律责任.违法者自负一切 ...

  9. muduo学习笔记(二)Reactor关键结构

    目录 muduo学习笔记(二)Reactor关键结构 Reactor简述 什么是Reactor Reactor模型的优缺点 poll简述 poll使用样例 muduo Reactor关键结构 Chan ...

  10. Html学习笔记(二) 简单标签

    标签的重点 标签的用途 标签在浏览器中的默认样式 <body>标签: 在网页上显示的内容 <p>标签: 添加段落 <hx>标签: 添加标题 标签一共有6个,h1.h ...

随机推荐

  1. 【2017-04--28】Winform中ListView控件

    ListView 1.先设置列,设置视图属性选择Details. 添加列,修改列名. 2.编辑项(添加行数据) 添加一个ListViewItem对象,该对象的Text对应着是第一列的数据, 在该对象的 ...

  2. macOS 中使用 phpize 动态添加 PHP 扩展的错误解决方法

    使用 phpize 动态添加 PHP 扩展是开发中经常需要做的事情,但是在 macOS 中,首次使用该功能必然会碰到一些错误,本文列出了这些错误的解决方法. 问题一: 执行 phpize 报错如下: ...

  3. PHP预定义变量$_SERVER

    PHP预定义变量$_SERVER $_SERVER 是一个包含诸如头部(headers).路径(paths)和脚本位置(script locations)的数组.数组的实体由 web 服务器创建,不能 ...

  4. 在Debian 8 上安装自动化工具Ansible

    如果你是新手,就不要犹豫了,ansible是你最好的选择,本人菜鸟一个.废话少说,开始安装! 实验环境: 192.168.3.190 192.168.3.191 192.168.3.192 192.1 ...

  5. php web开发安全之csrf攻击的简单演示和防范（一）

    csrf攻击,即cross site request forgery跨站(域名)请求伪造,这里的forgery就是伪造的意思.网上有很多关于csrf的介绍,比如一位前辈的文章浅谈CSRF攻击方式,参考 ...

  6. HashSet实现原理

    /* HashSet的实现原理: 往HashSet添加元素的时候,HashSet会先调用元素的hashCode方法得到元素的哈希值 , 然后通过元素 的哈希值经过移位等运算,就可以算出该元素在哈希表中 ...

  7. IOS中的UIScrollView

    要引用UIScrollView 首先要遵循UIScrollViewDelegate协议 然后重写 //1.拖拽方法 -(void)scrollViewDidScroll:(UIScrollView * ...

  8. Xcode旧项目引入CocoaPod遇到的问题与解决

    html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,bi ...

  9. redis中键的生存时间（expire）

    1.redis中可以使用expire命令设置一个键的生存时间,到时间后redis会自动删除它 expire 设置生存时间(单位/秒) pexpire 设置生存时间(单位/毫秒) ttl/pttl 查看 ...

  10. 重庆/北京/江苏KS/快乐时时/七星/福运来菠菜电商开奖修复APP网站SSC网站程序开发php

    网站制作是指使用标识语言(markup language),通过一系列设计.建模.和执行的过程将电子格式的信息通过互联网传输,最终以图形用户界面(GUI)的形式被用户所浏览.简单来说,网页设计的目的就 ...