dqn 应用案例_深度强化学习DQN(Deep Q Network)原理及例子：如何解决迷宫问题，附源码...

目前，强化学习中很火的当属Q-Learning了，关于Q-Learning的具体介绍请参加我上一篇文章。从上一篇文章中，我们可以看到，Q table可以看做Q-Learning的大脑，Q table对应了一张state-action的表，但在实际应用中，state和action往往很多，内存很难装下Q table，因此需要用神经网络替代Q table。

训练样本

首先要解决的问题是如何获取训练样本。在 DQN 中有 Experience Replay 的概念，就是经验回放。即先让agent去探索环境，将经验(记忆)累积到一定程度，再随机抽取出一批样本进行训练。为什么要随机抽取？因为agent去探索环境时采集到的样本是一个时间序列，样本之间具有连续性，如果每次得到样本就更新Q值，受样本分布影响，会对收敛造成影响。

这里我们联想到数据库领域，我们需要使用benchmark去回放得到不同的action对应的Q值。增强学习是试错学习(Trail-and-error)，由于没有直接的指导信息，agent要以不断与环境进行交互，通过试错的方式来获得最佳策略。因此一开始可以看做是盲目的、随机的试验，但是根据反馈的reward来优化损失函数可以使得我们想要的Q table慢慢收敛。

损失函数

上面提到了损失函数，那么如何选取呢。在DQN中，Q值表中表示的是当前已学习到的经验。而根据公式计算出的 Q 值是agent通过与环境交互及自身的经验总结得到的一个分数(即：目标 Q 值)。最后使用目标 Q 值(target_q)去更新原来旧的 Q 值(q)。而目标 Q 值与旧的 Q 值的对应关系，正好是监督学习神经网络中结果值与输出值的对应关系。

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

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

代码实现

看代码是最直观的，我先给出整个代码流程，然后再详细解释。下面是全部代码：

import tensorflow as tf

import numpy as np

from collections import deque

import random

class 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:

"""

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)

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_