如何为PPO pretrain随机演员网络培训?

12个视图(30天)

显示旧的评论

Jan Dewez 2021年5月6日

0
链接

这个问题直接联系

//www.tianjin-qmedu.com/matlabcentral/answers/823380-how-to-pretrain-a-stochastic-actor-network-for-ppo-training

评论道: 安特兰 2021年5月17日

答:接受安特兰

我想创建一个输出操作数组的随机演员网络10 0和1之间的值观察28归一化值的数组。我指定如下上限和下限,以确保演员的输出是在0和1之间:

                         ActionInfo = rlNumericSpec (numActions [1],“LowerLimit”,(0,0,0,0,0,0,0,0,0,0),“UpperLimit”,(1;1;1;1;1;1;1;1;1;1]);
                        

我的随机网络看起来如下:

我已经创建了一个标准化的训练数据集(目标尺寸输入维度28日10)。我怎么使用这个数据集pretrain以上网络?

澄清:我想训练开始前PPO代理培训网络。

0评论
显示1年长的评论藏1年长的评论

登录置评。

在回答这个问题。

接受的答案

安特兰 2021年5月13日

1
链接

直接链接到这个答案

//www.tianjin-qmedu.com/matlabcentral/answers/823380-how-to-pretrain-a-stochastic-actor-network-for-ppo-training answer_699308

嗨,简,

你可以pretrain随机演员与深度学习工具箱 trainNetwork 一些额外的工作。Emmanouil最初给了一些好的建议,但我想添加这些步骤:

您需要一个自定义层损失自随机演员网络输出均值和标准差,而你的目标行动。你可以试试最大日志可能损失。你可以按照指令在这里创建一个定制的损失层(你不必实现向后通过自动分化会照顾)

%我们想最大化的目标日志f (x), f (x)是概率密度函数遵循正常的(意思是,σ)

% =损失目标日志(f (x)) = - = 1/2 *日志(2 *π)+日志(σ)+ 1/2 * ((xμ)/σ)^ 2;

记住,你必须防止日志(0),增加每股收益是充分的。x是你的行动目标。

4评论
显示3年长的评论隐藏3年长的评论

Jan Dewez 2021年5月13日

嗨,安,

通过更换回归层在我最初的例子与定制回归层myRegressionLayer我应该能够与初始数据集训练网络?在下面的代码中变量Y包含手段和标准devations因为演员网络输出。换句话说,输入自定义尺寸回归层是20吗?因为如果我试着训练的网络我得到一个错误(见下文)。

                                  % % pretrain随机神经网络的演员
                                 
                                  classdefmyRegressionLayer < nnet.layer.RegressionLayer
                                 
                                  属性
                                 
                                  %(可选)层属性。
                                 
                                  %图层属性到这里。
                                 
                                  结束
                                 
                                  方法
                                 
                                  函数层= myRegressionLayer(名称)
                                 
                                  %(可选)创建一个myRegressionLayer。
                                 
                                  层。Name =名称;
                                 
                                  层。描述=“最大日志可能损失”;
                                 
                                  %层构造函数。
                                 
                                  结束
                                 
                                  函数损失= forwardLoss(层,Y, T)
                                 
                                  %返回损失预测Y和培训
                                 
                                  %的目标T。
                                 
                                  %
                                 
                                  %的输入:
                                 
                                  %层——输出层
                                 
                                  % Y -预测由网络
                                 
                                  % T -培训目标
                                 
                                  %
                                 
                                  %输出:
                                 
                                  % T - Y之间的损失和损失
                                 
                                  %层转发损失函数。
                                 
                                  numActions =长度(Y) / 2;
                                 
                                  μ= 0 (numActions);
                                 
                                  σ= 0 (numActions);
                                 
                                  为我= 1:numActions
                                 
                                  μ(i) = Y(我);
                                 
                                  σ(i) = Y (i + numActions);
                                 
                                  结束
                                 
                                  损失= 0.5 *日志(2 *π)+日志(σ+ eps) + 0.5 * ((tμ)。/(σ+ eps)) ^ 2;
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束

                                  错误使用trainNetwork(第183行)
                                 
                                  无效的训练数据。最后一层的输出大小(20)没有
                                 
                                  匹配反应(10)的数量。
                                 
                                  错误在pretraining(35)行
                                 
                                  网= trainNetwork (PtrainArray2 TtrainArray2、net_actor选项);

