LM拟合算法

一、  Levenberg-Marquardt算法

(1)y=a*e.^(-b*x)形式拟合

clear all
% 计算函数f的雅克比矩阵,是解析式
syms a b y x real;
f=a*exp(-b*x);
Jsym=jacobian(f,[a b]);
% 拟合用数据。参见《数学试验》,p190,例2
% data_1=[0.25 0.5 1 1.5 2 3 4 6 8];
% obs_1=[19.21 18.15 15.36 18.10 12.89 9.32 7.45 5.24 3.01];
load fla
% data_1=[0.25 0.5 1 1.5 2 3 4 6 8];
% obs_1=[19.21 18.15 15.36 18.10 12.89 9.32 7.45 5.24 3.01];
data_1=1:26;
obs_1=fla3_1;%y轴的值

% 2. LM算法
% 初始猜测s
a0=1e+09; b0=0;
y_init = a0*exp(-b0*data_1);
% 数据个数
Ndata=length(obs_1);
% 参数维数
Nparams=2;
% 迭代最大次数
n_iters=50;
% LM算法的阻尼系数初值
lamda=0.01;
% step1: 变量赋值
updateJ=1;
a_est=a0;
b_est=b0;
%% 
% step2: 迭代
for it=1:n_iters %迭代次数
   if updateJ==1
       % 根据当前估计值,计算雅克比矩阵
       J=zeros(Ndata,Nparams);%数据的维度,系数的维度
       for i=1:length(data_1)
           J(i,:)=[exp(-b_est*data_1(i)) -a_est*data_1(i)*exp(-b_est*data_1(i))];%雅克比矩阵的生成
                                                                                 % 对系数a和b求导
       end
       % 根据当前参数,得到函数值
       y_est = a_est*exp(-b_est*data_1);
       % 计算误差
       d=obs_1-y_est;
       % 计算(拟)海塞矩阵
       H=J'*J;
       % 若是第一次迭代,计算误差
       if it==1
           e=dot(d,d);%向量点乘
       end
   end
   % 根据阻尼系数lamda混合得到H矩阵
   H_lm=H+(lamda*eye(Nparams,Nparams)); % J'*J+lamda*I
   % 计算步长dp,并根据步长计算新的可能的参数估计值
   dp=inv(H_lm)*(J'*d(:)); %deltp=[J'*J+lamda*I]^(-1)*(J'*εk)矩阵求逆
   g = J'*d(:);
   a_lm=a_est+dp(1);
   b_lm=b_est+dp(2);
   % 计算新的可能估计值对应的y和计算残差e
   y_est_lm = a_lm*exp(-b_lm*data_1);
   d_lm=obs_1-y_est_lm;
   e_lm=dot(d_lm,d_lm);
   % 根据误差,决定如何更新参数和阻尼系数
   if e_lm<e
       lamda=lamda/10;
       a_est=a_lm;
       b_est=b_lm;
       e=e_lm;
       disp(e);
       updateJ=1;
   else
       updateJ=0;
       lamda=lamda*10;
   end
end
%% 
%显示优化的结果
a_est
b_est
%从图形上观察拟合程度
plot(data_1,obs_1,'*')
hold on
x=1:54;
y=a_est*exp(-b_est*x);
plot(x,y,'o-')

(2)y=a*x.^b+c形式

注意公式变化后,求导的变化 

clear all
% 计算函数f的雅克比矩阵,是解析式
syms a b c x ;
f=a*x.^b+c;
Jsym=jacobian(f,[a b c]);
% 拟合用数据。参见《数学试验》,p190,例2
% data_1=[0.25 0.5 1 1.5 2 3 4 6 8];
% obs_1=[19.21 18.15 15.36 18.10 12.89 9.32 7.45 5.24 3.01];
load fla
% data_1=[0.25 0.5 1 1.5 2 3 4 6 8];
% obs_1=[19.21 18.15 15.36 18.10 12.89 9.32 7.45 5.24 3.01];
data_1=1:length(fla3_1);
obs_1=fla3_1;%y轴的值

% 2. LM算法
% 初始猜测s
a0=1e+09; b0=0;c0=1.4e+09;
y_init = a0*data_1.^b0+c0;
% 数据个数
Ndata=length(obs_1);
% 参数维数
Nparams=3;
% 迭代最大次数
n_iters=50;
% LM算法的阻尼系数初值
lamda=0.01;
% step1: 变量赋值
updateJ=1;
a_est=a0;
b_est=b0;
c_est=c0;
%% 
% step2: 迭代
for it=1:n_iters %迭代次数
   if updateJ==1
       % 根据当前估计值,计算雅克比矩阵
       J=zeros(Ndata,Nparams);%数据的维度,系数的维度
       for i=1:length(data_1)
           J(i,:)=[data_1(i).^b_est a_est*log(data_1(i))*data_1(i).^b_est 0];%雅克比矩阵的生成
                                                                                 % 对系数a和b求导
       end
       % 根据当前参数,得到函数值
       y_est =a_est*data_1.^b_est+c_est ;
       % 计算误差
       d=obs_1-y_est;
       % 计算(拟)海塞矩阵
       H=J'*J;
       % 若是第一次迭代,计算误差
       if it==1
           e=dot(d,d);%向量点乘
       end
   end
   % 根据阻尼系数lamda混合得到H矩阵
   H_lm=H+(lamda*eye(Nparams,Nparams)); % J'*J+lamda*I
   % 计算步长dp,并根据步长计算新的可能的参数估计值
   dp=inv(H_lm)*(J'*d(:)); %deltp=[J'*J+lamda*I]^(-1)*(J'*εk)矩阵求逆
   g = J'*d(:);
   a_lm=a_est+dp(1);
   b_lm=b_est+dp(2);
   c_lm=c_est+dp(3);
   % 计算新的可能估计值对应的y和计算残差e
   y_est_lm = a_lm*data_1.^b_lm+c_lm;
   d_lm=obs_1-y_est_lm;
   e_lm=dot(d_lm,d_lm);
   % 根据误差,决定如何更新参数和阻尼系数
   if e_lm<e
       lamda=lamda/10;
       a_est=a_lm;
       b_est=b_lm;
       e=e_lm;
       disp(e);
       updateJ=1;
   else
       updateJ=0;
       lamda=lamda*10;
   end
end
%% 
%显示优化的结果
a_est
b_est
c_est
%从图形上观察拟合程度
plot(data_1,obs_1,'*')
hold on
x=1:length(data_1);
y=a_est*data_1.^b_est+c_est;
plot(x,y,'o-')

 

拟合不是很好

更改初始参数c0=1.42e+09后,变为如下图,拟合效果好很多,所以参数调整很重要。

LM函数

function [a_est,b_est,c_est]=LM(data)
    data_1=1:length(data);
    obs_1=data;%y轴的值

    % 2. LM算法
    % 初始猜测s
    a0=1; b0=0;c0=1.42e+09;
    y_init = a0*data_1.^b0+c0;
    % 数据个数
    Ndata=length(obs_1);
    % 参数维数
    Nparams=3;
    % 迭代最大次数
    n_iters=500;
    % LM算法的阻尼系数初值
    lamda=0.01;
    % step1: 变量赋值
    updateJ=1;
    a_est=a0;
    b_est=b0;
    c_est=c0;
    %% 
    % step2: 迭代
    for it=1:n_iters %迭代次数
       if updateJ==1
           % 根据当前估计值,计算雅克比矩阵
           J=zeros(Ndata,Nparams);%数据的维度,系数的维度
           for i=1:length(data_1)
               J(i,:)=[data_1(i).^b_est a_est*log(data_1(i))*data_1(i).^b_est 0];%雅克比矩阵的生成
                                                                                     % 对系数a和b求导
           end
           % 根据当前参数,得到函数值
           y_est =a_est*data_1.^b_est+c_est ;
           % 计算误差
           d=obs_1-y_est;
           % 计算(拟)海塞矩阵
           H=J'*J;
           % 若是第一次迭代,计算误差
           if it==1
               e=dot(d,d);%向量点乘
           end
       end
       % 根据阻尼系数lamda混合得到H矩阵
       H_lm=H+(lamda*eye(Nparams,Nparams)); % J'*J+lamda*I
       % 计算步长dp,并根据步长计算新的可能的参数估计值
       dp=inv(H_lm)*(J'*d(:)); %deltp=[J'*J+lamda*I]^(-1)*(J'*εk)矩阵求逆
       g = J'*d(:);
       a_lm=a_est+dp(1);
       b_lm=b_est+dp(2);
       c_lm=c_est+dp(3);
       % 计算新的可能估计值对应的y和计算残差e
       y_est_lm = a_lm*data_1.^b_lm+c_lm;
       d_lm=obs_1-y_est_lm;
       e_lm=dot(d_lm,d_lm);
       % 根据误差,决定如何更新参数和阻尼系数
       if e_lm<e
           lamda=lamda/10;
           a_est=a_lm;
           b_est=b_lm;
           e=e_lm;
           disp(e);
           updateJ=1;
       else
           updateJ=0;
           lamda=lamda*10;
       end
    end

 

 

 二、nlinfit拟合

clear;clc
x=[36 39 45 48 53 61 73 97 108 121 140 152];
y=[10000 7000 6500 5500 4500 3500 2000 300 750 1000 250 100];
a0=[0 0 0];
a=nlinfit(x,y,'gx',a0);
s=30:0.01:160;
plot(x,y,'*',x,gx(a,x),'--r')
a=vpa(a,5)

function q=gx(a,x)
q=a(1)*x.^a(2)+a(3);
end

 

 三、最小二乘法

%最小二乘法
function [a,b]=Least_sqr(data)%%
    x=1:length(data);
    y=data;
    s_xy=sum(x.*y);
    s_xx=sum(x.*x);
    s_sxy=sum(x)*sum(y)/length(x);
    s_sx=sum(x).*sum(x)/length(x);
    ave_x=sum(x)/length(x);
    ave_y=sum(y)/length(y);
    a=(s_xy-s_sxy)/(s_xx-s_sx);
    b=ave_y-a*ave_x;
end

 

 四、对LM算法的介绍

LM算法的实现并不算难,它的关键是用模型函数 f 对待估参数向量p在其邻域内做线性近似,忽略掉二阶以上的导数项,从而转化为线性最小二乘问题,它具有收敛速度快等优点。LM算法属于一种“信赖域法”——所谓的信赖域法,此处稍微解释一下:在最优化算法中,都是要求一个函数的极小值,每一步迭代中,都要求目标函数值是下降的,而信赖域法,顾名思义,就是从初始点开始,先假设一个可以信赖的最大位移s,然后在以当前点为中心,以s为半径的区域内,通过寻找目标函数的一个近似函数(二次的)的最优点,来求解得到真正的位移。在得到了位移之后,再计算目标函数值,如果其使目标函数值的下降满足了一定条件,那么就说明这个位移是可靠的,则继续按此规则迭代计算下去;如果其不能使目标函数值的下降满足一定的条件,则应减小信赖域的范围,再重新求解。

事实上,你从所有可以找到的资料里看到的LM算法的说明,都可以找到类似于“如果目标函数值增大,则调整某系数再继续求解;如果目标函数值减小,则调整某系数再继续求解”的迭代过程,这种过程与上面所说的信赖域法是非常相似的,所以说LM算法是一种信赖域法。

 

LM算法需要对每一个待估参数求偏导,所以,如果你的目标函数f非常复杂,或者待估参数相当地多,那么可能不适合使用LM算法,而可以选择Powell算法——Powell算法不需要求导。

 

至于这个求导过程是如何实现的,我还不能给出建议,我使用过的方法是拿到函数的方程,然后手工计算出其偏导数方程,进而在函数中直接使用,这样做是最直接,求导误差也最小的方式。不过,在你不知道函数的形式之前,你当然就不能这样做了——例如,你提供给了用户在界面上输入数学函数式的机会,然后在程序中解析其输入的函数,再做后面的处理。在这种情况下,我猜是需要使用数值求导算法的,但我没有亲自试验过这样做的效率,因为一些优秀的求导算法——例如Ridders算法——在一次求导数值过程中,需要计算的函数值次数也会达到5次以上。这样的话,它当然要比手工求出导函数(只需计算一次,就可以得到导数值)效率要差得多了。不过,我个人估计(没有任何依据的,只是猜的):依赖于LM算法的高效,就算添加了一个数值求导的“拖油瓶”,整个最优化过程下来,它仍然会优于Powell等方法。

关于偏导数的求取

个人认为:在条件允许、对速度和精度任何以方面都有一定要求的前提下,如果待求解的函数形式是显式的,应当尽量自己计算目标函数的偏导数方程。原因在于,在使用数值法估计偏导数值时,尽管我们可以控制每一步偏导数值的精度,但是由于求解过程需要进行多次迭代,特别是收敛过程比较慢的求解过程,需要进行很多次的求解,每一次求解的误差偏差都会在上一步偏差的基础上不断累积。尽管在最后依然可以收敛,但是得到的解已经离可以接受的解偏离比较远了。因此,在求解函数形式比较简单、偏导数函数比较容易求取时,还是尽量手动计算偏导数,得到的结果误差相对更小一些。

 

这篇解释信赖域算法的文章中,我们已经知道了LM算法的数学模型:

可以证明,此模型可以通过解方程组(Gk+μI)s=−gk确定sk来表征。
即:LM算法要确定一个μ≥0,使得Gk+μI正定,并解线性方程组(Gk+μI)sk=−gk求出sk。
下面来看看LM算法的基本步骤:

·从初始点x0,μ0>0开始迭代

·到第k步时,计算xk和μk

·分解矩阵Gk+μkI,若不正定,令μk=4μk并重复到正定为止

·解线性方程组(Gk+μkI)sk=−gk求出sk并计算rk

·若rk<0.25,令μk+1=4μk;若rk>0.75,令μk+1=μk2;若0.25≤rk≤0.75,令μk+1=μk

·若rk≤0,说明函数值是向着上升而非下降的趋势变化了(与最优化的目标相反),这说明这一步走错了,而且错得“离谱”,此时,不应该走到下一点,而应“原地踏步”,即xk+1=xk,并且和上面rk<0.25的情况一样对μk进行处理。反之,在rk>0的情况下,都可以走到下一点,即xk+1=xk+sk

·        迭代的终止条件:∥gk∥<ε,其中ε是一个指定的小正数(大家可以想像一下二维平面上的寻优过程(函数图像类似于抛物线),当接近极小值点时,迭代点的梯度趋于0)

从上面的步骤可见,LM求解过程中需要用到求解线性方程组的算法,一般我们使用高斯约当消元法,因为它非常稳定——虽然它不是最快最好的算法。
同时,上面的算法步骤也包含对矩阵进行分解的子步骤。为什么要先分解矩阵,再解线性方程组?貌似是这样的(数学不好的人再次泪奔):不分解矩阵使之正定,就无法确定那个线性方程组是有解的。矩阵分解有很多算法,例如LU分解等,这方面我没有看。

https://www.cnblogs.com/shhu1993/p/4878992.html 

三,程序实现

推导过程的博客 https://www.cnblogs.com/monoSLAM/p/5249339.html

clear all
% 计算函数f的雅克比矩阵,是解析式
syms a b c x ;
f=a*x.^b+c;%函数形式
Jsym=jacobian(f,[a b c]);
data=[1425204748.0, 1425204757.0, 1425204759.0, 1425204766.0,...
       1425204768.0, 1425206629.0, 1425209138.0, 1425209139.0,...
       1425209159.0, 1425209167.0, 1425219290.0, 1425219298.0,...
       1425219307.0, 1425219307.0, 1425219381.0, 1425219382.0,...
       1425219390.0,1425223403.0, 1425223411.0, 1425223420.0,...
       1425225096.0, 1425479571.0, 1425479580.0, 1427109036.0,...
       1427109038.0, 1427115143.0, 1427449736.0, 1427449755.0,...
       1427449763.0, 1427449774.0, 1427449775.0, 1427717884.0];
data_1=1:length(data);
obs_1=data;%y轴的值

% 2. LM算法
% 初始猜测s
a0=1; b0=0;c0=data(1);  %设置初始值
y_init = a0*data_1.^b0+c0;
% 数据个数
Ndata=length(obs_1);
% 参数维数
Nparams=3;
% 迭代最大次数
n_iters=200;
% LM算法的阻尼系数初值
lamda=0.01;
% step1: 变量赋值
updateJ=1
a_est=a0;
b_est=b0;
c_est=c0;
%% 
% step2: 迭代
for it=1:n_iters %迭代次数
    if updateJ==1
       % 根据当前估计值,计算雅克比矩阵
       J=zeros(Ndata,Nparams);%数据的维度,系数的维度
       for i=1:length(data_1)
           J(i,:)=[data_1(i).^b_est a_est*log(data_1(i))*data_1(i).^b_est 0];%雅克比矩阵的生成,32*3矩阵
                                                                                 % 对系数a、b、c求导
       end
       % 根据当前参数,得到函数值
       y_est =a_est*data_1.^b_est+c_est ;%32个预测值
       % 计算误差
       d=obs_1-y_est;
       % 计算(拟)海塞矩阵,是一个多元函数的二阶偏导数构成的方阵,描述了函数的局部曲率,对称矩阵
       H=J'*J;
       % 若是第一次迭代,计算误差
       if it==1
           e=dot(d,d);%向量点乘
       end
    end
    
   % 根据阻尼系数lamda混合得到H矩阵
   H_lm=H+(lamda*eye(Nparams,Nparams)); % J'*J+lamda*I
   % 计算步长dp,并根据步长计算新的可能的参数估计值
   dp=inv(H_lm)*(J'*d'); %deltp=[J'*J+lamda*I]^(-1)*(J'*εk)矩阵求逆
   g = J'*d(:);
   
   a_lm=a_est+dp(1);%新的系数值
   b_lm=b_est+dp(2);
   c_lm=c_est+dp(3);
   
   % 计算新的可能估计值对应的y和计算残差e
   y_est_lm = a_lm*data_1.^b_lm+c_lm;
   d_lm=obs_1-y_est_lm;
   e_lm=dot(d_lm,d_lm);
   
   % 根据误差,决定如何更新参数和阻尼系数
   if e_lm<e  %误差变小
       lamda=lamda/10;
       a_est=a_lm;
       b_est=b_lm;
       c_est=c_lm;
       e=e_lm;
       disp(e);
       updateJ=1;
   else
       updateJ=0;
       lamda=lamda*10;
   end
end
%% 
%显示优化的结果
a_est
b_est
c_est
%从图形上观察拟合程度
plot(data_1,obs_1,'*')
hold on
x=1:length(data);
y=a_est*data_1.^b_est+c_est;
plot(x,y,'o-')

 

  

posted on 2018-03-21 19:44  箬笠蓑衣  阅读(7398)  评论(0编辑  收藏  举报