Levenberg Marquardt实施问题

我刚读过，但我不太明白。

当你说

我认为你不希望为了更好的下降而减小mu。这会使反转变得越来越奇异。你想要增加。

我困惑。如果mu变大，LM就会接近最陡下降，变得非常慢。如果很小，LM收敛到准牛顿，那就更快了。

这是我们正在讨论的循环:

                                 为I = 1:迭代
                                
                                 而Mu <= max_mu && Mu > 1e-20
                                
                                 % PREV-PERFORMANCE计算
                                
                                 Pred = LW*tansig(IW*x + Ib) + Lb;
                                
                                 pre_perf = mean((y-Pred).^2);
                                
                                 %%%%%%%%%%%%%%%%%%%%%%%%
                                
                                 %以前的权重\偏差存储
                                
                                 pre_iw = IW;
                                
                                 pre_ib = Ib;
                                
                                 Prev_LW = LW;
                                
                                 Prev_Lb = Lb;
                                
                                 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                
                                 %计算梯度\黑森
                                
                                 [IWJ,IbJ,LWJ,LbJ] = Jacobian_LM(IW,LW,Ib,Lb,x,y);
                                
                                 [IWUpdate, ibuupdate,LWUpdate, lbuupdate] = UpdatesThroughHessianAndGradient(IWJ,IbJ,LWJ,LbJ,Pred,y,mu);
                                
                                 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                                
                                 %的权重\偏见更新
                                
                                 = IW + IWUpdate;
                                
                                 Ib = Ib + iupdate;
                                
                                 LW = LW + LWUpdate';
                                
                                 Lb = Lb + lbuupdate;
                                
                                 %%%%%%%%%%%
                                
                                 %性能计算
                                
                                 Pred = LW*tansig(IW*x + Ib) + Lb;
                                
                                 Perf = mean((y-Pred).^2);
                                
                                 %%%%%%%%%%%%%%%%%%%%%%%%
                                
                                 %性能检查
                                
                                 如果(Perf >= pre_perf)
                                
                                 IW = pre_iw;
                                
                                 Ib = Prev_Ib;
                                
                                 LW = Prev_LW;
                                
                                 Lb = Prev_Lb;
                                
                                 Mu = Mu * mu_incree_rate;
                                
                                 其他的
                                
                                 μ=μ* mu_decrease_rate;
                                
                                 打破；
                                
                                 结束
                                
                                 %%%%%%%%%%%%%%%%%%
                                
                                 结束
                                
                                 结束

我99%肯定这个循环结构和trainlm是一样的。每次迭代时，都会启动一个while循环，试图通过更新mu和权重来提高性能。如果新的权重带来更好的性能，则while循环结束，否则mu将增加。在任何情况下，如果mu超过max_mu或1e-20，则循环结束。

在trainlm函数中，这部分是(当然这里还有其他停止条件，但我在测试中禁用了所有条件):

                                 函数[worker,calcNet] = trainingIteration(worker,calcLib,calcNet)
                                
                                 %跨工作控制变量
                                
                                 muBreak = [];
                                
                                 perfBreak = [];
                                
                                 马夸特
                                
                                 而真正的
                                
                                 如果calcLib.isMainWorker
                                
                                 muBreak =工人。μ> worker.param.mu_max);
                                
                                 结束
                                
                                 如果calcLib.broadcast (muBreak)
                                
                                 打破
                                
                                 结束
                                
                                 如果calcLib.isMainWorker
                                
                                 %检查奇异矩阵
                                
                                 [msgstr, msgstr] = lastwarn;
                                
                                 lastwarn (MATLAB:没什么的，MATLAB:没什么的）
                                
                                 警告状态=警告(“关闭”，“所有”);
                                
                                 dWB = -(工人)。Jj +工人。i * worker.mu) \ worker.je;
                                
                                 [~，msgid1] = lastwarn;
                                
                                 Flag_inv = isequal(msgid1，MATLAB:没什么的);
                                
                                 如果flag_inv
                                
                                 lastwarn (msgstr,是否);
                                
                                 结束；
                                
                                 警告(warnstate)
                                
                                 工人。WB2 =工人。WB + dWB;
                                
                                 结束
                                
                                 calcNet2 = calcLib.setwb(calcNet,worker.WB2);
                                
                                 perf2 = calcLib.trainPerf(calcNet2);
                                
                                 如果calcLib.isMainWorker
                                
                                 perfBreak = (perf2 < worker.perf) && flag_inv;
                                
                                 结束
                                
                                 如果calcLib.broadcast (perfBreak)
                                
                                 工人。WB = worker.WB2;
                                
                                 calcNet = calcNet2;
                                
                                 如果calcLib.isMainWorker
                                
                                 工人。μ= max(worker.mu * worker.param.mu_dec,1e-20);
                                
                                 结束
                                
                                 打破
                                
                                 结束
                                
                                 如果calcLib.isMainWorker
                                
                                 工人。μ= worker.mu * worker.param.mu_inc;
                                
                                 结束
                                
                                 结束