在随机网络:

                                  inPath = [featureInputLayer numObs,“归一化”,“没有”,“名字”,“myobs”)% numObs = 28
                                 
                                  fullyConnectedLayer (380“名字”,“hidden1”)
                                 
                                  reluLayer (“名字”,“relu1”)
                                 
                                  fullyConnectedLayer (195“名字”,“hidden2”)
                                 
                                  reluLayer (“名字”,“relu2”)
                                 
                                  fullyConnectedLayer (100“名字”,“hidden3”)
                                 
                                  reluLayer (“名字”,“relu3”));
                                 
                                  %路径层平均值(10×1的输入和输出
                                 
                                  meanPath = [fullyConnectedLayer numActions,“名字”,“手段”)% numActions = 10
                                 
                                  sigmoidLayer (“名字”,“乙状结肠”)
                                 
                                  scalingLayer (“名字”,“规模”,“规模”ActionInfo.UpperLimit,“偏见”(ActionInfo.UpperLimit-ActionInfo.LowerLimit) / 2)];
                                 
                                  %路径层标准差(10×1的输入和输出)
                                 
                                  %使用softplus层非负
                                 
                                  sdevPath = [fullyConnectedLayer numActions,“名字”,的标准偏差)
                                 
                                  softplusLayer (“名字”,“splus”));
                                 
                                  %连接两个输入# 1(维度),形成一个由1(20)输出层
                                 
                                  支出= [concatenationLayer (1、2、“名字”,“mean&sdev”)
                                 
                                  myRegressionLayer (“行动”));
                                 
                                  %添加层网络对象
                                 
                                  net_actor = layerGraph (inPath);
                                 
                                  net_actor = addLayers (net_actor meanPath);
                                 
                                  net_actor = addLayers (net_actor sdevPath);
                                 
                                  net_actor = addLayers (net_actor,支出);
                                 
                                  %连接层:中值路径输出必须首先连接到输入concatenationLayer
                                 
                                  net_actor = connectLayers (net_actor,“relu3”,“意味着/”);%连接inPath meanPath输入的输出
                                 
                                  net_actor = connectLayers (net_actor,“relu3”,的标准偏差/);%连接inPath sdevPath输入的输出
                                 
                                  net_actor = connectLayers (net_actor,“规模”,“mean&sdev /三机一体”);%连接meanPath浓缩的层的输出输入# 1
                                 
                                  net_actor = connectLayers (net_actor,“splus”,“mean&sdev / in2”);

Jan Dewez 2021年5月15日

我重写我的自定义回归类是这样的:

                                  classdefmyRegressionLayer < nnet.layer.RegressionLayer
                                 
                                  方法
                                 
                                  函数层= myRegressionLayer ()
                                 
                                  %(可选)创建一个myRegressionLayer。
                                 
                                  层。Name =名称;
                                 
                                  层。描述=“最大日志可能损失”;
                                 
                                  %层构造函数。
                                 
                                  结束
                                 
                                  函数损失= forwardLoss(层,Y, T)
                                 
                                  %返回损失预测Y和培训
                                 
                                  %的目标T。
                                 
                                  %
                                 
                                  %的输入:
                                 
                                  %层——输出层
                                 
                                  % Y -预测由网络(20 x minibatchsize)
                                 
                                  % T -培训目标(20 x mminibatchsize)
                                 
                                  %
                                 
                                  %输出:
                                 
                                  % T - Y之间的损失和损失
                                 
                                  numActions =身高(Y) / 2;
                                 
                                  μ= Y (1: numActions,:);% (10 x minibatchsize)
                                 
                                  σ= Y (numActions + 1:最终,);% (10 x minibatchsize)
                                 
                                  为我= 1:numActions
                                 
                                  损失(我:)= 0.5 *日志(2 *π)+日志(σ(我:)+ eps) + 0.5 * ((T(我,:)μ(我,:))。/(σ(我:)+ eps)) ^ 2;
                                 
                                  结束
                                 
                                  disp (的损失:);
                                 
                                  disp(损失);
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束

当我例如MiniBatchSize设置为5,损失是这样的:

                                  失:
                                 
                                  10×5单dlarray
                                 
                                  0.7065 0.7062 0.7346 0.7249 0.6832
                                 
                                  1.0642 1.0203 1.0669 1.0500 1.0539
                                 
                                  0.7998 1.0349 1.3149 1.2599 0.8729
                                 
                                  1.5574 1.5650 1.5613 1.6017 1.5787
                                 
                                  1.2772 1.1369 1.5798 1.4769 1.2660
                                 
                                  0.7744 0.7541 0.7840 0.7776 0.7427
                                 
                                  0.8501 0.8206 0.8311 0.8372 0.8288
                                 
                                  0.7570 0.7704 0.7467 0.8035 0.7890
                                 
                                  0.7789 0.7916 0.7898 0.7881 0.8122
                                 
                                  0.7692 0.7411 0.7553 0.7528 0.7689

其次是这个错误:

                                  错误使用trainNetwork(第183行)
                                 
                                  错误在层myRegressionLayer使用“backwardLoss”。和函数抛出一个错误
                                 
                                  可以不被执行。
                                 
                                  错误在pretraining(42)行
                                 
                                  网= trainNetwork (PtrainArray2 TtrainArray2_ext、net_actor选项);
                                 
                                  引起的由:
                                 
                                  错误使用dlarray / dlgradient(51)行
                                 
                                  价值区分必须追踪dlarray标量。

我不知道如何解决这个问题。“损失”应该是什么样子的呢?

安特兰 2021年5月17日

正如前面提到的错误消息,价值区分必须是一个标量。因此,你需要计算的意思在每一批的损失。另外,我不明白为什么你需要一个for循环计算损失。我们可以vectorize计算之后(因为σ,T,μ具有相同的大小)

                                  % vectorize损失计算
                                 
                                  损失= 0.5 *日志(2 *π)+日志(σ+ eps) + 0.5 * ((tμ)。/(σ+ eps)) ^ 2;
                                 
                                  %的意思是在每一批的损失
                                 
                                  损失=总和(损失,“所有”);
                                 
                                  损失= / batchSize损失;