精华内容
下载资源
问答
  • 动量梯度下降算法训练BP网络 使用的主要函数如下: NEWFF——生成一个新的前向神经网络 TRAIN——对BP神经网络进行训练 SIM——对BP神经网络进行仿真
  • 梯度下降、随机梯度下降、小批量梯度下降、动量梯度下降、Nesterov加速梯度下降前言梯度下降(Gradient Descent / GD)单变量线性回归模型(Univariate Linear Regression)批梯度下降(Batch Gradient ...

    前言

    本文通过使用单变量线性回归模型讲解一些常见的梯度下降算法。为了更好的作对比,我们对参数设置了不同的学习率

    梯度下降法(GD / Gradient Descent)

    梯度下降法(Gradient Descent)是一种常见的、用于寻找函数极小值的一阶迭代优化算法,又称为最速下降(Steepest Descent),它是求解无约束最优化问题的一种常用方法。以下是梯度下降的基本公式:

    θ : = θ − ∂ J ( θ ) ∂ θ \theta := \theta - \frac{\partial J(\theta)}{\partial \theta} θ:=θθJ(θ)
    其中 J ( θ ) J(\theta) J(θ) 是关于参数 θ \theta θ 的损失函数, η \eta η学习率(正标量),也称为梯度下降的步长。由上述公式可知,梯度下降的想法是使得参数 θ \theta θ 向着负梯度方向做更新迭代。

    下面通过一个简单的例子来直观了解梯度下降的过程。假设 J ( θ ) J(\theta) J(θ) 为关于 θ \theta θ 的一元二次函数,即 J ( θ ) = θ 2 J(\theta) = \theta^2 J(θ)=θ2。假设初始值为 ( θ , J ( θ ) ) = ( 9 , 81 ) (\theta, J(\theta)) = (9,81) (θ,J(θ))=(9,81) η = 0.2 。 \eta = 0.2。 η=0.2对于第一次迭代,求取梯度为: ∂ J ( θ ) ∂ θ = 2 θ = 18 \frac{\partial J(\theta)}{\partial \theta} = 2\theta = 18 θJ(θ)=2θ=18,更新 θ : = θ − ∂ J ( θ ) ∂ θ = 9 − 0.2 ∗ 18 = 5.4 \theta := \theta - \frac{\partial J(\theta)}{\partial \theta} = 9 - 0.2*18 = 5.4 θ:=θθJ(θ)=90.218=5.4。继续重复迭代步骤,最后函数将会趋于极值点 x = 0 x = 0 x=0

    如下图所示,我们可以发现,随着梯度的不断减小,函数收敛越来越慢:

    在这里插入图片描述

    下面是该程序的matlab代码:

    % writen by: Weichen Gu,   date: 4/18th/2020 
    clc; clf; clear;
    xdata = linspace(-10,10,1000);                   % x range
    f = @(xdata)(xdata.^2);                         % Quadratic function - loss function
    
    ydata = f(xdata);
    plot(xdata,ydata,'c','linewidth',2);
    title('y = x^2 (learning rate = 0.2)');
    hold on;
    
    x = [9 f(9)];            % Initial point
    slope = inf;               % Slope
    LRate = 0.2;               % Learning rate
    slopeThresh = 0.0001;      % Slope threshold for iteration
    
    plot(x(1),x(2),'r*');
    
    while abs(slope) > slopeThresh
        [tmp,slope] = gradientDescent(x(1),f,LRate);
        x1 = [tmp f(tmp)];
        line([x(1),x1(1)],[x(2),x1(2)],'color','k','linestyle','--','linewidth',1);
        plot(x1(1),x1(2),'r*');
        legend('y = x^2');
        drawnow;
        x = x1;
    end
    hold off
    
    function [xOut,slope] = gradientDescent(xIn,f, eta)
        syms x;
        slope = double(subs(diff(f(x)),xIn));
        xOut = xIn- eta*(slope);
    end

    学习率决定了梯度下降的收敛速度,合适的学习率会使收敛速度得到一定的提高。我们应该避免过小或者过大的学习率:

    • 学习率过小会导致函数收敛速度非常慢,所需迭代次数多,难以收敛。
    • 学习率过大会导致梯度下降过程中出现震荡、不收敛甚至发散的情况。

    如下图所示:

    在这里插入图片描述
    对于学习率,一开始可以设置较大的步长,然后再慢慢减小步长来调整收敛速度,但是实际过程中,设置最优的学习率一般来说是比较困难的。

    同时我们应该知道,梯度下降是一种寻找函数极小值的方法,如下图,不同的初始点可能会获得不同的极小值:

    在这里插入图片描述

    单变量线性回归模型(Univariate Linear Regression)

    下面我们通过使用吴恩达老师课程中的单变量线性回归(Univariate Linear Regression)模型来讲解几种梯度下降策略。如下公式:
    h θ ( x ) = θ 0 x + θ 1 h_{\theta}(x) = \theta_0 x+\theta_1 hθ(x)=θ0x+θ1

    它是一种简单的线性拟合模型,并且目标函数为凸函数(根据一阶导二阶导性质),所以对于梯度下降求得的极小值就是损失函数的最优解。下列公式为单变量线性回归模型的损失函数/目标函数
    J ( θ 0 , θ 1 ) = 1 2 m ∑ i = 1 m ( h θ ( x i ) − y i ) 2 J(\theta_0,\theta_1) = \frac{1}{2m}\sum_{i = 1}^m(h_{\theta}(x^i)-y^i)^2 J(θ0,θ1)=2m1i=1m(hθ(xi)yi)2
    其中 h θ ( x ( i ) ) h_\theta(x^{(i)}) hθ(x(i))是通过回归模型预测的输出。 m m m为样本个数。
    我们的目标是求出使得目标函数最小的参数值
    ( θ ^ 0 , θ ^ 1 ) = arg min ⁡ θ 0 , θ 1 J ( θ 0 , θ 1 ) (\hat\theta_0,\hat\theta_1) = \argmin_{\theta_0,\theta_1}J(\theta_0,\theta_1) (θ^0,θ^1)=θ0,θ1argminJ(θ0,θ1)

    对损失函数进行梯度求解,可得到:

    ∂ J ( θ 0 , θ 1 ) ∂ θ 0 = 1 m ∑ i = 1 m ( θ 0 + θ 1 x i − y i ) \frac{\partial J(\theta_0,\theta_1)}{\partial \theta_0} = \frac{1}{m}\sum_{i = 1}^m(\theta_0+\theta_1x^i -y^i) θ0J(θ0,θ1)=m1i=1m(θ0+θ1xiyi) ∂ J ( θ 0 , θ 1 ) ∂ θ 1 = 1 m ∑ i = 1 m ( θ 0 + θ 1 x i − y i ) x i \frac{\partial J(\theta_0,\theta_1)}{\partial \theta_1} = \frac{1}{m}\sum_{i = 1}^m(\theta_0+\theta_1x^i -y^i)x^i θ1J(θ0,θ1)=m1i=1m(θ0+θ1xiyi)xi

    批梯度下降法(Batch GD / Batch Gradient Descent)

    批梯度下降法根据整个数据集求取损失函数的梯度,来更新参数 θ \theta θ的值。公式如下:
    θ : = θ − η ⋅ 1 m ∑ i = 1 m ∂ J ( θ , x i , y i ) ∂ θ \theta := \theta - \eta\cdot\frac{1}{m}\sum_{i=1}^m\frac{\partial J(\theta,x^i,y^i)}{\partial \theta} θ:=θηm1i=1mθJ(θ,xi,yi)
    优点:考虑到了全局数据,更新稳定,震荡小,每次更新都会朝着正确的方向。
    缺点:如果数据集比较大,会造成大量时间和空间开销

    下图显示了通过批梯度下降进行拟合的结果。根据图像可看到,我们的线性回归模型逐渐拟合到了一个不错的结果。
    在这里插入图片描述

    下面给出matlab的代码:

    % Writen by weichen GU, data 4/19th/2020
    clear, clf, clc; 
    
    data = linspace(-20,20,100);                    % x range
    col = length(data);                             % Obtain the number of x
    data = [data;0.5*data + wgn(1,100,1).*2+10];    % Generate dataset - y = 0.5 * x + wgn^2 + 10;
    X = [ones(1, col); data(1,:)]';                 % X ->[1;X];
    
    plot(data(1,:),data(2,:),'r.','MarkerSize',10); % Plot data
    title('Data fiting using Univariate Linear Regression');
    axis([-30,30,-10,30])
    hold on;
    
    theta =[0;0];           % Initialize parameters
    LRate = [0.1; 0.002]; % Learning rate
    thresh = 0.5;           % Threshold of loss for jumping iteration
    iteration = 40;        % The number of teration
    
    lineX = linspace(-30,30,100);
    [row, col] = size(data)                     % Obtain the size of dataset
    lineMy = [lineX;theta(1)*lineX+theta(2)];   % Fitting line
    hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2);  % draw fitting line
    
    for iter = 1 : iteration
        delete(hLine)       % set(hLine,'visible','off')
        
        [thetaOut] = GD(X,data(2,:)',theta,LRate); % Gradient Descent algorithm
        theta = thetaOut;   % Update parameters(theta)
        
        loss = getLoss(X,data(2,:)',col,theta); % Obtain the loss 
        lineMy(2,:) = theta(2)*lineX+theta(1); % Fitting line
        hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2); % draw fitting line
        
        drawnow()
        
        if(loss < thresh)
            break;
        end
    end
    
    hold off
    
    
    function [thetaOut] = GD(X,Y,theta,LRate)
        dataSize = length(X);               % Obtain the number of data 
        dx = 1/dataSize*(X'*(X*theta-Y));   % Obtain the gradient
        thetaOut = theta -LRate.*dx;         % gradient descent method
    end
    
    
    function [Z] = getLoss(X,Y, num,theta)
        Z= 1/(2*num)*sum((X*theta-Y).^2);
    end
    

    我们希望可以直观的看到批梯度下降的过程,以便和后续的一些梯度下降算法作比较,于是我们将其三维可视化出来,画出其拟合图(1)、三维损失图(2)、等高线图(3)以及迭代损失图(4)

    在这里插入图片描述

    根据上图可以看到,批梯度下降收敛稳定,震荡小。

    这里给出具体matlab实现代码:

    % Writen by weichen GU, data 4/19th/2020
    clear, clf, clc;
    data = linspace(-20,20,100);                    % x range
    col = length(data);                             % Obtain the number of x
    data = [data;0.5*data + wgn(1,100,1)+10];       % Generate dataset - y = 0.5 * x + wgn^2 + 10;
    X = [ones(1, col); data(1,:)]';                 % X ->[1;X];
    
    t1=-40:0.1:50;
    t2=-4:0.1:4;
    [meshX,meshY]=meshgrid(t1,t2);
    meshZ = getTotalCost(X, data(2,:)', col, meshX,meshY);
    
    theta =[-30;-4];        % Initialize parameters
    LRate = [0.1; 0.002];   % Learning rate
    thresh = 0.5;           % Threshold of loss for jumping iteration
    iteration = 50;         % The number of teration
    
    lineX = linspace(-30,30,100);
    [row, col] = size(data)                                     % Obtain the size of dataset
    lineMy = [lineX;theta(1)*lineX+theta(2)];                   % Fitting line
    hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2);    % draw fitting line
    
    loss = getLoss(X,data(2,:)',col,theta);                     % Obtain current loss value
    
    subplot(2,2,1);
    plot(data(1,:),data(2,:),'r.','MarkerSize',10);
    title('Data fiting using Univariate LR');
    axis([-30,30,-10,30])
    xlabel('x');
    ylabel('y');
    hold on;
    
    % Draw 3d loss surfaces
    subplot(2,2,2)
    mesh(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('3D surfaces for loss')
    hold on;
    scatter3(theta(1),theta(2),loss,'r*');
    
    % Draw loss contour figure
    subplot(2,2,3)
    contour(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('Contour figure for loss')
    hold on;
    plot(theta(1),theta(2),'r*')
    
    % Draw loss with iteration
    subplot(2,2,4)
    hold on;
    title('Loss when using Batch GD');
    xlabel('iter');
    ylabel('loss');
    plot(0,loss,'b*');
    
    set(gca,'XLim',[0 iteration]);
    %set(gca,'YLim',[0 4000]);
    hold on;
    
    for iter = 1 : iteration
        delete(hLine) % set(hLine,'visible','off')
        
        [thetaOut] = GD(X,data(2,:)',theta,LRate); % Gradient Descent algorithm
        subplot(2,2,3);
        line([theta(1),thetaOut(1)],[theta(2),thetaOut(2)],'color','k')
    
        theta = thetaOut;
        loss = getLoss(X,data(2,:)',col,theta); % Obtain losw
        
        
        lineMy(2,:) = theta(2)*lineX+theta(1); % Fitting line
        subplot(2,2,1);
        hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2); % draw fitting line
        %legend('training data','linear regression');
        
        subplot(2,2,2);
        scatter3(theta(1),theta(2),loss,'r*');
        
        subplot(2,2,3);
        plot(theta(1),theta(2),'r*')
        
        subplot(2,2,4)
        plot(iter,loss,'b*');
        
        drawnow();
        
        if(loss < thresh)
            break;
        end
    end
    
    hold off
    
    
    function [Z] = getTotalCost(X,Y, num,meshX,meshY);
        [row,col] = size(meshX);
        Z = zeros(row, col);
        for i = 1 : row
            theta = [meshX(i,:); meshY(i,:)];
            Z(i,:) =  1/(2*num)*sum((X*theta-repmat(Y,1,col)).^2);   
        end
    
    end
    
    function [Z] = getLoss(X,Y, num,theta)
        Z= 1/(2*num)*sum((X*theta-Y).^2);
    end
    
    function [thetaOut] = GD(X,Y,theta,eta)
        dataSize = length(X);                       % Obtain the number of data
        dx = 1/dataSize.*(X'*(X*theta-Y));          % Obtain the gradient of Loss function
        thetaOut = theta -eta.*dx;                  % Update parameters(theta)
    end
    

    随机梯度下降法(SGD / Stochastic Gradient Descent)

    因为批梯度下降所需要的时间空间成本大,我们考虑随机抽取一个样本来获取梯度,更新参数 θ \theta θ。其公式如下:
    θ : = θ − η ⋅ ∂ J ( θ , x i , y i ) ∂ θ \theta := \theta - \eta\cdot\frac{\partial J(\theta,x^i,y^i)}{\partial \theta} θ:=θηθJ(θ,xi,yi)步骤如下:

    1. 随机打乱数据集。
    2. 对于每个样本点,依次迭代更新参数 θ \theta θ
    3. 重复以上步骤直至损失足够小或到达迭代阈值

    优点:训练速度快,每次迭代只需要一个样本,相对于批梯度下降,总时间、空间开销小。
    缺点:噪声大导致高方差。导致每次迭代并不一定朝着最优解收敛,震荡大。

    下图直观显示了随机梯度下降的迭代过程:
    在这里插入图片描述

    下面给出随机梯度下降的matlab代码,因为它是小批量梯度下降的特殊情况(batchSize = 1),所以我将小批量梯度下降的代码放在本章节,并设置batchSize = 1。

    % Writen by weichen GU, data 4/19th/2020
    clear, clf, clc;
    data = linspace(-20,20,100);                    % x range
    col = length(data);                             % Obtain the number of x
    data = [data;0.5*data + wgn(1,100,1)+10];       % Generate dataset - y = 0.5 * x + wgn^2 + 10;
    X = [ones(1, col); data(1,:)]';                 % X ->[1;X];
    
    t1=-40:0.1:50;
    t2=-4:0.1:4;
    [meshX,meshY]=meshgrid(t1,t2);
    meshZ = getTotalCost(X, data(2,:)', col, meshX,meshY);
    
    theta =[-30;-4];        % Initialize parameters
    LRate = [0.1; 0.002]  % Learning rate
    thresh = 0.5;           % Threshold of loss for jumping iteration
    iteration = 100;        % The number of teration
    
    lineX = linspace(-30,30,100);
    [row, col] = size(data)                                     % Obtain the size of dataset
    lineMy = [lineX;theta(1)*lineX+theta(2)];                   % Fitting line
    hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2);    % draw fitting line
    
    loss = getLoss(X,data(2,:)',col,theta);                     % Obtain current loss value
    
    subplot(2,2,1);
    plot(data(1,:),data(2,:),'r.','MarkerSize',10);
    title('Data fiting using Univariate LR');
    axis([-30,30,-10,30])
    xlabel('x');
    ylabel('y');
    hold on;
    
    % Draw 3d loss surfaces
    subplot(2,2,2)
    mesh(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('3D surfaces for loss')
    hold on;
    scatter3(theta(1),theta(2),loss,'r*');
    
    % Draw loss contour figure
    subplot(2,2,3)
    contour(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('Contour figure for loss')
    hold on;
    plot(theta(1),theta(2),'r*')
    
    % Draw loss with iteration
    subplot(2,2,4)
    hold on;
    title('Loss when using SGD');
    xlabel('iter');
    ylabel('loss');
    plot(0,loss,'b*');
    
    set(gca,'XLim',[0 iteration]);
    hold on;
    
    batchSize = 1;
    for iter = 1 : iteration
        delete(hLine) % set(hLine,'visible','off')
    
        
        %[thetaOut] = GD(X,data(2,:)',theta,LRate); % Gradient Descent algorithm
        [thetaOut] = MBGD(X,data(2,:)',theta,LRate,batchSize);
        subplot(2,2,3);
        line([theta(1),thetaOut(1)],[theta(2),thetaOut(2)],'color','k')
    
        theta = thetaOut;
        loss = getLoss(X,data(2,:)',col,theta); % Obtain losw
        
        
        lineMy(2,:) = theta(2)*lineX+theta(1); % Fitting line
        subplot(2,2,1);
        hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2); % draw fitting line
        %legend('training data','linear regression');
        
        subplot(2,2,2);
        scatter3(theta(1),theta(2),loss,'r*');
        
        subplot(2,2,3);
        plot(theta(1),theta(2),'r*')
        
        
        subplot(2,2,4)
        plot(iter,loss,'b*');
        
        drawnow();
        
        if(loss < thresh)
            break;
        end
    end
    
    hold off
    
    
    function [Z] = getTotalCost(X,Y, num,meshX,meshY);
        [row,col] = size(meshX);
        Z = zeros(row, col);
        for i = 1 : row
            theta = [meshX(i,:); meshY(i,:)];
            Z(i,:) =  1/(2*num)*sum((X*theta-repmat(Y,1,col)).^2);   
        end
    
    end
    
    
    function [Z] = getLoss(X,Y, num,theta)
        Z= 1/(2*num)*sum((X*theta-Y).^2);
    end
    
    function [thetaOut] = GD(X,Y,theta,eta)
        dataSize = length(X);                       % Obtain the number of data
        dx = 1/dataSize.*(X'*(X*theta-Y));          % Obtain the gradient of Loss function
        thetaOut = theta -eta.*dx;                  % Update parameters(theta)
    end
    
    % @ Depscription: 
    %       Mini-batch Gradient Descent (MBGD)
    %       Stochastic Gradient Descent(batchSize = 1) (SGD)
    % @ param:
    %       X - [1 X_] X_ is actual X; Y - actual Y
    %       theta - theta for univariate linear regression y_pred = theta_0 + theta1*x
    %       eta - learning rate;
    %
    function [thetaOut] = MBGD(X,Y,theta, eta,batchSize) 
        dataSize = length(X);           % obtain the number of data 
        k = fix(dataSize/batchSize);    % obtain the number of batch which has absolutely same size: k = batchNum-1;    
        batchIdx = randperm(dataSize);  % randomly sort for every epoch for achiving sample diversity
        
        batchIdx1 = reshape(batchIdx(1:k*batchSize),k,batchSize);   % batches which has absolutely same size
        batchIdx2 = batchIdx(k*batchSize+1:end);                    % ramained batch
        
        for i = 1 : k
            thetaOut = GD(X(batchIdx1(i,:),:),Y(batchIdx1(i,:)),theta,eta);
        end
        if(~isempty(batchIdx2))
            thetaOut = GD(X(batchIdx2,:),Y(batchIdx2),thetaOut,eta);
        end
    end
    

    小批量梯度下降(Mini Batch GD / Mini-batch Gradient Descent)

    随机梯度下降收敛速度快,但是波动较大,在最优解处出现波动很难判断其是否收敛到一个合理的值。而批梯度下降稳定但是时空开销很大,针对于这种情况,我们引入小批量梯度下降对二者进行折衷,在每轮迭代过程中使用n个样本来训练参数:
    θ : = θ − η ⋅ 1 n ∑ i = 1 n ∂ J ( θ , x i , y i ) ∂ θ \theta := \theta - \eta\cdot\frac{1}{n}\sum_{i=1}^n\frac{\partial J(\theta,x^i,y^i)}{\partial \theta} θ:=θηn1i=1nθJ(θ,xi,yi)步骤如下:

    1. 随机打乱数据集。
    2. 将数据集分为 m n \frac{m}{n} nm个集合,如果有余,将剩余样本单独作为一个集合。
    3. 依次对于这些集合做批梯度下降,更新参数 θ \theta θ
    4. 重复上述步骤,直至损失足够小或达到迭代阈值

    下图显示了小批量梯度下降的迭代过程,其中batchSize = 32。我们可以看到,小批量折衷了批梯度下降和随机梯度下降的特点,做到了相对来说收敛快、较稳定的结果。

    在这里插入图片描述

    这里附上小批量梯度下降的相关代码:

    % Writen by weichen GU, data 4/19th/2020
    clear, clf, clc;
    data = linspace(-20,20,100);                    % x range
    col = length(data);                             % Obtain the number of x
    data = [data;0.5*data + wgn(1,100,1)+10];       % Generate dataset - y = 0.5 * x + wgn^2 + 10;
    X = [ones(1, col); data(1,:)]';                 % X ->[1;X];
    
    t1=-40:0.1:50;
    t2=-4:0.1:4;
    [meshX,meshY]=meshgrid(t1,t2);
    meshZ = getTotalCost(X, data(2,:)', col, meshX,meshY);
    
    theta =[-30;-4];        % Initialize parameters
    LRate = [0.1; 0.002]  % Learning rate
    thresh = 0.5;           % Threshold of loss for jumping iteration
    iteration = 50;        % The number of teration
    
    lineX = linspace(-30,30,100);
    [row, col] = size(data)                                     % Obtain the size of dataset
    lineMy = [lineX;theta(1)*lineX+theta(2)];                   % Fitting line
    hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2);    % draw fitting line
    
    loss = getLoss(X,data(2,:)',col,theta);                     % Obtain current loss value
    
    subplot(2,2,1);
    plot(data(1,:),data(2,:),'r.','MarkerSize',10);
    title('Data fiting using Univariate LR');
    axis([-30,30,-10,30])
    xlabel('x');
    ylabel('y');
    hold on;
    
    % Draw 3d loss surfaces
    subplot(2,2,2)
    mesh(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('3D surfaces for loss')
    hold on;
    scatter3(theta(1),theta(2),loss,'r*');
    
    % Draw loss contour figure
    subplot(2,2,3)
    contour(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('Contour figure for loss')
    hold on;
    plot(theta(1),theta(2),'r*')
    
    % Draw loss with iteration
    subplot(2,2,4)
    hold on;
    title('Loss when using Mini-Batch GD');
    xlabel('iter');
    ylabel('loss');
    plot(0,loss,'b*');
    
    set(gca,'XLim',[0 iteration]);
    %set(gca,'YLim',[0 4000]);
    hold on;
    
    batchSize = 32;
    for iter = 1 : iteration
        delete(hLine) % set(hLine,'visible','off')
    
        
        %[thetaOut] = GD(X,data(2,:)',theta,LRate); % Gradient Descent algorithm
        [thetaOut] = MBGD(X,data(2,:)',theta,LRate,batchSize);
        subplot(2,2,3);
        line([theta(1),thetaOut(1)],[theta(2),thetaOut(2)],'color','k')
    
        theta = thetaOut;
        loss = getLoss(X,data(2,:)',col,theta); % Obtain losw
        
        
        lineMy(2,:) = theta(2)*lineX+theta(1); % Fitting line
        subplot(2,2,1);
        hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2); % draw fitting line
        %legend('training data','linear regression');
        
        subplot(2,2,2);
        scatter3(theta(1),theta(2),loss,'r*');
        
        subplot(2,2,3);
        plot(theta(1),theta(2),'r*')
        
        
        subplot(2,2,4)
        plot(iter,loss,'b*');
        
        drawnow();
        
        if(loss < thresh)
            break;
        end
    end
    
    hold off
    
    
    function [Z] = getTotalCost(X,Y, num,meshX,meshY);
        [row,col] = size(meshX);
        Z = zeros(row, col);
        for i = 1 : row
            theta = [meshX(i,:); meshY(i,:)];
            Z(i,:) =  1/(2*num)*sum((X*theta-repmat(Y,1,col)).^2);   
        end
    
    end
    
    
    function [Z] = getLoss(X,Y, num,theta)
        Z= 1/(2*num)*sum((X*theta-Y).^2);
    end
    
    function [thetaOut] = GD(X,Y,theta,eta)
        dataSize = length(X);                       % Obtain the number of data
        dx = 1/dataSize.*(X'*(X*theta-Y));          % Obtain the gradient of Loss function
        thetaOut = theta -eta.*dx;                  % Update parameters(theta)
    end
    
    % @ Depscription: 
    %       Mini-batch Gradient Descent (MBGD)
    %       Stochastic Gradient Descent(batchSize = 1) (SGD)
    % @ param:
    %       X - [1 X_] X_ is actual X; Y - actual Y
    %       theta - theta for univariate linear regression y_pred = theta_0 + theta1*x
    %       eta - learning rate;
    %
    function [thetaOut] = MBGD(X,Y,theta, eta,batchSize) 
        dataSize = length(X);           % obtain the number of data 
        k = fix(dataSize/batchSize);    % obtain the number of batch which has absolutely same size: k = batchNum-1;    
        batchIdx = randperm(dataSize);  % randomly sort for every epoch for achiving sample diversity
        
        batchIdx1 = reshape(batchIdx(1:k*batchSize),k,batchSize);   % batches which has absolutely same size
        batchIdx2 = batchIdx(k*batchSize+1:end);                    % ramained batch
        
        for i = 1 : k
            thetaOut = GD(X(batchIdx1(i,:),:),Y(batchIdx1(i,:)),theta,eta);
        end
        if(~isempty(batchIdx2))
            thetaOut = GD(X(batchIdx2,:),Y(batchIdx2),thetaOut,eta);
        end
    end
    

    动量梯度下降(Momentum / Gradient Descent with Momentum)

    动量梯度下降通过指数加权平均(Exponentially weighted moving averages)策略,使用之前梯度信息修正当前梯度,来加速参数学习。这里我们令梯度项
    1 m ∑ i = 1 m ∂ J ( θ , x i , y i ) ∂ θ = ∇ θ J ( θ ) \frac{1}{m}\sum_{i=1}^m\frac{\partial J(\theta,x^i,y^i)}{\partial \theta} = \nabla_\theta J(\theta) m1i=1mθJ(θ,xi,yi)=θJ(θ)则梯度下降可以简化表示为
    θ : = θ − η ⋅ ∇ θ J ( θ ) \theta := \theta - \eta\cdot\nabla_\theta J(\theta) θ:=θηθJ(θ)
    对于动量梯度下降,初始化动量项 m = 0 m = 0 m=0,更新迭代公式如下
    m : = γ ⋅ m + η ⋅ ∇ θ J ( θ ) m := \gamma\cdot m + \eta\cdot\nabla_\theta J(\theta) m:=γm+ηθJ(θ) θ : = θ − m \theta :=\theta - m θ:=θm
    其中 m m m为动量梯度下降的动量项,且初始化为0; γ \gamma γ是关于动量项的超参数一般取小于等于0.9。我们可以发现,越是远离当前点的梯度信息,对于当前梯度的贡献越小。

    优点:通过过去梯度信息来优化下降速度,如果当前梯度与之前梯度方向一致时候,收敛速度得到加强,反之则减弱。换句话说,加快收敛同时减小震荡,分别对应图中 θ 0 \theta_0 θ0 θ 1 \theta_1 θ1 方向。
    缺点:可能在下坡过程中累计动量太大,冲过极小值点。

    下图直观显示动量梯度下降迭代过程。
    在这里插入图片描述

    这里附上动量梯度下降的相关代码:

    % Writen by weichen GU, data 4/19th/2020
    clear, clf, clc;
    data = linspace(-20,20,100);                    % x range
    col = length(data);                             % Obtain the number of x
    data = [data;0.5*data + wgn(1,100,1)+10];       % Generate dataset - y = 0.5 * x + wgn^2 + 10;
    X = [ones(1, col); data(1,:)]';                 % X ->[1;X];
    
    t1=-40:0.1:50;
    t2=-4:0.1:4;
    [meshX,meshY]=meshgrid(t1,t2);
    meshZ = getTotalCost(X, data(2,:)', col, meshX,meshY);
    
    theta =[-30;-4];        % Initialize parameters
    LRate = [0.1; 0.002]  % Learning rate
    thresh = 0.5;           % Threshold of loss for jumping iteration
    iteration = 50;        % The number of teration
    
    lineX = linspace(-30,30,100);
    [row, col] = size(data)                                     % Obtain the size of dataset
    lineMy = [lineX;theta(1)*lineX+theta(2)];                   % Fitting line
    hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2);    % draw fitting line
    
    loss = getLoss(X,data(2,:)',col,theta);                     % Obtain current loss value
    
    subplot(2,2,1);
    plot(data(1,:),data(2,:),'r.','MarkerSize',10);
    title('Data fiting using Univariate LR');
    axis([-30,30,-10,30])
    xlabel('x');
    ylabel('y');
    hold on;
    
    % Draw 3d loss surfaces
    subplot(2,2,2)
    mesh(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('3D surfaces for loss')
    hold on;
    scatter3(theta(1),theta(2),loss,'r*');
    
    % Draw loss contour figure
    subplot(2,2,3)
    contour(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('Contour figure for loss')
    hold on;
    plot(theta(1),theta(2),'r*')
    
    % Draw loss with iteration
    subplot(2,2,4)
    hold on;
    title('Loss when using Momentum GD');
    xlabel('iter');
    ylabel('loss');
    plot(0,loss,'b*');
    
    set(gca,'XLim',[0 iteration]);
    
    hold on;
    
    batchSize = 32;
    grad = 0; gamma = 0.5;
    
    for iter = 1 : iteration
        delete(hLine) % set(hLine,'visible','off')
    
        
        %[thetaOut] = GD(X,data(2,:)',theta,LRate); % Gradient Descent algorithm
        %[thetaOut] = MBGD(X,data(2,:)',theta,LRate,20);
        [thetaOut,grad] = MBGDM(X,data(2,:)',theta,LRate,batchSize,grad,gamma);
        subplot(2,2,3);
        line([theta(1),thetaOut(1)],[theta(2),thetaOut(2)],'color','k')
    
        theta = thetaOut;
        loss = getLoss(X,data(2,:)',col,theta); % Obtain losw
        
        
        lineMy(2,:) = theta(2)*lineX+theta(1); % Fitting line
        subplot(2,2,1);
        hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2); % draw fitting line
        %legend('training data','linear regression');
        
        subplot(2,2,2);
        scatter3(theta(1),theta(2),loss,'r*');
        
        subplot(2,2,3);
        plot(theta(1),theta(2),'r*')
        
        
        subplot(2,2,4)
        plot(iter,loss,'b*');
    
        drawnow();
        
        if(loss < thresh)
            break;
        end
    end
    
    hold off
    
    
    function [Z] = getTotalCost(X,Y, num,meshX,meshY);
        [row,col] = size(meshX);
        Z = zeros(row, col);
        for i = 1 : row
            theta = [meshX(i,:); meshY(i,:)];
            Z(i,:) =  1/(2*num)*sum((X*theta-repmat(Y,1,col)).^2);   
        end
    
    end
    
    
    function [Z] = getLoss(X,Y, num,theta)
        Z= 1/(2*num)*sum((X*theta-Y).^2);
    end
    
    function [thetaOut] = GD(X,Y,theta,eta)
        dataSize = length(X);                       % Obtain the number of data
        dx = 1/dataSize.*(X'*(X*theta-Y));          % Obtain the gradient of Loss function
        thetaOut = theta -eta.*dx;                  % Update parameters(theta)
    end
    % Gradient Descent with Momentum
    function [thetaOut, momentum] = GDM(X,Y,theta,eta,momentum,gamma)
        dataSize = length(X);                       % Obtain the number of data
        dx = 1/dataSize.*(X'*(X*theta-Y));          % Obtain the gradient of Loss function
        momentum = gamma*momentum +eta.*dx;         % Obtain the momentum of gradient
        thetaOut = theta - momentum;                % Update parameters(theta)
    end
    
    % @ Depscription: 
    %       Mini-batch Gradient Descent (MBGD)
    %       Stochastic Gradient Descent(batchSize = 1) (SGD)
    % @ param:
    %       X - [1 X_] X_ is actual X; Y - actual Y
    %       theta - theta for univariate linear regression y_pred = theta_0 + theta1*x
    %       eta - learning rate;
    %
    function [thetaOut] = MBGD(X,Y,theta, eta,batchSize) 
        dataSize = length(X);           % obtain the number of data 
        k = fix(dataSize/batchSize);    % obtain the number of batch which has absolutely same size: k = batchNum-1;    
        batchIdx = randperm(dataSize);  % randomly sort for every epoch for achiving sample diversity
        
        batchIdx1 = reshape(batchIdx(1:k*batchSize),k,batchSize);   % batches which has absolutely same size
        batchIdx2 = batchIdx(k*batchSize+1:end);                    % ramained batch
        
        for i = 1 : k
            thetaOut = GD(X(batchIdx1(i,:),:),Y(batchIdx1(i,:)),theta,eta);
        end
        if(~isempty(batchIdx2))
            thetaOut = GD(X(batchIdx2,:),Y(batchIdx2),thetaOut,eta);
        end
    end
    
    function [thetaOut,grad] = MBGDM(X,Y,theta, eta,batchSize,grad,gamma) 
        dataSize = length(X);           % obtain the number of data 
        k = fix(dataSize/batchSize);    % obtain the number of batch which has absolutely same size: k = batchNum-1;    
        batchIdx = randperm(dataSize);  % randomly sort for every epoch for achiving sample diversity
        
        batchIdx1 = reshape(batchIdx(1:k*batchSize),k,batchSize);   % batches which has absolutely same size
        batchIdx2 = batchIdx(k*batchSize+1:end);                    % ramained batch
        
        for i = 1 : k
            [thetaOut,grad] = GDM(X(batchIdx1(i,:),:),Y(batchIdx1(i,:)),theta,eta,grad,gamma);
            
        end
        if(~isempty(batchIdx2))
            [thetaOut,grad] = GDM(X(batchIdx2,:),Y(batchIdx2),thetaOut,eta,grad,gamma);
        end
    end
    
    

    Nesterov加速梯度下降法(NAG / Nesterov Accelerated Gradient)

    Nesterov加速梯度下降相比于动量梯度下降的区别是,通过使用未来梯度来更新动量。即将下一次的预测梯度 ∇ θ J ( θ − η ⋅ m ) \nabla_\theta J(\theta-\eta\cdot m) θJ(θηm)考虑进来。其更新公式如下:
    m : = γ ⋅ m + η ⋅ ∇ θ J ( θ − γ ⋅ m ) m :=\gamma\cdot m+\eta\cdot\nabla_\theta J(\theta-\gamma\cdot m) m:=γm+ηθJ(θγm) θ : = θ − m \theta := \theta - m θ:=θm
    对于公式理解如下图所示,

    1. 对于起始点应用动量梯度下降,首先求得在该点处的带权梯度 η ⋅ ∇ 1 \eta\cdot\nabla_1 η1,通过与之前动量 γ ⋅ m \gamma\cdot m γm矢量加权,求得下一次的 θ \theta θ位置。
    2. 对于起始点应用Nesterov加速梯度下降,首先通过先前动量求得 θ \theta θ的预测位置,再加上预测位置的带权梯度 γ ⋅ m \gamma\cdot m γm

    在这里插入图片描述
    优点

    1. 相对于动量梯度下降法,因为NAG考虑到了未来预测梯度,收敛速度更快(如上图)。
    2. 当更新幅度很大时,NAG可以抑制震荡。例如起始点在最优点的左侧 γ m \gamma m γm对应的值在最优点的右侧,对于动量梯度而言,叠加 η ∇ 1 \eta\nabla_1 η1使得迭代后的点更加远离最优点→→。而NAG首先跳到 γ m \gamma m γm对应的值,计算梯度为正,再叠加反方向的 η ∇ 2 \eta\nabla_2 η2,从而达到抑制震荡的目的。

    下图直观显示了Nesterov加速梯度下降的迭代过程:

    在这里插入图片描述

    下面是Nesterov加速梯度下降的相关代码:

    
    % Writen by weichen GU, data 4/19th/2020
    clear, clf, clc;
    data = linspace(-20,20,100);                    % x range
    col = length(data);                             % Obtain the number of x
    data = [data;0.5*data + wgn(1,100,1)+10];       % Generate dataset - y = 0.5 * x + wgn^2 + 10;
    X = [ones(1, col); data(1,:)]';                 % X ->[1;X];
    
    t1=-40:0.1:50;
    t2=-4:0.1:4;
    [meshX,meshY]=meshgrid(t1,t2);
    meshZ = getTotalCost(X, data(2,:)', col, meshX,meshY);
    
    theta =[-30;-4];        % Initialize parameters
    LRate = [0.1; 0.002]  % Learning rate
    thresh = 0.5;           % Threshold of loss for jumping iteration
    iteration = 50;        % The number of teration
    
    lineX = linspace(-30,30,100);
    [row, col] = size(data)                                     % Obtain the size of dataset
    lineMy = [lineX;theta(1)*lineX+theta(2)];                   % Fitting line
    hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2);    % draw fitting line
    
    loss = getLoss(X,data(2,:)',col,theta);                     % Obtain current loss value
    
    subplot(2,2,1);
    plot(data(1,:),data(2,:),'r.','MarkerSize',10);
    title('Data fiting using Univariate LR');
    axis([-30,30,-10,30])
    xlabel('x');
    ylabel('y');
    hold on;
    
    % Draw 3d loss surfaces
    subplot(2,2,2)
    mesh(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('3D surfaces for loss')
    hold on;
    scatter3(theta(1),theta(2),loss,'r*');
    
    % Draw loss contour figure
    subplot(2,2,3)
    contour(meshX,meshY,meshZ)
    xlabel('θ_0');
    ylabel('θ_1');
    title('Contour figure for loss')
    hold on;
    plot(theta(1),theta(2),'r*')
    
    % Draw loss with iteration
    subplot(2,2,4)
    hold on;
    title('Loss when using NAG');
    xlabel('iter');
    ylabel('loss');
    plot(0,loss,'b*');
    
    set(gca,'XLim',[0 iteration]);
    
    hold on;
    
    batchSize = 32;
    grad = 0; gamma = 0.5;
    
    for iter = 1 : iteration
        delete(hLine) % set(hLine,'visible','off')
    
        
        %[thetaOut] = GD(X,data(2,:)',theta,LRate); % Gradient Descent algorithm
        %[thetaOut] = MBGD(X,data(2,:)',theta,LRate,20);
        [thetaOut,grad] = MBGDM(X,data(2,:)',theta,LRate,batchSize,grad,gamma);
        subplot(2,2,3);
        line([theta(1),thetaOut(1)],[theta(2),thetaOut(2)],'color','k')
    
        theta = thetaOut;
        loss = getLoss(X,data(2,:)',col,theta); % Obtain losw
        
        
        lineMy(2,:) = theta(2)*lineX+theta(1); % Fitting line
        subplot(2,2,1);
        hLine = plot(lineMy(1,:),lineMy(2,:),'c','linewidth',2); % draw fitting line
        %legend('training data','linear regression');
        
        subplot(2,2,2);
        scatter3(theta(1),theta(2),loss,'r*');
        
        subplot(2,2,3);
        plot(theta(1),theta(2),'r*')
        
        
        subplot(2,2,4)
        plot(iter,loss,'b*');
    
        drawnow();
        
        if(loss < thresh)
            break;
        end
    end
    
    hold off
    
    
    function [Z] = getTotalCost(X,Y, num,meshX,meshY);
        [row,col] = size(meshX);
        Z = zeros(row, col);
        for i = 1 : row
            theta = [meshX(i,:); meshY(i,:)];
            Z(i,:) =  1/(2*num)*sum((X*theta-repmat(Y,1,col)).^2);   
        end
    
    end
    
    
    function [Z] = getLoss(X,Y, num,theta)
        Z= 1/(2*num)*sum((X*theta-Y).^2);
    end
    
    function [thetaOut] = GD(X,Y,theta,eta)
        dataSize = length(X);                       % Obtain the number of data
        dx = 1/dataSize.*(X'*(X*theta-Y));          % Obtain the gradient of Loss function
        thetaOut = theta -eta.*dx;                  % Update parameters(theta)
    end
    % Gradient Descent with Momentum
    function [thetaOut, momentum] = GDM(X,Y,theta,eta,momentum,gamma)
        dataSize = length(X);                       % Obtain the number of data
        dx = 1/dataSize.*(X'*(X*theta-Y));          % Obtain the gradient of Loss function
        momentum = gamma*momentum +eta.*dx;         % Obtain the momentum of gradient
        thetaOut = theta - momentum;                % Update parameters(theta)
    end
    
    % @ Depscription: 
    %       Mini-batch Gradient Descent (MBGD)
    %       Stochastic Gradient Descent(batchSize = 1) (SGD)
    % @ param:
    %       X - [1 X_] X_ is actual X; Y - actual Y
    %       theta - theta for univariate linear regression y_pred = theta_0 + theta1*x
    %       eta - learning rate;
    %
    function [thetaOut] = MBGD(X,Y,theta, eta,batchSize) 
        dataSize = length(X);           % obtain the number of data 
        k = fix(dataSize/batchSize);    % obtain the number of batch which has absolutely same size: k = batchNum-1;    
        batchIdx = randperm(dataSize);  % randomly sort for every epoch for achiving sample diversity
        
        batchIdx1 = reshape(batchIdx(1:k*batchSize),k,batchSize);   % batches which has absolutely same size
        batchIdx2 = batchIdx(k*batchSize+1:end);                    % ramained batch
        
        for i = 1 : k
            thetaOut = GD(X(batchIdx1(i,:),:),Y(batchIdx1(i,:)),theta,eta);
        end
        if(~isempty(batchIdx2))
            thetaOut = GD(X(batchIdx2,:),Y(batchIdx2),thetaOut,eta);
        end
    end
    
    % Nesterov Accelerated Gradient (NAG)
    function [thetaOut, momentum] = NAG(X,Y,theta,eta,momentum,gamma)
        dataSize = length(X);                                   % Obtain the number of data
        dx = 1/dataSize.*(X'*(X*(theta- gamma*momentum)-Y));    % Obtain the gradient of Loss function
        momentum = gamma*momentum +eta.*dx;                     % Obtain the momentum of gradient
        thetaOut = theta - momentum;                            % Update parameters(theta)
    end
    
    function [thetaOut,grad] = MBGDM(X,Y,theta, eta,batchSize,grad,gamma)
        dataSize = length(X);           % obtain the number of data 
        k = fix(dataSize/batchSize);    % obtain the number of batch which has absolutely same size: k = batchNum-1;    
        batchIdx = randperm(dataSize);  % randomly sort for every epoch for achiving sample diversity
        
        batchIdx1 = reshape(batchIdx(1:k*batchSize),k,batchSize);   % batches which has absolutely same size
        batchIdx2 = batchIdx(k*batchSize+1:end);                    % ramained batch
        
        for i = 1 : k
            %[thetaOut,grad] = GDM(X(batchIdx1(i,:),:),Y(batchIdx1(i,:)),theta,eta,grad,gamma);
            [thetaOut,grad] = NAG(X(batchIdx1(i,:),:),Y(batchIdx1(i,:)),theta,eta,grad,gamma);
        end
        if(~isempty(batchIdx2))
            %[thetaOut,grad] = GDM(X(batchIdx2,:),Y(batchIdx2),thetaOut,eta,grad,gamma);
            [thetaOut,grad] = NAG(X(batchIdx2,:),Y(batchIdx2),thetaOut,eta,grad,gamma);
        end
        
    end
    

    我们将 θ 1 \theta_1 θ1对应的学习率 η \eta η升高到0.005后,得到以下另一组数据方便对比。η=[0.1,0.005]

    批梯度下降随机梯度下降的迭代过程:
    在这里插入图片描述 在这里插入图片描述
    小批量梯度下降动量梯度下降的迭代过程:
    在这里插入图片描述 在这里插入图片描述
    Nesterov加速梯度下降的迭代过程:
    在这里插入图片描述

    后语

    下一篇我们将介绍几种常见的学习率自适应梯度下降算法:AdaGrad、RMSProp、AdaDelta、Adam和Nadam。

    展开全文
  • 采用动量梯度下降算法训练 BP 网络 matlab代码
  • matlab随机梯度下降

    2021-04-22 09:33:26
    %是否使用梯度下降进行局部搜索的控制参数 IfLocalSearch=0; %...经过 10000 次训练后,traningdm 网络...Traningdm 是动量梯度下降算法,和 traningd......权系数调整 u(k) e(k) e(k 1) O1(3) u (k ) O2(3) e(k ) u...

    %是否使用梯度下降法进行局部搜索的控制参数 IfLocalSearch=0; %...

    经过 10000 次训练后,traningdm 网络的输出误差与 traningd 训练算法的结果差不多, -9- 网络误差的收敛速度也非常慢。Traningdm 是动量梯度下降算法,和 traningd......

    权系数调整 u(k) e(k) e(k 1) O1(3) u (k ) O2(3) e(k ) u (k ) O3(3) e(k) 2e(k 1) e(k 2) 网络权系数的修正采用梯度下降法。...

    但是 ,他也 存在 明 显的不 足 之处 : ()B1 P算法 是按 照均 方误 差的梯度下降方向收 敛的 ,但均 方误 差 的梯 度 曲线存 在不 少 局部 和 ......

    (rig) 另一 种是动量批梯度下降 tnd,a 训练 函数(rid。tigtnm)rn d是根据批梯度下降算 aga法, 网络 性 能参 数的 负梯 度方 向去 调节B沿 P神经网 ......

    (2)BP 学习算法的数学分析 BP 算法用了优化算法中的梯度下降法,把一组样本...

    2 (2)BP 学习算法的数学分析 BP 算法用了优化算法中的梯度下降法,把一组...

    神经网络与 matlab 仿真摘要随着技术的发展,人工神经网络在各个方面应用越来越广泛,由于 matlab 仿 真技术对神经网络的建模起着十分重要的作用,因此,本文通过讨论......

    BP算法实质是求取误差函数的最小值问题。这种算法采用非 线性规划中的最速下降方法,按误差函数的负梯度方向修改 权系数。 BP网络的快速学习算法与选择 MATLAB神经......

    网络 tansig() 双曲正切S型(Tan-Sigmoid)传输函数 logsig() 对数S型(Log-Sigmoid)传输函数 traingd() 梯度下降BP训练函数 2.4.3 BP神经网络学习算法的MATLAB......

    梯度下降法适用于寻优过程的前期迭代或 作为间插步骤,当接近极值点时宜选用其它收 敛快的算法。 资料仅供参考,不当之处,请联系改正。 ? 在MATLAB 上实现的几个......

    网络学习函数 Para.PerformFcn = 'sse'; %网络的误差函数 Para.InNum = size(Input,1); BP 神经网络的设计实例(MATLAB 编程) 例 1 采用动量梯度下降算法......

    (b) 为模 型一 、模 型二在 梯度下降法训 练下 的 择为 0.叭—O.1之...

    = F #( Sj m- 1 ) !W i m m m ij i 应修改学习率算法和动量批梯度下降算法 , 因此网络 训练速度更快。共轭梯度算法: 通过变换梯度来加快 网络训练的......

    还可使用 ‘traingdx’,即带动量的梯度下降算 法;’traincgf’,即共轭梯度法。 ? 其它可看matlab帮助:help->contents-> Neural Network Toobox-> Network Object......

    自适应调整学习速率附加动量因子梯度下降反向 传播算法训练函数 %learn 属性 'learngdm' 附加动量因子的梯度下降学习函数 net.trainParam.epochs=1000;%允许最大训练......

    还可使用 ‘traingdx’,即带动量的梯度下降算 法;’traincgf’,即共轭梯度法。 ? 其它可看matlab帮助:help->contents-> Neural Network Toobox-> Network Object......

    自适应调整学习速率附加动量因子梯度下降反向传播算法训练函数 %learn 属性 'learngdm' 附加动量因子的梯度下降学习函数 net.trainParam.epochs=1000;%允许最大训练步......

    BP算法实质是求取误差函数的最小值问题。这种算法采用非 线性规划中的最速下降方法,按误差函数的负梯度方向修改 权系数。 BP网络的快速学习算法与选择 MATLAB神经......

    比较算法 的收敛速度与复杂度袁得到了对不同模型的应用实例袁需根据不同的数据集采用较好的优化算法遥 关键词院 梯度下降法曰线性回归曰逻辑回归曰MATLAB 中图分类......

    展开全文
  • 训练BP神经网络:采用动量梯度下降算法训练BP网络,训练样本,matlab源码
  • 1 基于梯度的优化问题——探险家的故事要形象地理解无约束多变量最优化问题,我们可以想象“一个探险家在广袤无际、完全黑暗的地界上,他要只凭脚底感受到的地面的坡度,找寻最深的谷底”。最优化的过程中,我们面临...

    a485e3c01ea3f2ba6094d113662abd53.png

    1 基于梯度的优化问题——探险家的故事

    要形象地理解无约束多变量最优化问题,我们可以想象“一个探险家在广袤无际、完全黑暗的地界上,他要只凭脚底感受到的地面的坡度,找寻最深的谷底”。最优化的过程中,我们面临的就是探险家一般艰难的境况。实际上这个模型还是有点不够准确,因为在我们找寻最低点的过程应当是离散的。因此可以进而改善这个模型:天神听闻探险家的事情,感其诚,遂决定赐予他一个技能——他能够迈步任意距离到下一个位置(如果到达的地点是空中,则视为到对应垂直下方的地面,因此实际上“位置”只需考虑水平面的坐标(x,y)),但每次释放技能都会耗费同等的体力。

    现在探险家面临的问题就变成了一个回合制游戏——他的目标是在尽可能少的回合数内到达峡谷的最低点。探险家每回合的行动包含两个部分:(1)往什么方向走?(2)每步走多远?因为探险家什么都看不见,因此脚底坡度的信息对他而言十分重要。他很容易能想到,每次都应该朝梯度下降的方向迈步,这就解决了方向的问题。然而步长(在机器学习中常称为“学习率”)却令他发愁。显而易见,每次行动迈步太短会浪费“体力值”。但是,步长太长则有可能迈过头了,比如从这边山头迈到那边山头,完美错过谷底。探险家应当如何到达至深之地呢?根据探险家的具体情况,我们可以给他私人定制不同的算法。

    如果探险家比较老了,记忆力不大好——他每达到一个新的位置,并不怎么记得之前发生了什么,那么他能采用的算法就是简单粗暴的随机梯度下降法(SGD)

    如果探险家能够记得他上一步行动的信息,那么利用好这些信息或许能给他的决策带来裨益,因此他可以采用Momentum、AdaGrad、RMSProp、Adam等算法。

    以上算法都是仅使用梯度信息的一阶优化算法。假如探险家是一个堪比拉普拉斯妖一般的智者,他不但能从脚底感知梯度,还能感知梯度的梯度(Hessian矩阵),那么他就可以使用二阶优化算法,如牛顿法、阻尼牛顿法、拟牛顿法、共轭梯度法等。

    2 探险家的故事续——以一个简单的峡谷为例

    下面是探险家面临的一个狭长峡谷

    5601a27c142425cb66c771f24d80c230.png

    峡谷的函数表达式:

    从上帝视角看,很显然最低点在(0,0)处。

    探险家若使用固定步长的随机梯度下降法:

    while 

    da938f9199d760e60e509406306da7d4.png
    探险家的轨迹(步长为0.9)

    我们发现探险家还是走了不少弯路的,因为步子跨得大了。如果将步长修改为0.1呢?

    0778af13d06af54e99031184aa9ac631.png
    探险家的轨迹(步长为0.1)

    尽管不像上次那样“之”字形移动,但步数太多了,收敛到最低点的速度缓慢。由此可以看到步长对收敛速度影响非常大。

    实际上,用展开泰勒级数的方法可以知道,对于能用二次函数很好近似的函数(此例目标函数正是二次函数),可以根据梯度和Hessian矩阵确定最优步长:

    if 

    eba53e58e2d7abe7b2999adbfe39d060.png
    脚底能洞悉Hessian矩阵的Laplace探险家的轨迹

    只用三步这位智者探险家就到达最低点了。


    以一个更复杂的目标函数为例,用Matlab实现一些基本的梯度优化算法。以下主要是实现算法并绘制收敛轨迹,得到一个对优化过程的形象理解,不保证代码中的参数已经调整至最优。

    目标函数:

    初值:(-1.2,1.0)

    有最低点坐标:(1,1)

    fb10b2ba3a2a70e31dc404ab84eaa1cd.png

    3 一阶优化算法

    3.1 随机梯度下降法(SGD)

    % 无线搜索的SGD
    

    收敛步数:9085

    x=(0.9889, 0.9779)
    收敛速度极慢,且结果不够准确

    dd4647806577ceb14004e5855a17e32b.png
    收敛轨迹图(每200步标记1个点)

    % 有线搜索的SGD
    

    收敛步数:48

    x=(1.0002, 1.0004)

    收敛速度快,且结果较准确

    可以对比得到学习率的线搜索策略的对于优化过程的重要性

    2fd56feca6abdae4156a1dd6de88ba00.png
    收敛轨迹图(每步标记1个点)

    3.2 动量随机梯度下降法(Momentum)

    % Momentum
    

    收敛步数:812

    x=(0.9890, 0.9780)

    e4ca8ebc73ba2c3d98e4d8bd2e172eaa.png
    收敛轨迹图(每10步标记1个点)

    3.3 AdaGrad

    % AdaGrad
    

    收敛步数:4762

    x=(0.9889, 0.9779)

    6ab2b83924ba5d5e36309573310e0fd4.png
    收敛轨迹图(每100步标记1个点)

    3.4 RMSProp

    % RMSProp
    

    收敛步数:23956

    x=(0.9889, 0.9779)

    eef138d345eee13b3900516588042681.png
    收敛轨迹图(每100步标记1个点)

    % Nesterov-RMSProp
    

    收敛步数:724

    x=(0.9985, 0.9970)

    9b93a4827cf377dc4daa977379459314.png
    收敛轨迹图(每10步标记1个点)

    3.5 Adam

    % Adam
    

    收敛步数:12314

    x=(0.9889, 0.9779)

    23a2ad691cb1ec8e246a8fc46cc346cd.png
    收敛轨迹图(每10步标记1个点)

    4 二阶优化算法

    二阶方法收敛速度非常快,对于参数较少的问题优势很大。然而由于要存储Hessian逆矩阵,二阶方法复杂度非常高(大多是多项式复杂度),在深度学习的训练中存在计算量大、训练慢等问题,目前还不能广泛适用于深度学习模型的训练中。

    4.1 牛顿法

    % 牛顿法
    


    收敛步数:5
    x=(1.0000,1.0000)

    7641376f2f414bb52214ea776c4eca52.png
    收敛轨迹图

    4.2 阻尼牛顿法

    % 阻尼牛顿法
    

    收敛步数:11

    x=(0.9996,0.9993)

    586bb3c424ef6cc363df52a6207de358.png
    收敛轨迹图

    4.3 DFP拟牛顿法

    % DFP拟牛顿法
    

    收敛步数:35

    x=(0.9999,0.9997)

    8e1565d20c74694e5fb1c77960287b03.png
    收敛轨迹图

    除此以外,拟牛顿法中还有更先进的BFGS及L-BFGS算法。

    4.4 共轭梯度法

    % 共轭梯度法
    

    收敛步数:14

    x=(1.0000,1.0000)

    f606909d8795397c3ca5f7047ba37f0c.png
    收敛轨迹图
    展开全文
  • 梯度下降matlab代码详解实现

    千次阅读 2019-11-22 23:57:10
    梯度下降又被称为最速下降(Steepest descend method),其理论基础是梯度的概念。梯度与方向导数的关系为:梯度的方向与取得最大方向导数值的方向一致,而梯度的模就是函数在该点的方向导数的最大值。梯度下降...

    基本概念


            梯度下降法又被称为最速下降法(Steepest descend method),其理论基础是梯度的概念。梯度与方向导数的关系为:梯度的方向与取得最大方向导数值的方向一致,而梯度的模就是函数在该点的方向导数的最大值。梯度下降算法应用于求多维函数的在某一点收敛的极小值,可以用这个算法迭代出在哪个点收敛,也是求最小二乘问题的一种方法。

    借用前辈的一张图说明算法的应用。假如你站在一座山上,怎么找到最快下山的方法呢?这时你当然会朝着最陡峭的方向前进,到达一个点后,再次朝着陡峭的方向下山,从而循环这些步骤,到达山脚。从图上也可以看到,算法一定会找到函数的极值点,但未必会找到最值点。

     基本原理

    我们用matlab编程示例最速下降法的原理。简单起见,最速下降函数为一元二次方程:

                                               

    展开全文
  • BP 神经网络基础数学模型
  • MATLAB梯度下降

    2020-03-10 22:43:52
      梯度下降(英语:Gradient descent)是一个一阶最优化算法。 要使用梯度下降找到一个函数的局部极小值,必须向函数上当前点对应梯度(或者是近似梯度)的反方向的规定步长距离点进行迭代搜索。如果相反地向...
  • 采用动量梯度下降算法训练 BP 网络

    千次阅读 2013-02-02 15:00:23
    例1 采用动量梯度下降算法训练 BP 网络。 训练样本定义如下: 输入矢量为   p =[-1 -2 3 1   -1 1 5 -3] 目标矢量为 t = [-1 -1 1 1] 解:本例的 MATLAB 程序如下:  close all  ...
  • 梯度下降原理和matlab仿真分析

    千次阅读 2020-12-10 17:03:52
    1 引言 梯度下降法(Gradient ...由梯度下降法衍生了许多其他算法,如次梯度下降法,近端梯度下降法,随机梯度下降法,回溯梯度发,动量加速梯度法等等。本文只介绍最基础的梯度下降法原理和理论分析,与此同时,通过
  • 更多相关内容请关注vx公号 优化与算法 便捷及时阅览1 引言梯度下降(Gradient Descent)也称为最速下降(Steepest Descent),是法国数学家奥古斯丁·路易·柯西 (Augustin Louis Cauchy) 于1847年提出来,它是最...
  • 随机梯度下降的动量法 Momentum

    千次阅读 2019-05-21 18:45:10
    转自:https://blog.csdn.net/BVL10101111/article/details/72615621 (下面选中的这句话很直观)
  • 基于自适应动量因子的 BP 神经网络优化方法研究 王锦[1];... 用蚁群优化算法选择最优初始权值 蚁群优化算法是一......自学习模型为 △Wij(n+1)= h ×Фi×Oj+a×△Wij(n) (5) h -学习因子;Фi-输出节点 i 的计算误...
  • 梯度下降实现softmax回归MATLAB程序

    千次阅读 2016-06-29 17:10:26
    梯度下降实现softmax回归MATLAB程序 版权声明:本文原创,转载须注明来源。 解决二分类问题时我们通常用Logistic回归,而解决多分类问题时若果用Logistic回归,则需要设计多个分类器,这是相当麻烦的事情。...
  • 文件名称: natural-gradient-algorithm下载 收藏√ [5 4 3 2 1]开发工具: matlab文件大小: 20 KB上传时间: 2013-03-28下载次数: 24提 供 者: 张艳芹详细说明:变步长自然梯度算法实现盲源分离,后面还有动量项自然...
  • MATLAB中的机械臂路径规划算法 在R2019a发布后RoboticsSystemToolbox(RST)中多了几个机械臂路径规划的MATLAB函数和Simulink模块。 MATLAB函数: Simulink模块: 不管是MATLAB函数还是类似Simulinkblock,大概这么几...
  • 利用MATLAB菜单栏的“导入数据”功能,将高塔观测数据导入 要点 Loggernet将原始二进制数据转为ASCII 【data】【card convert】按文件夹选择 MATLAB导入数据 输出类型中选择【列向量】 导入65080 30min数据和9345...
  • clear all;  pause(1);  P=[0.1452 0.1466 0.1314 0.2243 0.3523 0.4642 0.5015 0.6981 0.7821 0.8345 0.9649 1.156 0.2415 0.3027 0;  0.1217 0.1581 0.1408 0.2304 0.3143 0.4312 0.5819 0.7125 0.8065 0....
  • 更多相关内容请关注vx公号 优化与算法 便捷及时阅览1 引言梯度下降(Gradient Descent)也称为最速下降(Steepest Descent),是法国数学家奥古斯丁·路易·柯西 (Augustin Louis Cauchy) 于1847年提出来,它是最...
  • 使用的自适应梯度下降算法如下:Adagrad, Adadelta, RMSProp, Adam 比较了采用不同学习率策略和自适应梯度下降算法的模型性能 导入相应的库函数 from __future__ import print_function import numpy as np import ...
  • matlab人脸识别论文

    万次阅读 多人点赞 2019-10-11 17:41:51
    再由PCA算法对人脸图像进行主成分特征提取,进--步降低图像数据的处理量;最后使用经过训练后的BP神经网络对待测人脸进行分类识别。详细介绍了离散小波变换PCA特征提取以及BP神经网络分类设计。通过系统仿真实验与分析...
  • 神经网络学习算法,包括GradientDescent,Momentum,Adagrad,RMSprop,Adam优化方法,matlab程序
  • 遗传算法matlab初始化代码神经网络优化遗传算法 这是一个简单的项目,它涉及为人脸检测目的而训练的神经网络扩展耶鲁 B 数据库(38 人的人脸集合)。 定向梯度直方图 (HoG) 特征已被提取并存储在单独的 .mat 文件中...
  • MATLAB神经网络编程》 化学工业出版社 读书笔记 第四章 前向型神经网络 4.3 BP传播网络 本文是《MATLAB神经网络编程》书籍的阅读笔记,其中涉及的源码、公式、原理都来自此书,若有不理解之处请参阅原书

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,033
精华内容 413
关键字:

动量梯度算法matlab

matlab 订阅