13个评论
显示隐藏 12旧评论

罗伯特。 2019年12月23日

嗨,马特,

非常感谢你的回答。在这个函数中:

                                 函数[IWUpdate, ibuupdate,LWUpdate, lbuupdate] = UpdatesThroughHessianAndGradient(IWJ,IbJ,LWJ,LbJ,Pred,y,mu)
                                
                                 这个函数的摘要在这里
                                
                                 详细的解释在这里
                                
                                 1 = size(IWJ,1);
                                
                                 s2 = size(IWJ,2);
                                
                                 3 = size(IbJ,1);
                                
                                 4 = size(LWJ,1);
                                
                                 5 = size(LbJ,1);
                                
                                 6 = size(IWJ,3);
                                
                                 Jac = nan(s1*s2 + s3 + s4 + s5,s6);
                                
                                 Jac(1:s1*s2，:) = align = align (1,s1*s2, 1);
                                
                                 Jac(s1*s2+1:s1*s2+s3，:) = IbJ;
                                
                                 Jac(s1*s2+s3+1:s1*s2+s3+s4，:) = LWJ;
                                
                                 Jac(s1*s2+s3+s4+1:s1*s2+s3+s4+s5，:) = LbJ;
                                
                                 H = (Jac*Jac')/ 6;
                                
                                 D =平均;*(Pred - y)，2);
                                
                                 Update_Tot = -pinv (H +μ*眼(大小(H, 1))、min (H (:)) / 1000) * D;
                                
                                 IWUpdate = transform (Update_Tot(1:s1*s2)，s1,s2);
                                
                                 (s1*s2+1:s1*s2+s3);
                                
                                 LWUpdate = Update_Tot(s1*s2+s3+1:s1*s2+s3+s4);
                                
                                 LbUpdate = (s1*s2+s3+s4+1:s1*s2+s3+s4+s5);
                                
                                 结束

我试着替换这个:

Update_Tot = -pinv (H +μ*眼(大小(H, 1))、min (H (:)) / 1000) * D;

用这个:

                                 a = H + mu*eye(size(H,1));
                                
                                 Update_Tot = -linsolve(a,D);

还有这个:

                                 a = H + mu*eye(size(H,1));
                                
                                 Update_Tot = -a\D;

                                 a = H + mu*eye(size(H,1));
                                
                                 Update_Tot = -mldivide(a,D);

还有:

                                 a = H + mu*eye(size(H,1));
                                
                                 Update_Tot = -inv(a)*D;

这些方法都改善了执行时间，但最终结果与trainlm的执行时间仍然相差很大。

特别是这3种似乎是计算更新向量的更快的方法:

                                 Update_Tot = -linsolve(a,D);
                                
                                 Update_Tot = -a\D;
                                
                                 Update_Tot = -mldivide(a,D);

但它们需要大致相同的执行时间。

例如，当matlab的trainlm需要大约5秒时，这些需要大约15秒和-inv(a)*D;大约需要25秒。

我做错了什么?

我只是在单个epoch上运行检查，以便评估代码单个部分的执行时间。

