精华内容
下载资源
问答
  • 模型优化-动量方法

    千次阅读 2019-06-02 18:05:11
    动量梯度下降(Gradient Descent With Momentum),简称为动量方法(Momentum),运行速度几乎总是快于标准的梯度下降算法,并且能够解决随机梯度下降所遇到的山谷震荡以及鞍部停滞问题,这部分内容请阅读上一篇博客...

    动量梯度下降(Gradient Descent With Momentum),简称为动量方法(Momentum),运行速度几乎总是快于标准的梯度下降算法,并且能够解决随机梯度下降所遇到的山谷震荡以及鞍部停滞问题,这部分内容请阅读上一篇博客梯度下降算法

    根据梯度下降算法的参数更新公式:
    w=wηL(w)w w = w - \eta\frac{\partial L(w)}{\partial w}
    参数的更新仅仅取决于当前位置的梯度以及步长,试想一下这样一个情境:我们将某一个物品往山谷里丢,在梯度下降算法的规则下,该物品仅仅收到当前触碰在它身上的力,而忽略其他的力,例如重力、空气阻力等等。我们可以把它想象成一张纸团。

    • 山谷:在山谷中不可避免地撞在山壁,由于质量小受山壁弹力的干扰大,从一侧山壁反弹回来撞向另一侧山壁,结果来回震荡地滚下。
    • 鞍部:纸团来到鞍部时,由于质量小,速度很快减为零,无法冲出鞍部区域。

    如果此时,该物品拥有了大质量,例如是一个铁球,

    • 山谷:那么它沿着山谷滚下时,就不容易受到途中旁力的干扰,轨迹会更稳更直。
    • 鞍部:在惯性的作用下继续滚动,从而有机会冲出鞍部。

    在中学物理中,刻画惯性的物理量是动量,这也是该算法名字的由来。沿山谷滚下的铁球会收到沿坡道向下的力和与左右山壁碰撞的弹力。向下的力(重力)稳定不变,产生的动量不断累积,速度越来越快;左右的弹力总是在不停切换,动量累积的结果是相互抵消,减弱了球的来回震荡。因此,与随机梯度下降相比,动量方法的收敛速度更快,收敛曲线也更稳定,见下图。

    随机梯度下降与动量方法比较.png

    相比标准的梯度下降算法,动量梯度下降是算法将动量纳入了参数更新公式中。

    【计算公式】:
    vt=γvt1+ηL(w)ww=wvt v_t = \gamma v_{t-1} + \eta \frac{\partial L(w)}{\partial w} \quad w = w - v_t
    其中,KaTeX parse error: Expected 'EOF', got '\gammda' at position 1: \̲g̲a̲m̲m̲d̲a̲ 是衰减系数,扮演阻力的作用。前进步伐 vtv_t 由两部分组成:

    • 标准的梯度下降算法部分,也就是步长乘上当前位置的梯度:ηL(w)w\eta \frac{\partial L(w)}{\partial w}
    • 带衰减的前一次步伐 vt1v_{t-1}

    在该公式中,惯性就体现在对前一次步伐信息的利用。类比中学物理知识,当前梯度就好比当前时刻受力产生的加速度,而步长则是时间,前一次步伐好比前一时刻的速度。标准梯度下降算法在每次行动时,都忽略前一时刻的速度,而重新根据当前时刻的加速度和时间来行走,因此当加速度趋于零时就很难继续移动。而动量方法则考虑前一时刻速度和当前加速度的共同作用。

    不同的文献对于动量方法的计算公式也略有不同,吴恩达老师推荐使用下述的计算公式。
    vt=βvt1+(1β)L(w)ww=wηvt v_t = \beta v_{t-1} + (1 - \beta)\frac{\partial L(w)}{\partial w} \\ w = w - \eta v_t
    至于孰优孰劣暂无定论,大家可各按喜好进行选择。

    动量方法可以嵌入到标准的梯度下降算法中,例如使用动量的随机梯度下降、使用动量的批量梯度下降等等。无论对哪个梯度下降算法,加入动量后都可以加快收敛速度。对于随机梯度下降而言,还可以在一定程度上解决鞍部停滞问题。

    【代码实现】:

    def BatchGradientDescentM(x, y, step=0.001, iter_count=500, beta=0.9):
        length, features = x.shape
        
        # 初始化参数和动量以及整合 x'
        data = np.column_stack((x, np.ones((length, 1))))
        w = np.zeros((features + 1, 1))
        v = np.zeros((features + 1, 1))
        
        # 开始迭代
        for i in range(iter_count):
            # 计算动量
            v = (beta * v + (1 - beta) * np.sum((np.dot(data, w) - y) * data, axis=0).reshape((features + 1, 1))) / length    
            # 更新参数
            w -= step * v        
        return w
    

    同样,增量方法也可以嵌入到小批量梯度下降以及随机梯度下降算法中,具体代码请参考 传送门

    我们也可以将这些算法都整合到一块,通过 batch_size 的大小来判断是批量梯度下降算法,还是随机梯度下降算法。

    【代码实现】:

    def Momentum(x, y, step=0.01, iter_count=1000, batch_size=4, beta=0.9):
        length, features = x.shape
        
        # 初始化参数和动量以及整合 x'
        data = np.column_stack((x, np.ones((length, 1))))
        w = np.zeros((features + 1, 1))
        v = np.zeros((features + 1, 1))
        start, end = 0, batch_size
        
        # 开始迭代
        for i in range(iter_count):
            v = (beta * v + (1 - beta) * np.sum((np.dot(data[start:end], w) - y[start:end]) * data[start:end], axis=0).reshape((features + 1, 1))) / length         
            w -= step * v
            start = (start + batch_size) % length
            if start > length:
                start -= length
            end = (end + batch_size) % length
            if end > length:
                end -= length
        return w
        
    
    # 批量梯度下降
    print(Momentum(x, y, batch_size=(x.shape[0] - 1)))
    # 输出:
    array([[5.00311478],
           [0.8307453 ]])
           
    # 小批量梯度下降
    Momentum(x, y, batch_size=5)
    # 输出:
    array([[4.98144568],
           [1.43164128]])
           
    # 随机梯度下降
    Momentum(x, y, batch_size=1)
    # 输出:
    array([[4.99294353],
           [0.83128473]])
    

    牛顿动量

    受 Nesterov 加速梯度算法启发,Sutskever 提出动量方法的一个变种。与 Momentum 不同的是,Nesterov 先用当前的速度更新参数,再用更新后的临时参数计算梯度。

    【代码实现】:

    def Nesterov(x, y, step=0.01, iter_count=1000, batch_size=4, beta=0.9):
        length, features = x.shape
        data = np.column_stack((x, np.ones((length, 1))))
        w = np.zeros((features + 1, 1))
        v = np.zeros((features + 1, 1))
        start, end = 0, batch_size
        for i in range(iter_count):
            # 先更新参数
            w_temp = w - step * v
            # 再计算梯度与速度
            v = (beta * v + (1 - beta) * np.sum((np.dot(data[start:end], w_temp) - y[start:end]) * data[start:end], axis=0).reshape((features + 1, 1))) / length         
            w -= step * v
            start = (start + batch_size) % length
            if start > length:
                start -= length
            end = (end + batch_size) % length
            if end > length:
                end -= length
        return w
    

    牛顿增量相当于添加了矫正因子的 Momentum 方法,在批量梯度下降算法中能进一步缩小误差,但对于随机梯度下降而言,牛顿增量没有任何改进。

    参考

    展开全文
  • momentum动量方法

    千次阅读 2016-09-13 11:34:35
    由一阶滤波器得到启发(采用本次采样值与上次滤波输出进行加权,得到有效滤波,使得输出对输入有反馈作用)  如下图,当γ增加,滤波器输出震荡减少。平均滤波器输出与平均滤波器输入相同... 由于使用动量项,可

            由一阶滤波器得到启发(采用本次采样值与上次滤波输出进行加权,得到有效滤波,使得输出对输入有反馈作用)


            如下图,当γ增加,滤波器输出震荡减少。平均滤波器输出与平均滤波器输入相同,岁当当γ增加时,滤波器输入变慢。滤波器有助于减少震荡的书数目,同时仍然保持平均值。


    动量MOBP

          将动量滤波器加到参数的改变后,得到:

          由于使用动量项,可以在维持算法稳定的基础上使用更高的学习速度,动量的另一个特征是当轨迹进入某一个一直的方向后,可以加速收敛。

         



    python程序

    import numpy as np
    from math import e
    import matplotlib.pyplot as plt
    import scipy.io as sio
    
    def logsig(x):
        return 1/(1+e**(-x))
    
    if __name__=="__main__":
        W1=np.array([[2.0],[3.0]])
        b1=np.array([[-1.],[1.]])
        W2=np.array([[1.,1.]])
        b2=np.array([[-1.]])
        P=np.array([np.arange(-2,2,0.1)])
        #P=np.array([[1]])
        a0=P
        T=logsig(np.dot(W2,logsig(np.dot(W1,P)+b1))+b2)
    
        x = -2.0
        y = 0.6
        ep=300
        W1[0,0]=x
        W2[0,0]=y
        n1 = np.dot(W1, P)+b1
        a1 = logsig(n1)
        n2 = np.dot(W2, a1)+b2
        a2 = logsig(n2)
        lr=1.5
        mc=0.
    
        xx=np.zeros([1,ep+1])
        yy=np.zeros([1,ep+1])
        ee = np.zeros([1, ep + 1])
        E=T-a2
        #print E
        xx[0,0]=x
        yy[0,0]=y
        ee[0,0]=np.sum(E*E)
        v1=np.zeros(W1.shape)
        v2=np.zeros(W2.shape)
        for i in range(1,ep+1):
            s2=-2*E*(1-a2)*a2
            s1=np.dot(W2.T,s2)*a1*(1-a1)
            #print s1
            #s2=-2*a2*(1-a2)*E
            #s1=(1-a1)*a1*np.dot(W2.T,s2)
            dW2 = np.dot(s2, a1.T)
            dW1=np.dot(s1,a0.T)
            #print dW1
            v1 = mc * v1 - lr * dW1
            v2 = mc * v2 - lr * dW2
            newx=W1[0,0]+v1[0,0]
            W1[0,0]=newx
            xx[0,i]=newx
            newy = W2[0, 0] + v2[0, 0]
            W2[0, 0] = newy
            yy[0, i] = newy
            a1=logsig(np.dot(W1,a0)+b1)
            a2=logsig(np.dot(W2,a1)+b2)
            E=T-a2
            ee[0,i]=np.sum(E*E)
        print W1, W2
        data=sio.loadmat('nndbp1')
        p1=plt.subplot(121)
        p2=plt.subplot(122)
        x2=data['x2']
        y2=data['y2']
        E2=data['E2']
        x2,y2=np.meshgrid(x2,y2)
        p1.contour(x2,y2,E2)
        #p1.plot(xx[0,1:80],yy[0,1:80])
        p1.plot(xx[0,1:80],yy[0,1:80])
        p2.plot(ee[0,1:50])
        plt.show()
    
    
    
    
    
    
    

    实验结果


    上图,当mc=0,lr=1.5时,迭代约30次后收敛



    mc=0,lr=2.5时出现震荡


    mc=0.1,lr=2,5时,仅需10次就收敛了


    展开全文
  • Deep Learning 最优化方法之Momentum(动量

    万次阅读 多人点赞 2017-05-21 22:48:16
    动量方法主要是为了解决Hessian矩阵病态条件问题(直观上讲就是梯度高度敏感于参数空间的某些方向)的。 2.加速学习 3.一般将参数设为0.5,0.9,或者0.99,分别表示最大速度2倍,10倍,100倍于SGD的算法。

    本文是Deep Learning 之 最优化方法系列文章的Momentum(动量)方法。主要参考Deep Learning 一书。

    整个优化系列文章列表:

    Deep Learning 之 最优化方法

    Deep Learning 最优化方法之SGD

    Deep Learning 最优化方法之Momentum(动量)

    Deep Learning 最优化方法之Nesterov(牛顿动量)

    Deep Learning 最优化方法之AdaGrad

    Deep Learning 最优化方法之RMSProp

    Deep Learning 最优化方法之Adam

    先上结论:

    1.动量方法主要是为了解决Hessian矩阵病态条件问题(直观上讲就是梯度高度敏感于参数空间的某些方向)的。

    2.加速学习

    3.一般将参数设为0.5,0.9,或者0.99,分别表示最大速度2倍,10倍,100倍于SGD的算法。

    4.通过速度v,来积累了之间梯度指数级衰减的平均,并且继续延该方向移动:

    这里写图片描述

    再看看算法:
    这里写图片描述

    动量算法直观效果解释:

      如图所示,红色为SGD+Momentum。黑色为SGD。可以看到黑色为典型Hessian矩阵病态的情况,相当于大幅度的徘徊着向最低点前进。
      而由于动量积攒了历史的梯度,如点P前一刻的梯度与当前的梯度方向几乎相反。因此原本在P点原本要大幅徘徊的梯度,主要受到前一时刻的影响,而导致在当前时刻的梯度幅度减小。
      直观上讲就是,要是当前时刻的梯度与历史时刻梯度方向相似,这种趋势在当前时刻则会加强;要是不同,则当前时刻的梯度方向减弱。

    这里写图片描述

    从另一个角度讲:

      要是当前时刻的梯度与历史时刻梯度方向相似,这种趋势在当前时刻则会加强;要是不同,则当前时刻的梯度方向减弱。
      假设每个时刻的梯度g总是类似,那么由这里写图片描述我们可以直观的看到每次的步长为:

    这里写图片描述

    即当设为0.5,0.9,或者0.99,分别表示最大速度2倍,10倍,100倍于SGD的算法。

    展开全文
  • 即使最近重新考虑了波利亚科夫的原始引导方法,但在动量空间中并没有明确构造交叉对称基础。 在本文中,我们通过使用涉及一个张量的三点函数的新解析表达式,完成了带有带一般自旋的中间算子的标量四点函数的交叉...
  • Nesterov动量更新方法理解要点

    千次阅读 2019-04-24 10:24:31
    为了解释Nesterov动量更新的原理,我们从速度更新表达式开始说起。 v = mu * v - learning_rate * dx (为了说明下面的推论还是需要一些前提的,为了不影响整体感,把这些放到本小节的后面) 其实这个式子背后提现...

    本文主要是对CS231n相应部分做一些详细的阐释

    为了解释Nesterov动量更新的原理,我们从速度更新表达式开始说起。

    v = mu * v - learning_rate * dx 
    

    (为了说明下面的推论还是需要一些前提的,为了不影响整体感,把这些放到本小节的后面)
    其实这个式子背后提现了这样一个原理:下一时刻的速度应该由 「当前的速度」以及「质点因受力产生的速度变化」两部分共同构成。
    在这里插入图片描述

    式子的前一部分( mu * v)代表质点当前的速度状态,它是由上一个时刻的速度乘以摩擦系数得到,后一部分(learning_rate * dx)代表了作用在这个质点因重力产生的加速度进而产生了速度的变化,但是dx中的x是上一时刻的位置,dx确切的含义是上一时刻的位置带入到梯度解析式中得到关于这一时刻的重力对质点的速度影响。

    这样你就看出毛病了把——利用上一时刻质点的位置信息计算这一时刻的加速度是否合适?是不是觉得有点不妥?总觉得这一时刻的影响效果应该由这一时刻的相关信息计算出来,也就是这一时刻的加速度应该用这一时刻的位置信息来计算比较合适。但是这一时刻的位置信息又取决于当前的速度信息,当前的速度信息中的一部分又需要当前的位置信息,有点死循环了。

    解决的方法是引入一个新的概念——“趋势点”。(这是我对lookahead这个词的意译)
    利用趋势点来近似的代替“这一时刻的位置”从而计算出当前时刻重力对质点的速度影响(重力加速度),之后在用这个速度和这一时刻的「当前速度」相结合得到下一时刻的速度。

    “趋势点”是这样定义的:如果没有重力(也就是没有后一项),质点下一时刻的位置就是x + mu*v,我们可以称这个位置叫做“趋势位置”(lookahead)。这里也可以借助一下极限的思想,如果时间比较短的时候,x + mu * v 所表示的位置是质点最终到达的位置的一个临域。

    代码表示成下面:

    x_ahead = x + mu * v  # 先计算出趋势点
    v = mu * v - learning_rate * dx_ahead # 将趋势点带入梯度中作为当前的加速度效果
    x += v
    

    原理就是这样,但是在实践中人们希望用新方法中更新表达式的样子和之前方法中表达式样子接近。换句话说我们是要通过一些数学技巧把当前这个式子形式转换一下。

    核心技巧就是把上面式子中的x_head用x来进行代替,换句话说并不让x_head显式的出现在更新的式子里,而是变通的用其他的量来代替。这里涉及到好几个变量,而且还涉及到这些变量在不同的迭代时刻,为了掰扯清楚这件事情,我们定义下面的变量:

    真实位置: TP(Ture Postion)
    趋势位置:LH(lookahead)
    速度:V(这没啥可说的)
    与时刻相关的下标: last(上一次) now(这一次) next(下一次)
    摩擦系数 :μ\mu
    学习率:α\alpha

    在一开始我们的关系是这样(允许“趋势位置”显式出现)
    LHnow=TPlast+μVlastLH_{now} = TP_{last} + {\mu}V_{last}
    Vnow=μVlastαd(LHnow)V_{now}={\mu}V_{last} - {\alpha}d(LH_{now})
    TPnow=TPlast+VnowTP_{now} =TP_{last} + V_{now}

    这其实就是把上面的更新代码翻译成数学语言表达的样子,下标是特别有用的东西,这个方法灵感来自于SVM中SMO方法的推导,其实仔细想想,迭代这个概念我们在数学中还真的没有明确的遇到过,我们从来没有在数学中用一个变量表示不同时刻的值,或者说很少用一个明确的表示方法来将同一个自变量的不同时刻区别开来如果他们需要出现在同一个式子里。
    在这三个式子里,TPlastTP_{last}VlastV_{last}是已知量,需要推导出LHnowLH_{now}VnowV_{now}TPnowTP_{now}

    下面我们考虑这样一个问题
    已知LHnowLH_{now}(将来会用x来代替),VlastV_{last},需要推导出VnowV_{now}LHnextLH_{next}
    要推导LHLHTPTP是不可缺少中间变量的,但是不能出现在式子中,需要变通的方式代替它。

    根据上面的式子我们知道
    LHnext=TPnow+μVnowLH_{next} = TP_{now} + {\mu}V_{now}
    TPnow=TPlast+VnowTP_{now} = TP_{last} + V_{now}
    其中TPlast=LHnowμVlastTP_{last} = LH_{now} - {\mu}V_{last}(由 上面的 LHnow=TPlast+μVlastLH_{now} =TP_{last} + {\mu}V_{last} 推导而来)
    带入得到:LHnext=LHnowμVlast+Vnow+μVnowLH_{next} = LH_{now} - {\mu}V_{last} +V_{now} + {\mu}V_{now}
    其中Vnow=μVlastαd(LHnow)V_{now} = {\mu}V_{last}-{\alpha}d(LH_{now})
    于是更新的主要式子就是:
    1 Vnow=μVlastαd(LHnow)V_{now} = {\mu}V_{last}-{\alpha}d(LH_{now})
    2 LHnext=LHnowμVlast+Vnow+μVnowLH_{next} = LH_{now} - {\mu}V_{last} +V_{now} + {\mu}V_{now}
    你会发现第二个式子既需要VnowV_{now}也需要VlastV_{last}
    所以需要一个单独的变量「v_prev」来保存VlastV_{last} ,之后再把这两个式子中的LHLH换成「x」,V换成「v」,就得到了更新代码:

    v_prev = v # 需要一个单独的变量保存上一次的速度
    v = mu * v - learning_rate * dx # 对应上面的1式
    x += -mu * v_prev + (1 + mu) * v # 对应上面的2式
    

    本小结用到推论前提

    1. 由于这里设质点的质量为1,时间也为1,工具力学公式,有些量之间的大小是一样的,在推理的时候以下概念可能会混用。
      • 损失函数相当于重力势能
      • 梯度是能量函数的导数也就是重力,或者说是重力作用力
      • F=ma 所以 力作用 = 加速度
      • v=at 所以 加速度 = 速度
      • s = vt 所以 速度 = 位移
      • p = mv 所以 动量 = 速度
    2. v = mu * v - learning_rate * dx 这个式子到底叫做动量更新表达式还是速度更新表达式呢?在质点质量是1的情况下不区分这两种说法。
    3. x表示参数,也可以看成是质点某一时刻的位置;dx是求出损失函数的梯度解析式再带入x所代表的坐标得到的值,我们知道某一点的梯度代表的是那一点的切线,也可以称之为趋势。
    展开全文
  • 深度学习中的动量

    千次阅读 2018-06-08 16:35:23
    动量方法 (Polyak, 1964) 旨在加速学习,特别是处理高曲率、小但一致的梯度,或是带噪声的梯度。 动量算法积累了之前梯度指数级衰减的移动平均,并且继续沿该方向移动。 动量的效果如下图所示。 动量的主要目的是...
  • 动量方法旨在加速学习(加快梯度下降的速度),特别是处理高曲率、小但一致的梯度,或是带噪声的梯度。动量算法累积了之前梯度指数级衰减的移动平均,并且继续沿该方向移动。 简单介绍一下什么是指数加权平均...
  • 本文是Deep Learning 之 最优化方法系列文章的Momentum(动量方法。主要参考Deep Learning 一书。 整个优化系列文章列表: Deep Learning 之 最优化方法 Deep Learning 最优化方法之SGD Deep Learning 最优化...
  • 本文是Deep Learning 之 最优化方法系列文章的Nesterov(牛顿动量)方法。主要参考Deep Learning 一书。 整个优化系列文章列表: Deep Learning 之 最优化方法 Deep Learning 最优化方法之SGD Deep Learning 最...
  • 针对卫星动量轮的剩余寿命预测问题,提出一种基于Copula函数的多退化量下的寿命预测方法。首先,分析了影响动量轮寿命的关键因素,选择润滑剂剩余量和电流作为退化量;其次,分别对单个退化量进行退化建模,得到动量轮剩余...
  • 动量方法旨在加速学习,特别是处理高曲率、小但一致的梯度,或是带噪声的梯度。动量算法积累了之前梯度指数级衰减的移动平均,并且继续沿该方向移动。从形式上看,动量算法引入了变量v充当速度角色------它代表参数...
  • 作者提倡的大动量有效理论(或LaMET)提供了一种直接方法来模拟欧几里得格QCD理论中的部分物理。 最近,在文献中对该理论已经引起了很多兴趣,有人质疑它的有效性和有效性。 在这里,我们提供了一些讨论,旨在进一步...
  • 基于自然梯度算法提出一种带自适应动量因子的变步长盲源分离方法,在平稳和非平稳环境下进行正定盲源分离处理。该方法利用性能指标构造函数来估计混合矩阵,依据估计混合矩阵得出估计性能指标再反馈更新构造函数;...
  • 基于加权状态H方法的空间站姿态控制和动量管理
  • 优化法——动量

    2021-03-13 18:25:04
    动量梯度下降(Gradient Descent With Momentum),简称为动量方法(Momentum),运行速度几乎总是快于标准的梯度下降算法,并且能够解决随机梯度下降所遇到的山谷震荡以及鞍部停滞问题,这部分内容请阅读上一篇博客...
  • 融合系统采用动量BP神经网络对多源信息进行融合,根据调腔过程中的输入、输出情况,设计包含输入层、隐含层及输出层的3层网络拓扑结构。实验结果表明,此种方法对激光陀螺调腔质量是否合格判断准确率为93.81%,比...
  • 基于加权状态H∞方法的空间站姿态控制和动量管理
  • 我们先前的工作[1]基于Polyakov提出的因式分解性质,在三维动量空间中为标量共形四点函数构造了一个明显交叉的对称基础。 这项工作将这种构造扩展到通用尺寸共形场理论。 为了促进对称无痕张量的处理,我们采用了...
  • 我们考虑了强子碰撞中胶子聚变产生的希格斯玻色子的横向动量分布。 在较小的横向动量处,大的对数项将恢复到最接近对数的对数(NLL)精度。 恢复的计算始终与在较大横向动量下有效的次要(NLO)结果匹配。 随后的...
  • 《基于增加动量方法优化的交通流量预测算法》 计算机与数字工程/2021/深圳大学 1 小波神经网络 1.1 小波变换理论 小波变换是一种新型的信号时频分析变换方法,该变换的信号方向选择能力可以突出数据的某些...

空空如也

空空如也

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

动量方法