之前讲到Sarsa和Q Learning都不太适合解决大规模问题，为什么呢？
因为传统的强化学习都有一张Q表，这张Q表记录了每个状态下，每个动作的q值，但是现实问题往往极其复杂，其状态非常多，甚至是连续的，
比如足球场上足球的位置，此时，内存将无力承受这张Q表。
价值函数近似
既然Q表太大，那么怎么办呢？
假设我们可以找到一种方法来预测q值，那么在某个状态下，就可以估计其每个动作的q值，这样就不需要Q表了，这就是价值函数近似。
假设这个函数由参数w描述，那么
状态价值函数就表示为 v(s)≈f(s, w)
动作状态价值函数就表示为 q(s, a)≈f(s, a, w)
当然这个函数可以是线性的wx+b，也可以是决策树，神经网络等等，以神经网络最为常用。
价值函数近似有如下三种形式
1. 输入s，输出v
2. 输入s a，输出q
3.输入s，输出每个动作的q
Deep Q Learning 算法简介
先大概回顾Q Learning算法，初始状态S下ε-贪婪法选择动作，执行，进入状态S’，贪婪选择动作，更新q值，切换状态到S',
Deep Q Learning 大致思路也是如此，只是在某些细节有变化，具体如下
这是正版描述，结合实例翻译大致如下
输入：{S A R γ ε }，迭代轮数M，每次迭代次数T，初始的神经网络模型，初始的记忆库（空），batch_size训练样本数，
输出：预测q值的神经网络
for episode = 1:M
初始化状态s
for step = 1:T
### 制造记忆库
用神经网络计算s下所有动作的q值，（相当于Q-Learing中状态s对应的q值）这就是q估计
基于ε-贪婪法选择动作A，执行动作A，获得奖励R，进入状态S’
把 {S A R S'}存入记忆库
s=S'
### 训练神经网络
从记忆库随机取batch_size样本
用神经网络计算S下所有动作的q值，（相当于Q-Learing中状态S对应的q值）这就是q估计
用神经网络计算S’下所有动作的q值，（相当于Q-Learning中状态S’对应的q值）
找到样本中状态S下执行的动作A和奖励R，
计算 q 现实，R+γmaxaf(S',w)， （相当于Q-Learning中的 R+γmaxq(S',a)） , 当然如果S’为终止状态，那只有R
利用 (q现实-q估计)2作为损失函数更新神经网络参数
当然，这只是大致思路，具体算法时可以根据经验适当调整。
传统的Q Learning 是边实验边学习，而神经网络需要历史数据，
Deep Q Learning采用记忆库的方式解决这个问题，所有在实际算法中，往往需要先实验几次，以建立记忆库，
Deep Q Learning把这个方法叫 experience replay，经验回放，这里不一定要“亲自”去实验，也可以用“别人”实验的结果作为记忆。
实例
openAI中的例子很多，由于gym环境不能很好地支持windows，故选择了这个例子。
import gym import tensorflow as tf import numpy as np import random from collections import deque # Hyper Parameters for DQN GAMMA = 0.9 # discount factor for target Q INITIAL_EPSILON = 0.5 # starting value of epsilon FINAL_EPSILON = 0.01 # final value of epsilon REPLAY_SIZE = 10000 # experience replay buffer size BATCH_SIZE = 32 # size of minibatch class DQN(): # DQN Agent def __init__(self, env): # init experience replay self.replay_buffer = deque() # 记忆库 # init some parameters self.time_step = 0 # self.epsilon = INITIAL_EPSILON self.state_dim = env.observation_space.shape[0] # 状态 self.action_dim = env.action_space.n # 动作 self.create_Q_network() self.create_training_method() # Init session self.session = tf.InteractiveSession() self.session.run(tf.global_variables_initializer()) def create_Q_network(self): # 神经网络，输入s，输出q value # network weights W1 = self.weight_variable([self.state_dim,20]) b1 = self.bias_variable([20]) W2 = self.weight_variable([20,self.action_dim]) b2 = self.bias_variable([self.action_dim]) # input layer self.state_input = tf.placeholder("float",[None,self.state_dim]) # hidden layers h_layer = tf.nn.relu(tf.matmul(self.state_input,W1) + b1) # Q Value layer self.Q_value = tf.matmul(h_layer,W2) + b2 def create_training_method(self): # 训练方法 self.action_input = tf.placeholder("float",[None,self.action_dim]) # one hot presentation self.y_input = tf.placeholder("float",[None]) Q_action = tf.reduce_sum(tf.multiply(self.Q_value,self.action_input), reduction_indices = 1) # q 估计 self.cost = tf.reduce_mean(tf.square(self.y_input - Q_action)) self.optimizer = tf.train.AdamOptimizer(0.0001).minimize(self.cost) def perceive(self,state,action,reward,next_state,done): # 存储记忆 并 训练网络 one_hot_action = np.zeros(self.action_dim) one_hot_action[action] = 1 self.replay_buffer.append((state,one_hot_action,reward,next_state,done)) if len(self.replay_buffer) > REPLAY_SIZE: # 记忆大于经验回放大小，就删掉之前的 self.replay_buffer.popleft() if len(self.replay_buffer) > BATCH_SIZE: # 记忆大于batch，就开始训练网络 self.train_Q_network() def train_Q_network(self): # 训练网络 self.time_step += 1 # Step 1: obtain random minibatch from replay memory # 随机取样本 minibatch = random.sample(self.replay_buffer,BATCH_SIZE) state_batch = [data[0] for data in minibatch] action_batch = [data[1] for data in minibatch] reward_batch = [data[2] for data in minibatch] next_state_batch = [data[3] for data in minibatch] # Step 2: calculate y y_batch = [] # q 现实 Q_value_batch = self.Q_value.eval(feed_dict={self.state_input:next_state_batch}) # 神经网络预测q值，注意是下个状态的 for i in range(0,BATCH_SIZE): done = minibatch[i][4] if done: # 回合结束 y_batch.append(reward_batch[i]) else : y_batch.append(reward_batch[i] + GAMMA * np.max(Q_value_batch[i])) # 更新q值 self.optimizer.run(feed_dict={ self.y_input:y_batch, self.action_input:action_batch, self.state_input:state_batch }) def egreedy_action(self,state): Q_value = self.Q_value.eval(feed_dict = {self.state_input:[state]})[0] self.epsilon -= (INITIAL_EPSILON - FINAL_EPSILON)/10000 if random.random() <= self.epsilon: return random.randint(0,self.action_dim - 1) else: return np.argmax(Q_value) def action(self,state): return np.argmax(self.Q_value.eval(feed_dict = {self.state_input:[state]})[0]) def weight_variable(self,shape): initial = tf.truncated_normal(shape) return tf.Variable(initial) def bias_variable(self,shape): initial = tf.constant(0.01, shape = shape) return tf.Variable(initial) # --------------------------------------------------------- # Hyper Parameters ENV_NAME = 'CartPole-v0' EPISODE = 10000 # Episode limitation STEP = 300 # Step limitation in an episode TEST = 10 # The number of experiment test every 100 episode def main(): # initialize OpenAI Gym env and dqn agent env = gym.make(ENV_NAME) agent = DQN(env) for episode in range(EPISODE): # initialize task state = env.reset() # Train # 生成记忆 for step in range(STEP): action = agent.egreedy_action(state) # e-greedy action for train next_state,reward,done,_ = env.step(action) # Define reward for agent # reward_agent = -1 if done else 0.1 agent.perceive(state,action,reward,next_state,done) state = next_state if done: break # Test every 100 episodes if episode % 100 == 0: total_reward = 0 for i in range(TEST): state = env.reset() for j in range(STEP): env.render() action = agent.action(state) # direct action for test state,reward,done,_ = env.step(action) total_reward += reward if done: break ave_reward = total_reward/TEST print('episode: ',episode,'Evaluation Average Reward:',ave_reward) if ave_reward >= 200: break if __name__ == '__main__': main()
这里做了一些简单优化：
1. 探索率逐渐减小
2. 记忆库不能太大，超过限值就删除最早的记忆，最早的记忆太过久远，参考意义不大，删掉就不会被随机选中。
3. 在记忆库小于batch时，只实验，不训练。
总结
这里虽然解决了大规模问题，但是Deep Q Learning可能出现不收敛的情况，所以产生了很多Deep Q Learning的变种来优化该算法。