结果:

                                 以前的性能计算
                                
                                 运行时间是0.002138秒。
                                
                                 以前的w / b存储
                                
                                 运行时间为0.000032秒。
                                
                                 雅可比矩阵计算
                                
                                 运行时间为0.009249秒。
                                
                                 黑森梯度计算
                                
                                 运行时间是0.012288秒。
                                
                                 W \ b更新
                                
                                 运行时间是0.000297秒。
                                
                                 新性能计算
                                
                                 运行时间是0.001972秒。
                                
                                 性能检查和更新
                                
                                 运行时间是0.000053秒。

显然存在两个主要瓶颈:

雅可比矩阵计算
海赛/梯度计算

雅可比矩阵是由 Jacobian_LM 函数中唯一慢的部分是for循环:

                                 IWJ = nan(size(deltaw,1)，size(x,1)，size(x,2));
                                
                                 为I = 1:size(x,2)
                                
                                 IWJ(:，:，i) = deltaw (:，i).*x(:，i)';
                                
                                 结束

你们还能找到其他方法来计算输入权矩阵的雅可比矩阵吗?

deltaIW的大小为(num个隐藏神经元，num个示例)

X有大小(输入维度，个数)

有什么方法可以避免这个例子的循环吗?

另一方面，黑线和梯度由函数计算 UpdatesThroughHessianAndGradient。

在这个函数中有2个缓慢的部分:

从单权重/偏置雅可比矩阵的次要部分开始构建雅可比矩阵:

                                 Jac = 0 (s1*s2 + s3 + s4 + s5,s6);
                                
                                 Jac(1:s1*s2，:) = align = align (1,s1*s2, 1);
                                
                                 Jac(s1*s2+1:s1*s2+s3，:) = IbJ;
                                
                                 Jac(s1*s2+s3+1:s1*s2+s3+s4，:) = LWJ;
                                
                                 Jac(s1*s2+s3+s4+1:s1*s2+s3+s4+s5，:) = LbJ;

的倒置:

作为最慢的部分:

                                 H = (Jac*Jac')/ 6;
                                
                                 D =平均;*(Pred - y)，2);
                                
                                 Update_Tot = -(H + mu*eye(size(H,1))))\D;

我看不出有任何改进的余地。唯一的方法应该是避免计算每个例子的导数，但我不知道怎么做…

马特·J 2019年12月23日

是的，计算它的方法是不计算它。这里需要注意的是

J =重塑(s1 * s2, IWJ s6)

等于

J = kron (x, deltaIW)

这里有特殊计算恒等式可以用来计算它们对H和D的贡下载188bet金宝搏献，而不是扩展克罗内克积。

我不太明白你为什么

                                 H =(江淮*江淮。')/ s6
                                
                                 D =平均;*(Pred - y)，2);

当我认为它应该是

                                 H =(江淮。*江淮)/ s6
                                
                                 D =江淮。“*(p - y)”

