如何解决强化学习的政策梯度会反向传播哪些损失或奖励？
我用Python编写了一个小脚本，以通过策略梯度来解决各种Gym环境。
import gym,os
import numpy as np
#create environment
env = gym.make('Cartpole-v0')
env.reset()
s_size = len(env.reset())
a_size = 2
#import my neural network code
os.chdir(r'C:\---\---\---\Python Code')
import RLPolicy
policy = RLPolicy.NeuralNetwork([s_size,a_size],learning_rate=0.000001,['softmax']) #a 3layer network might be ([s_size,5,learning_rate=1,['tanh','softmax'])
#it supports the sigmoid activation function also
print(policy.weights)
DISCOUNT = 0.95 #parameter for discounting future rewards
#first step
action = policy.feedforward(env.reset)
state,reward,done,info = env.step(action)
for t in range(3000):
done = False
states = [] #lists for recording episode
probs2 = []
rewards = []
while not done:
#env.render() #to visualize learning
probs = policy.feedforward(state)[-1] #calculate probabilities of actions
action = np.random.choice(a_size,p=probs) #choose action from probs
#record and update state
probs2.append(probs)
states.append(state)
state,info = env.step(action)
rewards.append(reward) #should reward be before updating state?
#calculate gradients
gradients_w = []
gradients_b = []
for i in range(len((rewards))):
totalReward = sum([rewards[t]*DISCOUNT**t for t in range(len(rewards[i:]))]) #discounted reward
## !! this is the line that I need help with
gradient = policy.backpropagation(states[i],totalReward*(probs2[i])) #what should be backpropagated through the network
## !!
##record gradients
gradients_w.append(gradient[0])
gradients_b.append(gradient[1])
#combine gradients and update the weights and biases
gradients_w = np.array(gradients_w,object)
gradients_b = np.array(gradients_b,object)
policy.weights += policy.learning_rate * np.flip(np.sum(gradients_w,0),0) #np.flip because the gradients are calculated backwards
policy.biases += policy.learning_rate * np.flip(np.sum(gradients_b,0)
#reset and record
env.reset()
if t%100==0:
print('t'+str(t),'r',sum(rewards))
应该向后传递什么来计算梯度？我正在使用梯度上升，但可以将其切换为下降。有人将奖励功能定义为 totalReward * log（probabilities）。这会使分数导数 totalReward *（1 / probs）或 log（probs）或其他东西吗？您是否使用诸如交叉熵之类的成本函数？
我试过了totalReward*np.log(probs) totalReward*(1/probs) totalReward*(probs**2) totalReward*probs
probs = np.zeros(a_size)
probs[action] = 1
totalRewards*probs
和其他几个。 最后一个是唯一能够解决其中任何一个问题的解决方案，并且仅适用于Cartpole。我已经在Cartpole，Pendulum和MountainCar上用梯度上升和下降测试了数千个情节的各种损失或得分函数。有时候，它会有所改善，但永远无法解决。我在做什么错了？
这是RLPolicy代码。它的编写或伪编码不好，但是我不认为这是问题所在，因为我多次进行了梯度检查。但是，即使我可以将其范围缩小到神经网络或代码中其他地方的问题，也会很有帮助。
#Neural Network
import numpy as np
import random,math,time,os
from matplotlib import pyplot as plt
def activation(x,function):
if function=='sigmoid':
return(1/(1+math.e**(-x))) #Sigmoid
if function=='relu':
x[x<0]=0
return(x)
if function=='tanh':
return(np.tanh(x.astype(float))) #tanh
if function=='softmax':
z = np.exp(np.array((x-max(x)),float))
y = np.sum(z)
return(z/y)
def activationDerivative(x,function):
if function=='sigmoid':
return(x*(1-x))
if function=='relu':
x[x<0]==0
x[x>0]==1
return(x)
if function=='tanh':
return(1-x**2)
if function=='softmax':
s = x.reshape(-1,1)
return(np.diagflat(s) - np.dot(s,s.T))
class NeuralNetwork():
def __init__ (self,layers,learning_rate,momentum,regularization,activations):
self.learning_rate = learning_rate
if (isinstance(layers[1],list)):
h = layers[1][:]
del layers[1]
for i in h:
layers.insert(-1,i)
self.layers = layers
self.weights = [2*np.random.rand(self.layers[i]*self.layers[i+1])-1 for i in range(len(self.layers)-1)]
self.biases = [2*np.random.rand(self.layers[i+1])-1 for i in range(len(self.layers)-1)]
self.weights = np.array(self.weights,object)
self.biases = np.array(self.biases,object)
self.activations = activations
def feedforward(self,input_array):
layer = input_array
neuron_outputs = [layer]
for i in range(len(self.layers)-1):
layer = np.tile(layer,self.layers[i+1])
layer = np.reshape(layer,[self.layers[i+1],self.layers[i]])
weights = np.reshape(self.weights[i],self.layers[i]])
layer = weights*layer
layer = np.sum(layer,1)#,self.layers[i+1]-1)
layer = layer+self.biases[i]
layer = activation(layer,self.activations[i])
neuron_outputs.append(np.array(layer,float))
return(neuron_outputs)
def neuronErrors(self,l,neurons,layerError,n_os):
if (l==len(self.layers)-2):
return(layerError)
totalErr = [] #total error
for e in range(len(layerError)): #-layers
e = e*self.layers[l+2]
a_ws = self.weights[l+1][e:e+self.layers[l+1]]
e = int(e/self.layers[l+2])
err = layerError[e]*a_ws #error
totalErr.append(err)
return(sum(totalErr))
def backpropagation(self,state,loss):
weights_gradient = [np.zeros(self.layers[i]*self.layers[i+1]) for i in range(len(self.layers)-1)]
biases_gradient = [np.zeros(self.layers[i+1]) for i in range(len(self.layers)-1)]
neuron_outputs = self.feedforward(state)
grad = self.individualBackpropagation(loss,neuron_outputs)
return(grad)
def individualBackpropagation(self,difference,neuron_outputs): #number of output
lr = self.learning_rate
n_os = neuron_outputs[:]
w_o = self.weights[:]
b_o = self.biases[:]
w_n = self.weights[:]
b_n = self.biases[:]
gradient_w = []
gradient_b = []
error = difference[:] #error for neurons
for l in range(len(self.layers)-2,-1,-1):
p_n = np.tile(n_os[l],self.layers[l+1]) #previous neuron
neurons = np.arange(self.layers[l+1])
error = (self.neuronErrors(l,error,n_os))
if not self.activations[l]=='softmax':
error = error*activationDerivative(neuron_outputs[l+1],self.activations[l])
else:
error = error @ activationDerivative(neuron_outputs[l+1],self.activations[l]) #because softmax derivative returns different dimensions
w_grad = np.repeat(error,self.layers[l]) #weights gradient
b_grad = np.ravel(error) #biases gradient
w_grad = w_grad*p_n
b_grad = b_grad
gradient_w.append(w_grad)
gradient_b.append(b_grad)
return(gradient_w,gradient_b)
谢谢您的回答，这是我在这里的第一个问题。
解决方法
将此帖子用作计算梯度（https://medium.com/@jonathan_hui/rl-policy-gradients-explained-9b13b688b146）的参考：
在我看来totalRewardOfEpisode*np.log(probability of sampled action)是正确的计算。但是，为了更好地估计坡度，我建议使用许多情节进行计算。 （例如，您只需将30除以30即可得出平均结束梯度）
使用totalReward*np.log(probs)进行测试的主要区别在于，对于每一步，我认为您应该仅对采样动作的概率进行反向传播，而不是对整个输出进行反向传播。最初在引用的文章中，他们使用总奖励，但最后建议您像现在一样使用当前和未来奖励的折现奖励，这样该部分在理论上似乎没有问题。
旧答案：
据我所知，deepRL方法经常使用对游戏状态值或每个动作值的一些估计。从我在您的代码中看到的，您有一个神经网络，该神经网络仅输出每个动作的概率。
尽管您想要的绝对是总奖励的最大化，但是由于环境原因，您无法计算最终奖励的梯度。我建议您考虑使用诸如deepQLearning之类的方法或基于Actor / Critic的方法（如PPO）。
鉴于您选择的方法，您将获得有关如何计算梯度的不同答案。
, mprouveur的回答是正确的一半，但我认为我需要解释正确的做法以进行反向传播。在ai.stackexchange.com上对my question的答案是我如何理解这一点的。向后传播的正确误差是采取行动的对数概率乘以目标奖励。也可以将其计算为输出的概率与零数组之间的交叉熵损失，并且所采取的行动为1。由于交叉熵损失的导数，这将具有仅推高概率的可能性。接近采取的行动。然后，总奖励的乘积使更好的动作被更多地推到更高的概率。因此，在标签为单热编码矢量的情况下，正确的方程为label/probs * totalReward，因为这是交叉熵损失的导数和概率的对数的导数。我在其他代码中使用了此功能，但是即使使用此等式，我也认为代码中的其他内容是错误的。这可能与我如何使softmax导数过于复杂而不是通过组合交叉熵导数和softmax导数来计算通常的方式有关。我将尽快使用正确的代码和更多信息来更新此答案。
这里的损失取决于每个问题的输出。通常，反向传播的损失应为代表您已处理的一切的数字。对于策略梯度，这将是它认为可以与原始奖励进行比较的奖励，对数只是将其返回到概率随机变量的一种方法。单一尺寸。如果要检查代码背后的行为，则应始终检查每个过程之间的形状/尺寸以充分理解
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
