在前两篇文章强化学习基础：基本概念和动态规划和强化学习基础：蒙特卡罗和时序差分中介绍的强化学习的三种经典方法（动态规划、蒙特卡罗以及时序差分）适用于有限的状态集合$mathcal{S}$，以时序差分中的Q-Learning算法为例，一般来说使用n行(n = number of states)和m列(m= number of actions)的矩阵(Q table)来储存action-value function的值，如下图所示：
对于连续的状态集合$mathcal{S}$，上述方法就不能适用了，这时可以引入神经网络来估计Q的值，即Deep Q-Learning，如下图所示：
接下来介绍Deep Q-Learning中常用的几种技巧，用于提升学习效果：
- Stack States：对于连续的状态集合，单个状态不能很好地描述整体的状况。例如下图所示，要判断黑色方块的移动方向，仅凭一副图像是无法判断的，需要连续的多幅图像才能判断出黑色方块在向右移动
- Experience Replay：如下图所示，防止算法在训练过程中忘记了之前场景获得的经验，创建一个Replay Buffer，不断回放之前的场景对算法进行训练；另一方面，相邻的场景之间(例如$[S_{t},A_{t},R_{t+1},S_{t+1}]$与$[S_{t+1},A_{t+1},R_{t+2},S_{t+2}]$)有着一定的相关性,为了防止算法被固定在某些特定的状态空间，从Replay Buffer中随机抽样选取场景进行训练（打乱场景之间的顺序，减少相邻场景的相关性）
- Fixed Q-targets：针对Deep Q-Learning中计算Q值的神经网络的权重系数的更新，有公式如左图所示，此时将TD target近似为了$q_{pi}(S,A)$的真值，但是当不断更新权重系数时TD target也是不断变化的，这就会使得在训练过程中$q_{pi}(S,A)$的估计值要接近一个不断变化的值，加大了训练难度，减小了训练效率。解决方案如右图所示，使用相对固定的参数来估计TD target
- Double DQNs：解决TD target对$q_{pi}(S,A)$的真值可能高估的问题，方案是在计算TD target时使用两个不同的神经网络，将动作$a$的选择过程与TD target的计算过程进行分割。如果和Fixed Q-targets结合起来，可以直接使用$w$和$w^{-}$这两组参数（如下图所示）
- Dueling DQN：如下图所示，相对于直接计算action-value function $Q(s,a)$，将$Q(s,a)$分解为state-value function $V(s)$与advantage-value function $A(s,a)$之和，这样做的原因是多数状态下采取何种行动对$Q(s,a)$的值影响不大，适合直接对状态函数$V(s)$进行估计，再叠加上不同行动对其的影响。在实际计算中，为了使得从$Q(s,a)$能够唯一确定$V(s)$与$A(s,a)$，可以令$A(s,a)$的均值（即$frac{1}{|mathcal{A}|}sum_{a^{prime}} A(s,a^{prime})$）为0
-
Prioritized Experience Replay：如下图所示，对Replay Buffer中的每个场景加入一个优先级，一个场景的TD error越大，它对应的优先级就越大。其中$e$是一个大于0的常数，防止抽样概率为0；$a$控制按优先级抽样和均匀抽样的比重，$a=1$时完全按优先级抽样，$a=0$时退化为均匀抽样；另外由于是按照优先级进行抽样，还需要改写神经网络中权重系数的更新规则，针对优先级高的场景减少权重更新的步长，使权重更新的过程与场景出现的真实概率一致（特别是在训练的后期，通过参数$b$控制），避免过拟合高优先级的场景
代码实现
使用vizdoom强化学习环境，以其中的一个任务为基础进行训练，该任务要确保玩家活着走到目标位置（要做到这一点，路上要躲避敌人的射击或者杀死敌人，否则不可能成功）。该任务每步的奖励与玩家和目标的距离变化有关（+dX for getting closer, -dX for getting further），此外若玩家死亡会有-100的惩罚。
值得注意的是在代码中使用SumTree(二叉树，每个父节点的值是两个子节点的值的和)这一数据结构来存储Replay Buffer中的Priority，具体结构如下图所示，这样做的目的是方便按优先级进行抽样，可以使得每次抽样以及更新优先级的计算均为$O(ln{n})$。在抽样过程中抽得的叶子节点$x$满足$P(xleq{k})=frac{sum_{i=1}^{k}Priority_i}{sum_{i=1}^{n}Priority_i}, ext{ }kin{1,2,cdots,n}$
import tensorflow as tf # Deep Learning library import numpy as np # Handle matrices from vizdoom import * # Doom Environment import random # Handling random number generation import time # Handling time calculation from skimage import transform# Help us to preprocess the frames from collections import deque# Ordered collection with ends import matplotlib.pyplot as plt # Display graphs import warnings # This ignore all the warning messages that are normally printed during the training because of skiimage warnings.filterwarnings('ignore') ### Here we create our environment def create_environment(): game = DoomGame() # Load the correct configuration game.load_config("deadly_corridor.cfg") # Load the correct scenario (in our case deadly_corridor scenario) game.set_doom_scenario_path("deadly_corridor.wad") game.init() # Create an hot encoded version of our actions (7 possible actions) possible_actions = np.identity(7,dtype=int).tolist() return game, possible_actions game, possible_actions = create_environment() ### Preprocess(reduce the complexity of states and the training time) def preprocess_frame(frame): # Grayscale frame(color not add important information, already done by the config file) # Crop the screen (remove part that contains no information) cropped_frame = frame[15:-5,20:-20] #[Up: Down, Left: right] # Normalize Pixel Values normalized_frame = cropped_frame/255.0 # Resize preprocessed_frame = transform.resize(normalized_frame, [100,120]) return preprocessed_frame # 100x120x1 frame ### Stack frames stack_size = 4 #stack 4 frames # Initialize deque with zero-images, one array for each image stacked_frames = deque([np.zeros((100,120), dtype=np.int) for i in range(stack_size)], maxlen=4) def stack_frames(stacked_frames, state, is_new_episode): frame = preprocess_frame(state) #preprocess frame if is_new_episode: # Clear our stacked_frames stacked_frames = deque([np.zeros((100,120), dtype=np.int) for i in range(stack_size)], maxlen=4) # Because we're in a new episode, copy the same frame 4x stacked_frames.append(frame) stacked_frames.append(frame) stacked_frames.append(frame) stacked_frames.append(frame) # Stack the frames stacked_state = np.stack(stacked_frames, axis=2) else: # Append frame to deque, automatically removes the oldest frame stacked_frames.append(frame) # Build the stacked state stacked_state = np.stack(stacked_frames, axis=2) return stacked_state, stacked_frames ### Set the hyperparameters # MODEL HYPERPARAMETERS state_size = [100,120,4] # Our input is a stack of 4 frames hence 100x120x4 (Width, height, channels) action_size = game.get_available_buttons_size() # 7 possible actions learning_rate = 0.00025 # Alpha (i.e., learning rate) # TRAINING HYPERPARAMETERS total_episodes = 5000 # Total episodes for training max_steps = 5000 # Max possible steps in an episode batch_size = 64 # FIXED Q TARGETS HYPERPARAMETERS max_tau = 10000 # The number of steps where we update our target network # EXPLORATION HYPERPARAMETERS for epsilon greedy strategy explore_start = 1.0 # exploration probability at start explore_stop = 0.01 # minimum exploration probability decay_rate = 0.00005 # exponential decay rate for exploration prob # Q LEARNING hyperparameters gamma = 0.95 # Discounting rate # MEMORY HYPERPARAMETERS(If you have GPU change to 1 million) pretrain_length = 100000 # Number of experiences stored in the Memory when initialized for the first time memory_size = 100000 # Number of experiences the Memory can keep # MODIFY THIS TO FALSE IF YOU JUST WANT TO SEE THE TRAINED AGENT training = True ### Set up Deep Q network and Target network (both are Dueling Network) class DDDQNNet: def __init__(self, state_size, action_size, learning_rate, name): self.state_size = state_size self.action_size = action_size self.learning_rate = learning_rate self.name = name # use tf.variable_scope to know which network we're using (DQN or target_net) # it will be useful when we will update our w- parameters (by copy the DQN parameters) with tf.variable_scope(self.name): # create the placeholders self.inputs_ = tf.placeholder(tf.float32, [None, *state_size], name="inputs") #[None,100,120,4] self.ISWeights_ = tf.placeholder(tf.float32, [None,1], name='IS_weights') self.actions_ = tf.placeholder(tf.float32, [None, action_size], name="actions_") # Remember that target_Q is the R(s,a) + max Qhat(s', a') self.target_Q = tf.placeholder(tf.float32, [None], name="target") # first conv layer self.conv1 = tf.layers.conv2d(inputs = self.inputs_, filters = 32, kernel_size = [8,8], strides = [4,4], padding = "VALID", name = "conv1", kernel_initializer=tf.contrib.layers.xavier_initializer_conv2d()) self.conv1_out = tf.nn.elu(self.conv1, name="conv1_out") # second conv layer self.conv2 = tf.layers.conv2d(inputs = self.conv1_out, filters = 64, kernel_size = [4,4], strides = [2,2], padding = "VALID", name = "conv2", kernel_initializer=tf.contrib.layers.xavier_initializer_conv2d()) self.conv2_out = tf.nn.elu(self.conv2, name="conv2_out") # third conv layer self.conv3 = tf.layers.conv2d(inputs = self.conv2_out, filters = 128, kernel_size = [4,4], strides = [2,2], padding = "VALID", name = "conv3", kernel_initializer=tf.contrib.layers.xavier_initializer_conv2d()) self.conv3_out = tf.nn.elu(self.conv3, name="conv3_out") self.flatten = tf.layers.flatten(self.conv3_out) # Here we separate into two streams (Dueling Network) # The one that calculate V(s) self.value_fc = tf.layers.dense(inputs = self.flatten, units = 512, activation = tf.nn.elu, kernel_initializer=tf.contrib.layers.xavier_initializer(), name="value_fc") self.value = tf.layers.dense(inputs = self.value_fc, units = 1, activation = None, kernel_initializer=tf.contrib.layers.xavier_initializer(), name="value") # The one that calculate A(s,a) self.advantage_fc = tf.layers.dense(inputs = self.flatten, units = 512, activation = tf.nn.elu, kernel_initializer=tf.contrib.layers.xavier_initializer(), name="advantage_fc") self.advantage = tf.layers.dense(inputs = self.advantage_fc, units = self.action_size, activation = None, kernel_initializer=tf.contrib.layers.xavier_initializer(), name="advantages") # Agregating layer # Q(s,a) = V(s) + (A(s,a) - 1/|A| * sum A(s,a')) self.output = self.value + tf.subtract(self.advantage, tf.reduce_mean(self.advantage, axis=1, keepdims=True)) # Predicted Q value self.Q = tf.reduce_sum(tf.multiply(self.output, self.actions_), axis=1) # For computing priority and updating Sumtree self.absolute_errors = tf.abs(self.target_Q - self.Q) # The loss is modified because of Priority Experience Replay self.loss = tf.reduce_mean(self.ISWeights_ * tf.squared_difference(self.target_Q, self.Q)) self.optimizer = tf.train.RMSPropOptimizer(self.learning_rate).minimize(self.loss) # Reset the graph tf.reset_default_graph() # Instantiate the DQNetwork DQNetwork = DDDQNNet(state_size, action_size, learning_rate, name="DQNetwork") # Instantiate the target network TargetNetwork = DDDQNNet(state_size, action_size, learning_rate, name="TargetNetwork") ### Data Struture to store experience and priority(SumTree) class SumTree(object): data_pointer = 0 # Here we initialize the tree with all nodes = 0, and initialize the data with all values = 0 def __init__(self, capacity): self.capacity = capacity # Number of leaf nodes (final nodes) that contains experiences # Generate the tree with all nodes values = 0 # Parent nodes = capacity - 1, Leaf nodes = capacity self.tree = np.zeros(2 * capacity - 1) # Contains the experiences (so the size of data is capacity) self.data = np.zeros(capacity, dtype=object) # Here we add our priority score in the sumtree leaf and add the experience in data def add(self, priority, data): # Look at what index we want to put the experience tree_index = self.data_pointer + self.capacity - 1 # the leaves from left to right self.data[self.data_pointer] = data # Update data frames self.update(tree_index, priority) # Update the leaf self.data_pointer += 1 # Add 1 to data_pointer # If we're above the capacity, you go back to first index (we overwrite) if self.data_pointer >= self.capacity: self.data_pointer = 0 # Update the leaf priority score and propagate the change through tree def update(self, tree_index, priority): # Change = new priority score - former priority score change = priority - self.tree[tree_index] self.tree[tree_index] = priority # Propagate the change through tree while tree_index != 0: tree_index = (tree_index - 1) // 2 self.tree[tree_index] += change # Here we get the leaf and associated experience # the returned index is the smallest index satisfying: sum(leaf priority) >= v for leaf index <= returned index def get_leaf(self, v): parent_index = 0 while True: left_child_index = 2 * parent_index + 1 right_child_index = left_child_index + 1 # If we reach bottom, end the search if left_child_index >= len(self.tree): leaf_index = parent_index break else: # downward search if v <= self.tree[left_child_index]: parent_index = left_child_index else: v -= self.tree[left_child_index] parent_index = right_child_index data_index = leaf_index - self.capacity + 1 return leaf_index, self.tree[leaf_index], self.data[data_index] @property def total_priority(self): return self.tree[0] # Returns the root node ### Create Replay Buffer and Prioritized Experience Replay class Memory(object): PER_e = 0.01 # Hyperparameter that we use to avoid some experiences to have 0 probability of being taken PER_a = 0.6 # Hyperparameter that we use to make a tradeoff between taking only exp with high priority and sampling randomly PER_b = 0.4 # importance-sampling, from initial value increasing to 1 PER_b_increment_per_sampling = 0.001 absolute_error_upper = 1. # clipped abs error def __init__(self, capacity): # Making the tree self.tree = SumTree(capacity) # Store a new experience in our tree # Each new experience have a score of max_prority (it will be then improved when we use this exp to train our DDQN) def store(self, experience): # Find the max priority max_priority = np.max(self.tree.tree[-self.tree.capacity:]) # If the max priority = 0 we can't put priority = 0 since this exp will never have a chance to be selected # So we use an upper limit if max_priority == 0: max_priority = self.absolute_error_upper self.tree.add(max_priority, experience) # set the max p for new exp # First, to sample a minibatch of n size, the range [0, priority_total] is split into n ranges. # Then a value is uniformly sampled from each range # We search in the sumtree, the experience where priority score correspond to sample values are retrieved from # Finally, we calculate IS weights for each minibatch element def sample(self, n): memory_b = [] # Create a sample array that will contains the minibatch b_idx, b_ISWeights = np.empty((n,), dtype=np.int32), np.empty((n, 1), dtype=np.float32) priority_segment = self.tree.total_priority / n # priority segment # Here we increasing the PER_b each time we sample a new minibatch self.PER_b = np.min([1., self.PER_b + self.PER_b_increment_per_sampling]) # max = 1 # Calculating the max_weight p_min = np.min(self.tree.tree[-self.tree.capacity:]) / self.tree.total_priority max_weight = (p_min * n) ** (-self.PER_b) for i in range(n): # A value is uniformly sample from each range a, b = priority_segment * i, priority_segment * (i + 1) value = np.random.uniform(a, b) # Experience that correspond to each value is retrieved index, priority, data = self.tree.get_leaf(value) sampling_probabilities = priority / self.tree.total_priority # P(j) # IS = (1/N * 1/P(i))**b /max wi == (N*P(i))**-b /max wi b_ISWeights[i, 0] = np.power(n * sampling_probabilities, -self.PER_b)/ max_weight b_idx[i]= index experience = [data] memory_b.append(experience) return b_idx, memory_b, b_ISWeights # Update the priorities on the tree def batch_update(self, tree_idx, abs_errors): abs_errors += self.PER_e # convert to abs and avoid 0 clipped_errors = np.minimum(abs_errors, self.absolute_error_upper) ps = np.power(clipped_errors, self.PER_a) for ti, p in zip(tree_idx, ps): self.tree.update(ti, p) ### Deal with the empty memory problem (pre-populate memory by taking random actions and storing the experience) memory = Memory(memory_size) # Instantiate memory game.new_episode() # Render the environment for i in range(pretrain_length): # If it's the first step if i == 0: # First we need a state state = game.get_state().screen_buffer state, stacked_frames = stack_frames(stacked_frames, state, True) action = random.choice(possible_actions) # Random action reward = game.make_action(action) # Get the rewards done = game.is_episode_finished() # Look if the episode is finished # If the player is dead if done: # the episode ends so no next state next_state = np.zeros((120,140), dtype=np.int) next_state, stacked_frames = stack_frames(stacked_frames, next_state, False) # Add experience to memory experience = state, action, reward, next_state, done memory.store(experience) # Start a new episode game.new_episode() # First we need a state state = game.get_state().screen_buffer # Stack the frames state, stacked_frames = stack_frames(stacked_frames, state, True) else: # Get the next state next_state = game.get_state().screen_buffer next_state, stacked_frames = stack_frames(stacked_frames, next_state, False) # Add experience to memory experience = state, action, reward, next_state, done memory.store(experience) # Our state is now the next_state state = next_state ### Choose action from Q (use ϵ-greedy strategy) def predict_action(explore_start, explore_stop, decay_rate, decay_step, state, actions): exp_exp_tradeoff = np.random.rand() # First we randomize a number explore_probability = explore_stop + (explore_start - explore_stop) * np.exp(-decay_rate * decay_step) if (explore_probability > exp_exp_tradeoff): # Make a random action (exploration) action = random.choice(actions) else: # Get action from Q-network (exploitation) # Estimate the Qs values state Qs = sess.run(DQNetwork.output, feed_dict = {DQNetwork.inputs_: state.reshape((1, *state.shape))}) # Take the biggest Q value (= the best action) choice = np.argmax(Qs) action = actions[int(choice)] return action, explore_probability ### Copy the parameters of DQN to Target_network (used for Fixed Q-target and Double DQN) def update_target_graph(): # Get the parameters of our DQNNetwork from_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "DQNetwork") # Get the parameters of our Target_network to_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "TargetNetwork") op_holder = [] # Update our target_network parameters with DQNNetwork parameters for from_var,to_var in zip(from_vars,to_vars): op_holder.append(to_var.assign(from_var)) return op_holder ### Train the agent saver = tf.train.Saver() # Saver will help us to save our model if training == True: with tf.Session() as sess: sess.run(tf.global_variables_initializer()) # Initialize the variables decay_step = 0 # Initialize the decay step tau = 0 # Set tau = 0 game.init() # Init the game # Update the parameters of our TargetNetwork with DQN_weights update_target = update_target_graph() sess.run(update_target) for episode in range(total_episodes): step = 0 # Set step to 0 episode_rewards = [] # Initialize the rewards of the episode game.new_episode() # Make a new episode and observe the first state state = game.get_state().screen_buffer state, stacked_frames = stack_frames(stacked_frames, state, True) while step < max_steps: step += 1 tau += 1 decay_step +=1 # ϵ-greedy stragety action, explore_probability = predict_action(explore_start, explore_stop, decay_rate, decay_step, state, possible_actions) reward = game.make_action(action) # Do the action done = game.is_episode_finished() # Look if the episode is finished episode_rewards.append(reward) # Add the reward to total reward # If the game is finished if done: # the episode ends so no next state next_state = np.zeros((120,140), dtype=np.int) next_state, stacked_frames = stack_frames(stacked_frames, next_state, False) # Set step = max_steps to end the episode step = max_steps # Get the total reward of the episode total_reward = np.sum(episode_rewards) print('Episode: {}'.format(episode), 'Total reward: {}'.format(total_reward), 'Training loss: {:.4f}'.format(loss), 'Explore P: {:.4f}'.format(explore_probability)) # Add experience to memory experience = state, action, reward, next_state, done memory.store(experience) else: next_state = game.get_state().screen_buffer # Get the next state # Stack the frame of the next_state next_state, stacked_frames = stack_frames(stacked_frames, next_state, False) # Add experience to memory experience = state, action, reward, next_state, done memory.store(experience) state = next_state # LEARNING PART tree_idx, batch, ISWeights_mb = memory.sample(batch_size) # Obtain random mini-batch from memory states_mb = np.array([each[0][0] for each in batch], ndmin=3) actions_mb = np.array([each[0][1] for each in batch]) rewards_mb = np.array([each[0][2] for each in batch]) next_states_mb = np.array([each[0][3] for each in batch], ndmin=3) dones_mb = np.array([each[0][4] for each in batch]) target_Qs_batch = [] # DOUBLE DQN # Use DQNNetwork to select the action a' to take at next_state s' (action with the highest Q-value) # Use TargetNetwork to calculate the Q_val of Q(s',a') # Get Q values for next_state q_next_state = sess.run(DQNetwork.output, feed_dict = {DQNetwork.inputs_: next_states_mb}) # Calculate Qtarget for all actions at that state q_target_next_state = sess.run(TargetNetwork.output, feed_dict = {TargetNetwork.inputs_: next_states_mb}) # Set Q_target = r if the episode ends at s+1, otherwise set Q_target = r + gamma * Qtarget(s',a') for i in range(0, len(batch)): terminal = dones_mb[i] # We got a' action = np.argmax(q_next_state[i]) # If we are in a terminal state, only equals reward if terminal: target_Qs_batch.append(rewards_mb[i]) else: # Take the Qtarget for action a' target = rewards_mb[i] + gamma * q_target_next_state[i][action] target_Qs_batch.append(target) targets_mb = np.array([each for each in target_Qs_batch]) # Optimize _, loss, absolute_errors = sess.run([DQNetwork.optimizer, DQNetwork.loss, DQNetwork.absolute_errors], feed_dict={DQNetwork.inputs_: states_mb, DQNetwork.target_Q: targets_mb, DQNetwork.actions_: actions_mb, DQNetwork.ISWeights_: ISWeights_mb}) # Update priority memory.batch_update(tree_idx, absolute_errors) # Fixed Q target if tau > max_tau: # Update the parameters of our TargetNetwork with DQN_weights update_target = update_target_graph() sess.run(update_target) tau = 0 print("Model updated") # Save model every 5 episodes if episode % 5 == 0: save_path = saver.save(sess, "./models/model.ckpt") print("Model Saved") ### Watch the agent play with tf.Session() as sess: game = DoomGame() # Load the correct configuration (TESTING) game.load_config("deadly_corridor_testing.cfg") # Load the correct scenario (in our case deadly_corridor scenario) game.set_doom_scenario_path("deadly_corridor.wad") game.init() # Load the model saver.restore(sess, "./models/model.ckpt") for i in range(10): game.new_episode() state = game.get_state().screen_buffer state, stacked_frames = stack_frames(stacked_frames, state, True) while not game.is_episode_finished(): # EPSILON GREEDY STRATEGY exp_exp_tradeoff = np.random.rand() explore_probability = 0.01 if (explore_probability > exp_exp_tradeoff): # Make a random action (exploration) action = random.choice(possible_actions) else: # Get action from Q-network (exploitation) Qs = sess.run(DQNetwork.output, feed_dict = {DQNetwork.inputs_: state.reshape((1, *state.shape))}) choice = np.argmax(Qs) # Take the biggest Q value (= the best action) action = possible_actions[int(choice)] game.make_action(action) done = game.is_episode_finished() if done: break else: next_state = game.get_state().screen_buffer next_state, stacked_frames = stack_frames(stacked_frames, next_state, False) state = next_state score = game.get_total_reward() print("Score: ", score) game.close()