如果我假设后者是您的意思，那么IJW对这些表达式的贡献是

                                 H_ijw = J。‘* J / s6 = kron (x ' * x, deltaIW * deltaW) / s6
                                
                                 E = Pred (1: s1 * s2) - y (1: s1 * s2);
                                
                                 D_ijw = deltaIW。”*(重塑(E, s1, s2)) * x;

罗伯特。 2019年12月24日

好吧，我试了你的解决方案，但我不太明白。

你说这个

和这个是一样的:

我们来举个例子:

4隐藏神经元

二维输入

数据集中的5个例子

然后我们有这样的东西:

                                 deltaw = randi(10,4,5)
                                
                                 deltaIW =
                                
                                 3 3 9 1 3
                                
                                 8 8 4 5 4
                                
                                 4 7 9 7 4
                                
                                 7 2 4 9 3
                                
                                 X = randi(10,2,5)
                                
                                 x =
                                
                                 10 6 2 4 3
                                
                                 2 1 6 9 8
                                
                                 IWJ = nan(size(deltaw,1)，size(x,1)，size(x,2));
                                
                                 为I = 1:size(x,2)
                                
                                 IWJ(:，:，i) = deltaw (:，i).*x(:，i)';
                                
                                 结束
                                
                                 1 = size(IWJ,1);
                                
                                 s2 = size(IWJ,2);
                                
                                 6 = size(IWJ,3);
                                
                                 [J] = (IWJ,s1*s2, s1)
                                
                                 J =
                                
                                 30 18 18 4 9
                                
                                 80 48 8 20 12
                                
                                 40 42 18 28 12
                                
                                 70 12 8 36 9
                                
                                 6 3 54 9 24
                                
                                 16 8 24 45 32
                                
                                 8 7 54 63 32
                                
                                 14 2 24 81 24

但这个J绝对不同于:

                                 J2 = kron (x, deltaIW)
                                
                                 J2 =
                                
                                 30 30 90 10 30 18 18 54 6 18 6 6 18 18 2 6 12 12 36 4 12 9 9 27 3 9
                                
                                 80 80 40 50 40 48 48 24 30 24 16 16 16 8 10 8 32 32 16 16 16 16 24 24 12 15 12
                                
                                 40 70 90 70 40 24 42 54 42 24 8 14 18 14 8 16 28 36 28 16 12 21 27 21 12
                                
                                 70 20 40 90 30 42 12 24 54 18 14 4 8 18 6 28 8 16 36 12 21 6 12 27 9
                                
                                 6 6 18 2 6 3 3 9 1 3 18 18 54 6 18 27 27 81 9 27 24 24 72 8 24
                                
                                 16 16 8 10 8 8 8 45 4 48 48 24 30 24 72 72 36 45 36 64 64 32 40 32
                                
                                 8 14 18 14 8 4 7 7 7 4 24 42 54 42 24 24 36 63 81 63 36 32 56 72 56 32 32
                                
                                 14 4 8 18 6 72 4 9 3 42 12 24 54 18 63 18 36 81 27 56 16 32 72 24

J肯定包含在J2中，它可以从中提取出来，但是有很多不必要的计算来产生J2…计算完整的J2然后从中提取J更有效吗?

有没有办法执行某种“元素明智”的kron?我们只需要J2中的几列……

我从来没有解释过我实现的数学的细节，所以混乱是不可避免的，我很抱歉。

在这个简单的例子中，我们有4个神经元，输入x的维度是2，所以我们在输入权重矩阵中有4x2 = 8个权重。这就是一阶算法中只需要梯度的情况。

正如你正确提到的，这将导致梯度 D1

形状(8,1)因为我们在计算梯度

但不幸的是，这不是我们的情况。

我们需要计算近似的黑森线 H 地点:

要做到这一点，我们需要 J 在哪里 J 是:

有5列的矩阵(在我们的例子中)，其中第i列是基于x_i wrt权重和偏差计算的Net梯度。

这是无法避免的，因为我们需要 H 。

D1 等于 D2 但是我们需要雅可比矩阵 J 在任何情况下都可以计算 H 。

换句话说，我们不是在计算梯度 E 这是一个向量。我们在计算的梯度

对于数据集中的每个x_i，把这个梯度作为列 J。

可能“雅可比矩阵”并不准确，因为Net是一个标量函数。

在任何情况下，这里都很好地解释了数学:

Levenberg马夸特

辉煌!你的想法很有效，现在我们离火车的表现很近了。

我明天会做更多的检查，并告诉你最新的情况。

现在，谢谢你，圣诞快乐!

登录评论。

1评论
显示隐藏 None

不，我没有。这是个好主意，谢谢。

这将是我的下一个尝试，如果我不设法改善我的代码。

在这一点上，我很清楚，我的算法和trainlm做同样的事情。这两个算法的输出是相同的，直到10个有效数字或更多。我只是想知道为什么我的效率不高。我近了! !

0评论
显示隐藏-1旧评论

接受的答案

13个评论
显示隐藏 12旧评论

更多答案(2)

1评论
显示隐藏 None

0评论
显示隐藏-1旧评论

另请参阅

类别

标签

下载188bet金宝搏

释放

社区寻宝

Levenberg Marquardt实施问题

0评论 显示隐藏-1旧评论

接受的答案

13个评论 显示隐藏 12旧评论

更多答案(2)

1评论 显示隐藏 None

0评论 显示隐藏-1旧评论

另请参阅

类别

标签

下载188bet金宝搏

释放

社区寻宝

0评论
显示隐藏-1旧评论

13个评论
显示隐藏 12旧评论

1评论
显示隐藏 None

0评论
显示隐藏-1旧评论