也就是优先采样，这里的推导部分完全没看懂 Orz，这里也只是记录实现代码。
也就是看了以下两篇文章对应做了实现。
莫烦老师的教程：
https://morvanzhou.github.io/tutorials/machine-learning/reinforcement-learning/4-6-prioritized-replay/
还有这位大神的：
https://jaromiru.com/2016/11/07/lets-make-a-dqn-double-learning-and-prioritized-experience-replay/
https://github.com/jaara/AI-blog
这里同样是在上一篇的基础上完善。
完整实现
tree 优先采样：
import numpy as np import random class SumTree: write = 0 def __init__(self, capacity): # 容量。 self.capacity = capacity self.tree = np.zeros(2 * capacity - 1) self.data = np.zeros(capacity, dtype=object) def _propagate(self, idx, change): # 整数除法。 parent = (idx - 1) // 2 self.tree[parent] += change if parent != 0: self._propagate(parent, change) def _retrieve(self, idx, s): """ 示例： 样本数（sample num）：4 个，则 Tree 的 size 是：4 X 2 - 1 = 7。 其中，size 的后 sample num 个是单个样本的优先级，其它的是父级，即：父级的优先级=SUM(子级的优先级)。 如果 data = ["test1", "test2", "test3", "test4"]，它们单个的优先级对应的就是下图中的“3, 4, 5, 6”。 Tree structure and array storage: Tree index: 18 -> storing priority sum / \ 7 11 / \ / \ 3 4 5 6 -> storing priority for transitions Array type for storing: [18,7,11,3,4,5,6] """ left = 2 * idx + 1 right = left + 1 if left >= len(self.tree): return idx if s <= self.tree[left]: return self._retrieve(left, s) else: return self._retrieve(right, s - self.tree[left]) def total(self): return self.tree[0] def add(self, p, data): idx = self.write + self.capacity - 1 self.data[self.write] = data self.update(idx, p) self.write += 1 if self.write >= self.capacity: self.write = 0 def update(self, idx, p): change = p - self.tree[idx] self.tree[idx] = p self._propagate(idx, change) def get(self, s): idx = self._retrieve(0, s) data_index = idx - self.capacity + 1 return idx, self.tree[idx], self.data[data_index] class Memory: e = 0.01 a = 0.6 def __init__(self, capacity): self.tree = SumTree(capacity) def _get_priority(self, error): return (error + self.e) ** self.a def add(self, error, sample): p = self._get_priority(error) self.tree.add(p, sample) def sample(self, n): batch = [] # 计算样本抽取的区间。 segment = self.tree.total() / n for i in range(n): # 第 i 个样本抽取区间的开始序号。 a = segment * i # 第 i 个样本抽取区间的结束序号。 b = segment * (i + 1) # 在(a, b)的区间内随机选数。 s = random.uniform(a, b) # 根据 s 来抽取，并将数据（数据序号，优先级，数据）返回。 (idx, p, data) = self.tree.get(s) # 将样本增加到集合里。 batch.append((idx, data)) return batch def update(self, idx, error): p = self._get_priority(error) self.tree.update(idx, p) if __name__ == "__main__": memory = Memory(4) memory.add(1, "test1") print(memory.tree.data) print(memory.tree.tree) memory.add(1, "test2") print(memory.tree.data) print(memory.tree.tree) memory.add(2, "test3") memory.add(3, "test4") samples, sample_index, i_s_weight = memory.sample(2) print("samples:", samples) print("sample_index:", sample_index) print("Importance-Sampling Weight", i_s_weight)
神经网络：
import tensorflow as tf import numpy as np class DeepQNetwork: # q_eval 网络状态输入参数。 q_eval_input = None # # q_eval 网络动作输入参数。 # q_action_input = None # q_eval 网络中 q_target 的输入参数。 q_eval_target = None # q_eval 网络输出结果。 q_eval_output = None # q_eval 网络输出的结果中的最优得分。 q_predict = None # q_eval 网络输出的结果中当前选择的动作得分。 reward_action = None # q_eval 网络损失函数。 loss = None # q_eval 网络训练。 train_op = None # q_target 网络状态输入参数。 q_target_input = None # q_target 网络输出结果。 q_target_output = None # 更换 target_net 的步数。 replace_target_stepper = 0 def __init__(self, input_num, output_num, learning_rate=0.001, replace_target_stepper=300, session=None): self.learning_rate = learning_rate self.INPUT_NUM = input_num self.OUTPUT_NUM = output_num self.replace_target_stepper = replace_target_stepper self.create() if session is None: self.session = tf.InteractiveSession() self.session.run(tf.initialize_all_variables()) else: self.session = session def create(self): neuro_layer_1 = 3 w_init = tf.random_normal_initializer(0, 0.3) b_init = tf.constant_initializer(0.1) # -------------- 创建 eval 神经网络, 及时提升参数 -------------- # self.q_eval_input = tf.placeholder(shape=[None, self.INPUT_NUM], dtype=tf.float32, name="q_eval_input") # self.q_action_input = tf.placeholder(shape=[None, self.OUTPUT_NUM], dtype=tf.float32) self.q_eval_target = tf.placeholder(shape=[None, self.OUTPUT_NUM], dtype=tf.float32, name="q_target") with tf.variable_scope("eval_net"): q_name = ['eval_net_params', tf.GraphKeys.GLOBAL_VARIABLES] with tf.variable_scope('l1'): w1 = tf.get_variable('w1', [self.INPUT_NUM, neuro_layer_1], initializer=w_init, collections=q_name) b1 = tf.get_variable('b1', [1, neuro_layer_1], initializer=b_init, collections=q_name) l1 = tf.nn.relu(tf.matmul(self.q_eval_input, w1) + b1) with tf.variable_scope('l2'): w2 = tf.get_variable('w2', [neuro_layer_1, self.OUTPUT_NUM], initializer=w_init, collections=q_name) b2 = tf.get_variable('b2', [1, self.OUTPUT_NUM], initializer=b_init, collections=q_name) self.q_eval_output = tf.matmul(l1, w2) + b2 self.q_predict = tf.argmax(self.q_eval_output, 1) with tf.variable_scope('loss'): # # 取出当前动作的得分。 # self.reward_action = tf.reduce_sum(tf.multiply(self.q_eval_output, self.q_action_input), # reduction_indices=1) # self.loss = tf.reduce_mean(tf.square((self.q_eval_target - self.reward_action))) self.loss = tf.reduce_mean(tf.squared_difference(self.q_eval_target, self.q_eval_output)) with tf.variable_scope('train'): self.train_op = tf.train.GradientDescentOptimizer(self.learning_rate).minimize(self.loss) # -------------- 创建 target 神经网络, 及时提升参数 -------------- # self.q_target_input = tf.placeholder(shape=[None, self.INPUT_NUM], dtype=tf.float32, name="q_target_input") with tf.variable_scope("target_net"): t_name = ['target_net_params', tf.GraphKeys.GLOBAL_VARIABLES] with tf.variable_scope('l1'): w1 = tf.get_variable('w1', [self.INPUT_NUM, neuro_layer_1], initializer=w_init, collections=t_name) b1 = tf.get_variable('b1', [1, neuro_layer_1], initializer=b_init, collections=t_name) l1 = tf.nn.relu(tf.matmul(self.q_target_input, w1) + b1) with tf.variable_scope('l2'): w2 = tf.get_variable('w2', [neuro_layer_1, self.OUTPUT_NUM], initializer=w_init, collections=t_name) b2 = tf.get_variable('b2', [1, self.OUTPUT_NUM], initializer=b_init, collections=t_name) self.q_target_output = tf.matmul(l1, w2) + b2 def replace_target_params(self): """ 使用 Tensorflow 中的 assign 功能替换 target_net 所有参数。 :return: """ # 提取 target_net 的参数。 t_params = tf.get_collection('target_net_params') # 提取 eval_net 的参数。 e_params = tf.get_collection('eval_net_params') # 更新 target_net 参数。 self.session.run([tf.assign(t, e) for t, e in zip(t_params, e_params)]) def get_q(self, input_data): return self.session.run(self.q_eval_output, {self.q_eval_input: input_data}) def get_next_q(self, input_data): return self.session.run(self.q_target_output, {self.q_target_input: input_data}) def get_predict(self, input_data): return np.max(self.get_q(input_data)) def get_action(self, input_data): return np.argmax(self.get_q(input_data)) def train(self, input_data, y_): _, cost = self.session.run([self.train_op, self.loss], feed_dict={self.q_eval_input: input_data, self.q_eval_target: y_}) return cost
主逻辑：
import numpy as np from collections import deque import random from q_network import DeepQNetwork from tree import Memory class Agent: 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], ]) # 神经网络。 network = None def __init__(self, train_num=2000, prioritized=True): # 执行步数。 self.step_index = 0 # 状态数。 self.STATE_NUM = 6 # 动作数。 self.ACTION_NUM = 6 # 记忆上限。 self.memory_size = 5000 # 当前记忆数。 self.memory_counter = 0 self.prioritized = prioritized if prioritized: self.replay_memory_store = Memory(self.memory_size) else: # 保存观察到的执行过的行动的存储器，即：曾经经历过的记忆。 self.replay_memory_store = deque() # 训练之前观察多少步。 self.OBSERVE = 5000 self.TRAIN_NUM = train_num # 训练步数统计。 self.learn_step_counter = 0 # 选取的小批量训练样本数。 self.BATCH = 20 # γ经验折损率。 self.gamma = 0.9 # -------------------- 探索策略 -------------------- # # epsilon 的最小值，当 epsilon 小于该值时，将不在随机选择行为。 self.FINAL_EPSILON = 0.0001 # epsilon 的初始值，epsilon 逐渐减小。 self.INITIAL_EPSILON = 0.1 # epsilon 衰减的总步数。 self.EXPLORE = 3000000. # 探索模式计数。 self.epsilon = 0 # -------------------- 探索策略 -------------------- # # 生成神经网络。 self.network = DeepQNetwork(input_num=self.STATE_NUM, output_num=self.ACTION_NUM, learning_rate=0.001, replace_target_stepper=1000, session=None) # 生成一个状态矩阵（6 X 6），每一行代表一个状态。 self.state_list = np.identity(self.STATE_NUM) # 生成一个动作矩阵。 self.action_list = np.identity(self.ACTION_NUM) # 输出图表。 self.q_list = [] self.running_q = 0 def select_action(self, current_state_index): """ 根据策略选择动作。 :param current_state_index: :return: """ # 获得当前状态。 current_state = self.state_list[current_state_index:current_state_index + 1] # 根据当前状态获得在 Q 网络中最有价值的动作，并返回动作序号。 current_action_index = self.network.get_action(current_state) # 输出图表。 actions_value = self.network.get_predict(current_state) self.running_q = self.running_q * 0.99 + 0.01 * np.max(actions_value) self.q_list.append(self.running_q) if np.random.uniform() < self.epsilon: current_action_index = np.random.randint(0, self.ACTION_NUM) # 开始训练后，在 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 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: """ current_state = self.state_list[current_state_index:current_state_index + 1] current_action = self.action_list[current_action_index:current_action_index + 1] next_state = self.state_list[next_state_index:next_state_index + 1] # 保存数据(当前状态， 当前执行的动作， 当前动作的得分，下一个状态，是否结束)。 memory_data = (current_state, current_action, current_reward, next_state, done) if self.prioritized: x, y, errors = self._get_targets([(0, memory_data)]) self.replay_memory_store.add(errors[0], memory_data) else: # 记忆动作。 self.replay_memory_store.append(memory_data) # 如果超过记忆的容量，则将最久远的记忆移除。 if len(self.replay_memory_store) > self.memory_size: self.replay_memory_store.popleft() self.memory_counter += 1 def run_game(self, state_index, action_index): """ 执行动作。 :param state_index: 当前状态。 :param action_index: 执行的动作。 :return: """ reward = self.r[state_index][action_index] next_state = action_index done = False if action_index == 5: done = True return next_state, reward, done def experience_replay(self): """ 记忆回放。 :return: """ # 检查是否替换 target_net 参数 if self.learn_step_counter % self.network.replace_target_stepper == 0: self.network.replace_target_params() # 随机选择一小批记忆样本。 batch = self.BATCH if self.memory_counter > self.BATCH else self.memory_counter if self.prioritized: minibatch = self.replay_memory_store.sample(batch) else: minibatch = random.sample(self.replay_memory_store, batch) x, y, errors = self._get_targets(minibatch) if self.prioritized: # update errors for i in range(len(minibatch)): idx = minibatch[i][0] self.replay_memory_store.update(idx, errors[i]) self.network.train(x, y) else: self.network.train(x, y) self.learn_step_counter += 1 def _get_targets(self, batch): if self.prioritized: # (当前状态，当前动作，当前得分，下一个状态) = （s, a, r, s_）。 current_states = np.vstack([o[1][0] for o in batch]) current_actions = np.vstack([o[1][1] for o in batch]) current_rewards = np.vstack([o[1][2] for o in batch]) next_states = np.vstack([o[1][3] for o in batch]) else: current_states = np.vstack([o[0] for o in batch]) current_actions = np.vstack([o[1] for o in batch]) current_rewards = np.vstack([o[2] for o in batch]) next_states = np.vstack([o[3] for o in batch]) # 当前状态在 Q 网络的得分。 p = self.network.get_q(current_states) # 下一状态在 Q 网络的得分。 p_ = self.network.get_q(next_states) # 下一状态在 Target 网络的得分。 p_target = self.network.get_next_q(next_states) x = np.zeros((len(batch), self.STATE_NUM)) y = np.zeros((len(batch), self.ACTION_NUM)) errors = np.zeros(len(batch)) for i in range(len(batch)): s = current_states[i] a = current_actions[i] r = current_rewards[i][0] s_ = next_states[i] a_index = np.argmax(a) # 获得第 i 个样本当前状态的所有动作的 Q 值表。 target_q = p[i] # 获得第 i 个样本当前动作的 Q 得分。 current_q = target_q[a_index] max_q = p_target[i][np.argmax(p_[i])] if r <= -1 or s_ is None: target_q[a_index] = r else: target_q[a_index] = r + self.gamma * max_q x[i] = s y[i] = target_q errors[i] = abs(current_q - target_q[a_index]) return x, y, errors def train(self): """ 训练。 :return: """ # 初始化当前状态。 current_state = np.random.randint(0, self.ACTION_NUM - 1) self.epsilon = self.INITIAL_EPSILON while True: # 选择动作。 action = self.select_action(current_state) # 执行动作，得到：下一个状态，执行动作的得分，是否结束。 next_state, reward, done = self.run_game(current_state, action) # 保存记忆。 self.save_store(current_state, action, reward, next_state, done) # 先观察一段时间累积足够的记忆在进行训练。 if self.step_index > self.OBSERVE: self.experience_replay() if self.step_index - self.OBSERVE > self.TRAIN_NUM: break if done: current_state = np.random.randint(0, self.ACTION_NUM - 1) else: current_state = next_state self.step_index += 1 def pay(self): """ 运行并测试。 :return: """ self.train() # 显示 R 矩阵。 print(self.r) for index in range(5): start_room = index print("#############################", "Agent 在", start_room, "开始行动", "#############################") current_state = start_room step = 0 target_state = 5 while current_state != target_state: next_state = self.network.get_action(self.state_list[current_state:current_state + 1]) print("Agent 由", current_state, "号房间移动到了", next_state, "号房间") current_state = next_state step += 1 print("Agent 在", start_room, "号房间开始移动了", step, "步到达了目标房间 5") print("#############################", "Agent 在", 5, "结束行动", "#############################") def show_plt(self): import matplotlib.pyplot as plt plt.plot(np.array(self.q_list), c='r', label='natural') # plt.plot(np.array(q_double), c='b', label='double') plt.legend(loc='best') plt.ylabel('Q eval') plt.xlabel('training steps') plt.grid() plt.show() if __name__ == "__main__": agent = Agent(train_num=20000, prioritized=True) agent.pay() agent.show_plt()