Deep learning 强化学习，为何表现崩溃？

我正在尝试在TITAN X GPU服务器上使用A3C算法和TensorFlow在致命的_走廊场景的平台上培训一名代理，但是，经过大约2天多的培训后，性能崩溃了。如下图所示

走廊里有6个恶魔，特工应该杀死至少5个恶魔才能到达目的地并获得背心

这是新工作的代码

带有tf.variable\u范围（范围）：
self.inputs=tf.placeholder（shape=[None，*shape，1]，dtype=tf.float32）
self.conv_1=slim.conv2d（激活=tf.nn.relu，输入=self.inputs，num_输出=32，
内核大小=[8,8]，步幅=4，填充='SAME'）
self.conv_2=slim.conv2d（激活=tf.nn.relu，输入=self.conv_1，输出=64，
内核大小=[4,4]，步幅=2，填充='SAME'）
self.conv_3=slim.conv2d（激活=tf.nn.relu，输入=self.conv_2，输出=64，
内核大小=[3,3]，步幅=1，填充='SAME'）
self.fc=slim.fully_connected（slim.flatten（self.conv_3），512，activation_fn=tf.nn.elu）
#LSTM
lstm\u cell=tf.contrib.rnn.BasicLSTMCell（cfg.rnn\u DIM，state\u is\u tuple=True）
c_init=np.zeros（（1，lstm_cell.state_size.c），np.float32）
h_init=np.zeros（（1，lstm_cell.state_size.h），np.float32）
self.state_init=[c_init，h_init]
c_in=tf.placeholder（tf.float32[1，lstm_cell.state_size.c]）
h_in=tf.placeholder（tf.float32[1，lstm_cell.state_size.h]）
self.state_in=（c_in，h_in）
rnn_in=tf.expand_dims（self.fc，[0]）
步长大小=tf.shape（自输入）[:1]
state_in=tf.contrib.rnn.LSTMStateTuple（c_in，h_in）
lstm_输出，lstm_状态=tf.nn.dynamic_rnn（lstm_单元，
rnn_in，
初始状态=中的状态，
序列长度=步长大小，
时间（主=假）
lstm_c，lstm_h=lstm_状态
self.state_out=（lstm_c[：1，：]，lstm_h[：1，：]）
rnn_out=tf.重塑（lstm_输出，[-1256]）
#用于策略和价值估计的输出层
self.policy=slim.fully\u connected（rnn\u out，
cfg.ACTION_DIM，
激活\u fn=tf.nn.softmax，
偏差（初始值设定项=无）
self.value=slim.fully\u connected（rnn\u out，
1.
激活\u fn=无，
偏差（初始值设定项=无）
如果范围！='“全球”和“不玩”：
self.actions=tf.placeholder（shape=[None]，dtype=tf.int32）
self.actions\u onehot=tf.one\u hot（self.actions，cfg.ACTION\u DIM，dtype=tf.float32）
self.target_v=tf.placeholder（shape=[None]，dtype=tf.float32）
self.advantages=tf.placeholder（shape=[None]，dtype=tf.float32）
self.responsible\u outputs=tf.reduce\u sum（self.policy*self.actions\u onehot，axis=1）
#损失函数
self.policy_loss=-tf.reduce_sum（self.advantages*tf.log（self.responsible_输出+1e-10））
self.value\u loss=tf.reduce\u sum（tf.square（self.target\u v-tf.restrape（self.value，[-1]））
self.entropy=-tf.reduce_sum（self.policy*tf.log（self.policy+1e-10））
#使用本地损耗从本地网络获取梯度
局部变量=tf.get\u集合（tf.GraphKeys.TRAINABLE\u变量，范围）
值变量，策略变量=本地变量[：-2]+[本地变量[-1]]，本地变量[：-2]+[本地变量[-2]]
self.var\u norm=tf.global\u norm（局部变量）
self.value\u梯度=tf.梯度（self.value\u损失，value\u var）
value\u grads，self.grad\u norms\u value=tf.clip\u by\u global\u norm（self.value\u渐变，40.0）
self.policy_梯度=tf.gradients（self.policy_损失，policy_var）
policy_grads，self.grad_norms_policy=tf.clip_by_global_norm（self.policy_渐变，40.0）
#将局部梯度应用于全局网络
全局变量=tf.get\u集合（tf.GraphKeys.TRAINABLE\u变量，“全局”）
全局变量值，全局变量策略=\
全局变量[：-2]+[全局变量[-1]]，全局变量[：-2]+[全局变量[-2]]
self.apply_grads_value=优化器.apply_渐变（zip（value_grads，global_vars_value））
self.apply_grads_policy=optimizer.apply_渐变（zip（policy_grads，global_vars_policy））

优化器是

optimizer = tf.train.RMSPropOptimizer(learning_rate=1e-5)

这里是一些梯度和规范的总结

---

帮助某人可以帮助我解决这个问题。

现在，我个人认为，代理性能崩溃的原因可能是对值的过度优化。我读了一篇关于双DQN的论文，你可以读这篇论文