Deep Q-Network 学习笔记（六）—— 改进④：dueling dqn
这篇同样是完全没看懂 Orz，这里只做实现记录。。
要改动的地方只是在神经网络的最后一层做下调整即可。
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_eval_target = tf.placeholder(shape=[None, self.OUTPUT_NUM], dtype=tf.float32, name="q_target") def _dueling_builder(input_data, name, nl_1, w_initializer, b_initializer):
with tf.variable_scope('l1'):
w1 = tf.get_variable('w1', [self.INPUT_NUM, nl_1], initializer=w_initializer, collections=name)
b1 = tf.get_variable('b1', [1, nl_1], initializer=b_initializer, collections=name)
l1 = tf.nn.relu(tf.matmul(input_data, w1) + b1) with tf.variable_scope('Value'):
w2 = tf.get_variable('w2', [nl_1, 1], initializer=w_initializer, collections=name)
b2 = tf.get_variable('b2', [1, 1], initializer=b_initializer, collections=name)
self.V = tf.matmul(l1, w2) + b2 with tf.variable_scope('Advantage'):
w2 = tf.get_variable('w2', [nl_1, self.OUTPUT_NUM], initializer=w_initializer, collections=name)
b2 = tf.get_variable('b2', [1, self.OUTPUT_NUM], initializer=b_initializer, collections=name)
self.A = tf.matmul(l1, w2) + b2
with tf.variable_scope('Q'):
out = self.V + (self.A - tf.reduce_mean(self.A, axis=1, keep_dims=True)) return out with tf.variable_scope("eval_net"):
q_name = ['eval_net_params', tf.GraphKeys.GLOBAL_VARIABLES] self.q_eval_output = _dueling_builder(self.q_eval_input, q_name, neuro_layer_1, w_init, b_init)
self.q_predict = tf.argmax(self.q_eval_output, 1) with tf.variable_scope('loss'):
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] self.q_target_output = _dueling_builder(self.q_target_input, t_name, neuro_layer_1, w_init, b_init)
完整代码
优先采样：
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_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 V = None
A = None 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_eval_target = tf.placeholder(shape=[None, self.OUTPUT_NUM], dtype=tf.float32, name="q_target") def _dueling_builder(input_data, name, nl_1, w_initializer, b_initializer):
with tf.variable_scope('l1'):
w1 = tf.get_variable('w1', [self.INPUT_NUM, nl_1], initializer=w_initializer, collections=name)
b1 = tf.get_variable('b1', [1, nl_1], initializer=b_initializer, collections=name)
l1 = tf.nn.relu(tf.matmul(input_data, w1) + b1) with tf.variable_scope('Value'):
w2 = tf.get_variable('w2', [nl_1, 1], initializer=w_initializer, collections=name)
b2 = tf.get_variable('b2', [1, 1], initializer=b_initializer, collections=name)
self.V = tf.matmul(l1, w2) + b2 with tf.variable_scope('Advantage'):
w2 = tf.get_variable('w2', [nl_1, self.OUTPUT_NUM], initializer=w_initializer, collections=name)
b2 = tf.get_variable('b2', [1, self.OUTPUT_NUM], initializer=b_initializer, collections=name)
self.A = tf.matmul(l1, w2) + b2
with tf.variable_scope('Q'):
out = self.V + (self.A - tf.reduce_mean(self.A, axis=1, keep_dims=True)) return out with tf.variable_scope("eval_net"):
q_name = ['eval_net_params', tf.GraphKeys.GLOBAL_VARIABLES] self.q_eval_output = _dueling_builder(self.q_eval_input, q_name, neuro_layer_1, w_init, b_init)
self.q_predict = tf.argmax(self.q_eval_output, 1) with tf.variable_scope('loss'):
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] self.q_target_output = _dueling_builder(self.q_target_input, t_name, neuro_layer_1, w_init, b_init) 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):
# 执行步数。
self.step_index = 0 # 状态数。
self.STATE_NUM = 6 # 动作数。
self.ACTION_NUM = 6 # 记忆上限。
self.memory_size = 5000 # 当前记忆数。
self.memory_counter = 0 self.replay_memory_store = Memory(self.memory_size) # 训练之前观察多少步。
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.r_list = [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) 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) x, y, errors = self._get_targets([(0, memory_data)])
self.replay_memory_store.add(errors[0], memory_data) 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 minibatch = self.replay_memory_store.sample(batch) x, y, errors = self._get_targets(minibatch) # 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) self.learn_step_counter += 1 def _get_targets(self, batch):
# (当前状态，当前动作，当前得分，下一个状态) = （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]) # 当前状态在 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) test_reward = reward / 10
self.r_list.append(test_reward + self.r_list[-1]) # 保存记忆。
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.r_list), c='r', label='dueling')
# plt.plot(np.array(q_double), c='b', label='double')
plt.legend(loc='best')
plt.ylabel('accumulated reward')
plt.xlabel('training steps')
plt.grid()
plt.show() if __name__ == "__main__":
agent = Agent(train_num=20000)
agent.pay()
agent.show_plt()
Deep Q-Network 学习笔记（六）—— 改进④：dueling dqn的更多相关文章
- 强化学习系列之:Deep Q Network (DQN)
文章目录 [隐藏] 1. 强化学习和深度学习结合 2. Deep Q Network (DQN) 算法 3. 后续发展 3.1 Double DQN 3.2 Prioritized Replay 3. ...
- 深度学习（二十六）Network In Network学习笔记
深度学习(二十六)Network In Network学习笔记 Network In Network学习笔记 原文地址:http://blog.csdn.net/hjimce/article/deta ...
- 深度增强学习--Deep Q Network
从这里开始换个游戏演示,cartpole游戏 Deep Q Network 实例代码 import sys import gym import pylab import random import n ...
- AlphaGo的前世今生（一）Deep Q Network and Game Search Tree：Road to AI Revolution
这一个专题将会是有关AlphaGo的前世今生以及其带来的AI革命,总共分成三节.本人水平有限,如有错误还望指正.如需转载,须征得本人同意. Road to AI Revolution(通往AI革命之路 ...
- Deep Q Network(DQN)原理解析
1. 前言 在前面的章节中我们介绍了时序差分算法(TD)和Q-Learning,当状态和动作空间是离散且维数不高时可使用Q-Table储存每个状态动作对的Q值,而当状态和动作空间是高维连续时,使用Q- ...
- Network In Network学习笔记
Network In Network学习笔记 原文地址:http://blog.csdn.net/hjimce/article/details/50458190 作者:hjimce 一.相关理论 本篇 ...
- 【opencv学习笔记六】图像的ROI区域选择与复制
图像的数据量还是比较大的,对整张图片进行处理会影响我们的处理效率,因此常常只对图像中我们需要的部分进行处理,也就是感兴趣区域ROI.今天我们来看一下如何设置图像的感兴趣区域ROI.以及对ROI区域图像 ...
- # go微服务框架kratos学习笔记六(kratos 服务发现 discovery)
目录 go微服务框架kratos学习笔记六(kratos 服务发现 discovery) http api register 服务注册 fetch 获取实例 fetchs 批量获取实例 polls 批 ...
- java之jvm学习笔记六-十二(实践写自己的安全管理器)(jar包的代码认证和签名) (实践对jar包的代码签名) (策略文件)(策略和保护域) (访问控制器) (访问控制器的栈校验机制) (jvm基本结构)
java之jvm学习笔记六(实践写自己的安全管理器) 安全管理器SecurityManager里设计的内容实在是非常的庞大,它的核心方法就是checkPerssiom这个方法里又调用 AccessCo ...
- Learning ROS for Robotics Programming Second Edition学习笔记(六) indigo xtion pro live
中文译著已经出版,详情请参考:http://blog.csdn.net/ZhangRelay/article/category/6506865 Learning ROS for Robotics Pr ...
随机推荐
- AI_ 视频监控-人体移动捕捉监测
总目录地址:AI 系列 总目录 需要最新源码,或技术提问,请加QQ群:538327407 我的各种github 开源项目和代码:https://github.com/linbin524 需求 为了实现 ...
- 如何优化代码中大量的if/else,switch/case?
前言 随着项目的迭代,代码中存在的分支判断可能会越来越多,当里面涉及到的逻辑比较复杂或者分支数量实在是多的难以维护的时候,我们就要考虑下,有办法能让这些代码变得更优雅吗? 正文 使用枚举 这里我们简单 ...
- 敏捷项目-依赖项拖动change
1. 2.类方法插入数据.
- Android代码编译出现的错误
一.decoupled apps failed 解耦应用程序失败 2.每次编译时候一定先扩充内存 export JACK_SERVER_VM_ARGUMENTS="-Dfile.encod ...
- Swift 如何像 C语言 那样接收入口参数？
我们都知道在 Swift 语言当中不再有 main 函数了,可能了解过 C语言或者 Java 语言的同学对这一点赶到深深的不适.总之,取而代之的是 main.swift. int main(int a ...
- JavaScript基础函数和词法分析以及常用的内置对象和使用方法（4）
day52 参考:https://www.cnblogs.com/liwenzhou/p/8004649.html 函数 函数定义 JavaScript中的函数和Python中的非常类似,只是定义方式 ...
- Python(多线程threading模块)
day27 参考:http://www.cnblogs.com/yuanchenqi/articles/5733873.html CPU像一本书,你不阅读的时候,你室友马上阅读,你准备阅读的时候,你室 ...
- window7下Python安装
去python官网下载软件,https://www.python.org. 选择dowloads-->windows,选择稳定版python3.5.2,x86表示32位操作系统,x86-64表示 ...
- 【bug】安卓浏览器键盘输入改变弹出层的定位
bug描述 在安卓浏览器中,有一个在页面底部的弹出层表单,样式如下: .popup { position: absolute; bottom: 0; } 当在这个弹出层输入内容,键盘自动弹出,弹出层的 ...
- [Swift实际操作]七、常见概念-(2)点CGPoint和变形CGAffineTransform的使用
本文将为你演示点对象CGPoint的使用,其中CG表示来自CoreGraphic(核心图形)这个跨平台框架 首先导入需要使用的两个框架第一个框架表示界面工具框架第二个框架表示核心绘图和动画框架 imp ...