精华内容
下载资源
问答
  • 动量:动量算法实验代码
  • BP动量算法仿真

    2013-05-13 05:30:44
    动量算法改进的BP算法matlab仿真实例,经验证。证 明一个3层的BP网络能够实现任意的连续映射,可以任意 精度逼近任何给定的连续函数 。
  • momentum动量算法详解

    千次阅读 2019-10-29 11:46:24
    momentum动量算法详解 1.原理 先看作用: 保留历史梯度对现有梯度的影响,具有减小梯度震荡,加速模型训练的作用。 再看解释: 如图所示,红色为SGD+Momentum。黑色为SGD。可以看到黑色为典型Hessian矩阵病态的情况...

    momentum动量算法详解

    1.原理

    先看作用:

    保留历史梯度对现有梯度的影响,具有减小梯度震荡,加速模型训练的作用。

    再看解释:
    在这里插入图片描述
    如图所示,红色为SGD+Momentum。黑色为SGD。可以看到黑色为典型Hessian矩阵病态的情况,相当于大幅度的徘徊着向最低点前进。

    而由于动量积攒了历史的梯度,如点P前一刻的梯度与当前的梯度方向几乎相反。因此原本在P点原本要大幅徘徊的梯度,主要受到前一时刻的影响,而导致在当前时刻的梯度幅度减小。

    直观上讲就是,要是当前时刻的梯度与历史时刻梯度方向相似,这种趋势在当前时刻则会加强;要是不同,则当前时刻的梯度方向减弱。

    2.算法实现

    算法原理:

    在这里插入图片描述

    pytorch-SGD+Momentum源码:

    class SGD(Optimizer):
        .... #函数注释
    
        def __init__(self, params, lr=required, momentum=0, dampening=0,
                     weight_decay=0, nesterov=False):
            ... #初始化
    
        def __setstate__(self, state):
            super(SGD, self).__setstate__(state)
            for group in self.param_groups:
                group.setdefault('nesterov', False)
    
        def step(self, closure=None):
            """Performs a single optimization step.
    
            Arguments:
                closure (callable, optional): A closure that reevaluates the model
                    and returns the loss.
            """
            loss = None
            if closure is not None:
                loss = closure()
    
            for group in self.param_groups:
                weight_decay = group['weight_decay']
                momentum = group['momentum'] 	#动量参数α
                dampening = group['dampening']
                nesterov = group['nesterov']
    
                for p in group['params']:
                    if p.grad is None:
                        continue
                    d_p = p.grad.data
                    if weight_decay != 0:
                        d_p.add_(weight_decay, p.data)# d_p = d_p + (weight_decay * p)
                    if momentum != 0:
                        param_state = self.state[p]	#存放辅助性的参数
                        if 'momentum_buffer' not in param_state:
                            buf = param_state['momentum_buffer'] = torch.zeros_like(p.data)	#开辟内存空间,存放动量参数
                            buf.mul_(momentum).add_(d_p)# buf = buf * momentum + d_p
                        else:
                            buf = param_state['momentum_buffer']
                            buf.mul_(momentum).add_(1 - dampening, d_p)# buf = momentum * buf + (1 - dampening) * d_p
                        if nesterov:
                            d_p = d_p.add(momentum, buf)# d_p = d_p + momentum * buf
                        else:
                            d_p = buf
    
                    p.data.add_(-group['lr'], d_p)# p = p - lr * d_p
    
            return loss
    展开全文
  • Bkprop Köhnəproqramlarınyenihəyatı。 BkpropС#-da。
  • 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....


    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.8647 0.9726 1.132 0.2385 0.3125 0; 
    0.1525 0.1627 0.1507 0.2406 0.3502 0.4636 0.5051 0.7352 0.8459 0.8915 0.9654 1.156 0.2216 0.2701 1; 
    0.1016 0.1105 0.1234 0.1978 0.3021 0.4232 0.5819 0.6952 0.8015 0.8725 0.9825 1.095 0.2352 0.2506 0.5; 
    0.1115 0.1201 0.1312 0.2019 0.3532 0.4736 0.5029 0.7032 0.8189 0.8619 0.9365 1.125 0.2542 0.3125 0; 
    0.1335 0.1322 0.1534 0.2214 0.3623 0.4827 0.5198 0.7276 0.8359 0.8906 0.9592 1.143 0.2601 0.3198 0; 
    0.1368 0.1432 0.1653 0.2205 0.3823 0.4971 0.5136 0.7129 0.8263 0.8953 0.9891 1.137 0.2579 0.3099 0; 
    0.1342 0.1368 0.1602 0.2131 0.3726 0.4822 0.5101 0.7098 0.8127 0.8921 0.9995 1.126 0.2301 0.2867 0.5; 
    0.1113 0.1212 0.1305 0.1819 0.3952 0.4312 0.5886 0.6898 0.7999 0.8423 0.9721 1.095 0.2234 0.2799 1; 
    0.1005 0.1121 0.1207 0.1605 0.3556 0.4022 0.5553 0.6673 0.7798 0.8623 0.9521 1.087 0.2314 0.2977 0]'; 
    T=[0.1217 0.1581 0.1408 0.2304 0.3143 0.4312 0.5819 0.7125 0.8265 0.8847 0.9826 1.132; 
    0.1525 0.1627 0.1507 0.2406 0.3502 0.4636 0.5051 0.7352 0.8459 0.8915 0.9464 1.156; 
    0.1016 0.1105 0.1234 0.1978 0.3021 0.4232 0.5819 0.6952 0.8015 0.8825 0.9825 1.102; 
    0.1115 0.1201 0.1312 0.2019 0.3532 0.4736 0.5029 0.7032 0.8189 0.8919 0.9965 1.125; 
    0.1335 0.1322 0.1534 0.2214 0.3623 0.4827 0.5198 0.7276 0.8359 0.8506 0.9892 1.123; 
    0.1368 0.1432 0.1653 0.2205 0.3823 0.4971 0.5136 0.7129 0.8263 0.8953 0.9691 1.117; 
    0.1342 0.1368 0.1602 0.2131 0.3726 0.4822 0.5101 0.7098 0.8127 0.8921 0.9995 1.126; 
    0.1113 0.1212 0.1305 0.1819 0.3952 0.4312 0.5886 0.6898 0.7999 0.8323 0.9721 1.156; 
    0.1005 0.1121 0.1207 0.1605 0.3556 0.4022 0.5553 0.6673 0.7798 0.8623 0.9521 1.156; 
    0.1123 0.1257 0.1343 0.2079 0.3579 0.4716 0.5459 0.7145 0.8205 0.8901 0.9419 1.136]'; 
    threshold=[0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1]; 
    net=newff(threshold,[32,12],{'tansig','logsig'},'trainscg','learngdm');%新建BP神经网络 
    net.trainParam.epochs=1000;%bp网络训练次数 
    net.trainParam.goal=0.002;%网络训练目标 
    net.trainParam.lr=0.01;%网络学习速率 
    [net,tr]=train(net,P,T);%训练网络 
    P_test=[0.1123 0.1257 0.1343 0.2079 0.3579 0.4716 0.5459 0.7145 0.8205 0.8901 0.9419 1.136 0.2317 0.2936 0]';%网络输入数据 
    Out=sim(net,P_test);%网络仿真 
    X=[0.1119 0.1215 0.1621 0.2161 0.3471 0.4639 0.5555 0.7061 0.8243 0.8923 0.9522 1.129];%实际测得数据 
    t=1:1:12; 
    box off; 
    grid off; 
    plot(t,Out,'b',t,X,'r');%画出二维图形 
    set(gca,'Xtick',0:1:24,'Ytick',0:.1:1.4);%设置坐标 
    title('基于BP网络的设备故障时间序列预测'); 
    xlabel('时间/2小时'); 
    ylabel('加速度/g'); 
    text(1.5,1.2,'预测振动曲线(蓝)'); 
    text(1.5,1.1,'实际测试曲线(红)');

    展开全文
  • 该算法通过在粒子群算法中引入一种新的二进制交叉策略来加快粒子群算法的收敛速度, 通过设置新的惯性权重来改善新算法的全局搜索和局部搜索能力, 并且在粒子搜索路径中引入变系数低通滤波器构成的动量算法来平滑粒子...
  • 动量法在一定程度上能解决梯度下降的问题,如果考虑历史梯度,将会引导参数朝着最优值更快收敛,这就是动量算法的基本思想 vt=γvt−1+ηtgtv_t = \gamma v_{t-1} + \eta_t g_tvt​=γvt−1​+ηt​gt​ xt=xt−1−...

    动量法

    梯度下降存在问题,因为是对整个梯度用学习率做的衰减和增强,所以所有的梯度分量都享受同一个权重学习率,容易造成有些分量衰减的过于缓慢,有些分量震荡的剧烈到最后发散的可能

    动量法在一定程度上能解决梯度下降的问题,如果考虑历史梯度,将会引导参数朝着最优值更快收敛,这就是动量算法的基本思想

    vt=γvt1+ηtgtv_t = \gamma v_{t-1} + \eta_t g_t
    xt=xt1vtx_t = x_{t-1} - v_t

    由指数加权移动平均式子转化为
    vt=γvt1+(1γ)ηt1γgtv_t = \gamma v_{t-1} + (1-\gamma)\frac{\eta_t}{1-\gamma} g_t

    动量法在每个时间步的自变量更新量近似于将最近1/(1−γ)个时间步的普通更新量(即学习率乘以梯度)做了指数加权移动平均后再除以1−γ,所以,在动量法中,自变量在各个方向上的移动幅度不仅取决当前梯度,还取决于过去的各个梯度在各个方向上是否一致
    动量超参数γ满足0≤γ<1, 动量项γ通常设定为0.9, 当γ=0时,动量法等价于小批量随机梯度下降,
    依赖指数加权移动平均使得自变量的更新方向更加一致,从而降低发散的可能

    指数加权移动平均

    yt=γyt1+(1γ)xty_t = \gamma y_{t-1} + (1-\gamma)x_t
    yt=(1γ)xt+γ(1γ)xt1+γ2yt2y_t= (1-\gamma)x_t + \gamma(1-\gamma)x_{t-1} + \gamma^2y_{t-2}

    yt=(1γ)xt+γ(1γ)xt1+....+γn1(1γ)x1+γny0y_t = (1-\gamma) x_t + \gamma (1-\gamma)x_{t-1} + ....+ \gamma^{n-1} (1-\gamma)x_1 + \gamma^n y_0

    γ\gamma=0.9时,yt=0.9yt1+0.1xty_t = 0.9 y_{t-1} + 0.1x_t

    当最原始的y0y_0=0时

    yt=(1γ)(xt+γxt1+γ2xt2+...+γt1x1)y_t = (1-\gamma)(x_t + \gamma x_{t-1} + \gamma^2 x_{t-2} + ... + \gamma^{t-1}x_1)

    可以看出数值的加权系数随时间呈现指数下降
    由于

    limn(11n)n=1e\lim_{n \rightarrow \infty}(1 - \frac{1}{n})^n = \frac{1}{e}

    所以将1/e作为系数临界值,当系数小于1/e时不考虑
    γ\gamma=0.9时,此时0.9101e0.9^{10} \approx \frac{1}{e}可以认为是近10个数的加权平均

    偏差修正,初始y0y_0如果等于0会造成初始的数值都偏小,此时可以用一个惩罚分母

    yt=γyt1+(1γ)xt1γty_t = \frac{\gamma y_{t-1} + (1-\gamma)x_t}{1-\gamma^t}

    当t趋近0时,分母离1最远,此时相当于放大,当t很大时,分母项趋近1和之前式子近似

    展开全文
  • 动量梯度下降算法

    2020-03-09 01:35:03
    上篇文章介绍了指数加权平均,这篇文章介绍在此基础上介绍一下动量梯度下降算法。 所谓动量梯度下降算法,简言之就计算梯度的指数加权平均,然后使用这个梯度来更新权重,下面我们来详细解释这句话。 我们在使用...

    上篇文章介绍了指数加权平均,这篇文章介绍在此基础上介绍一下动量梯度下降算法。

    所谓动量梯度下降算法,简言之就计算梯度的指数加权平均,然后使用这个梯度来更新权重,下面我们来详细解释这句话。

    我们在使用梯度下降算法更新权重时,希望损失函数能减小直到最优值。我们可以在一副等高线图中,画出损失函数随着迭代次数增加而减小的路径,即如下图所示:

    图中红点为最优点,蓝线为损失函数的减小路径,从图中左侧出发,逐渐靠近最优点。不过我们可以发现,这条路径看起来十分曲折,虽然整体趋势是向右的,但在竖直方向有太多波动,这直接造成了两个负面影响:

    1. 增加了梯度下降的次数,增加了训练时间
    2. 无法使用较大的学习率

    如果使用了较大的学习率,可能会出现下图中紫线的情况:

    即虽然增大了向右的步伐,同时也增大了上下的步伐,导致损失函数值反而越来越大,因此为了避免振荡过大,我们只能选择较小的学习率。

    为了使其步伐能在水平方向更大,而在竖直方向更小,可以使用之前提到的指数滑动平均。

    我们说过,运用了指数滑动平均后,vtv_t 相当于粗略计算了前 11β\frac{1}{1 - \beta} 个数据的平均值,如果我们对导数进行指数滑动平均操作,就会有以下结果:

    • 竖直方向的振动几乎消失
    • 水平方向的步伐逐渐加大

    即如下图红线所示

    这正好是我们想看到的结果,为什么会这样呢?下面来分析一下。观察上图中的蓝线,我们发现竖直方向的振动大致可以抵消,即每两次上下方向的振动长度大致相等,因此如果对其去平均值,结果就会很接近 0,这就是“竖直方向的振动几乎消失”的原因,而蓝线水平方向的路径都是向右的,对其取平均值不会使其减小,而是随着已经行进的路径增多而变大,这就是“水平方向的步伐逐渐加大”的原因。综上,得到上图中的红线。

    算法描述如下:

    第 t 次迭代:
    	在当前的 mini-batch 上计算 dW, db
    	v_dW = β * v_dW + (1 - β) * dW
    	v_db = β * v_db + (1 - β) * db
    	W -= α * v_dW, b -= α * v_db
    

    上面的描述中,α\alphaβ\beta 都是需要调整的超参数,β\beta 通常会取 0.9 左右。

    以上就是对动量梯度下降算法的简单介绍,它几乎总是要优于不适用动量的梯度下降算法,不过除此外,还有一些其他的方法也能加速你的训练速度,接下来几篇文章会谈谈 RMSprop 和 Adam 梯度下降算法以及学习率衰减。

    展开全文
  • 基于全局人工鱼群优化算法动量常数模盲均衡算法
  • 语音增强中先验SNR估计的可变动量因子算法
  • 动量因子常数模算法和理论
  • 采用动量梯度下降算法训练 BP 网络 matlab代码
  • 介绍了盲信道均衡恒模算法(CMA)的基本原理,对恒模算法的缺点进行了分析,通过修正恒模算法的迭代公式提出一种动量恒模算法(MCMA)。利用QPSK信号,采用计算机仿真的方法对动量恒模算法与恒模算法进行盲均衡性能比较,...
  • 通过相关数学工具确定了与矿工安全行为状况紧密相关的63条测量指标作为评价因素集合,建立了基于灰色-模糊-改进动量BP算法的矿工安全行为状况的综合评价模型。通过实践应用表明,该方法能对矿工安全行为状态进行较为...
  • 本文针对三轴稳定零动量卫星的特点,设计了利用三正一斜装的四动量轮系统进行卫星角动量控制的算法。通过四动量轮系统控制算法,既完成了卫星角动量和姿态的控制,还实现了控制系统的自备份,提高了系统的可靠性,...
  • 动量项盲源分离算法及其性能优化策略
  • 在训练模型时,会使⽤优化算法不断迭代模型参数以降低模型损失函数的值,本节详细学习常用的优化算法:梯度下降、动量法、AdaGrad算法、RMSProp算法、AdaDelta算法、Adam算法
  • DFE,Odd symmetry error Function blind equalization Algorithm based Decision Feedback Equalizer)基础上,提出了基于奇对称误差函数变动量因子判决反馈动量盲均衡算法(VMFMOFA-DFE,Variable Momentum Factor...
  • LM 神经网络MATLAB算法 LM 神经网络MATLAB算法 LM 神经网络MATLAB算法 LM 神经网络MATLAB算法 LM 神经网络MATLAB算法
  • 采用动量梯度下降算法训练 BP 网络。 训练样本定义如下: 输入矢量为 p =[-1 -2 3 1 -1 1 5 -3] 目标矢量为 t = [-1 -1 1 1] 有注释
  • 此时的梯度不再只是我现在的数据的梯度,而是有一定权重的之前的梯度,就我个人认为,就像是把原本的梯度压缩一点,并且补上一个之前就已经存在的“动量”。 举个例子,如果你站在一个地方不动,让你立刻向后转...
  • 动量-自适应学习调整算法(BP改进算法)应用实例。共享给大家,希望有用。
  • 动量梯度下降算法训练BP网络 使用的主要函数如下: NEWFF——生成一个新的前向神经网络 TRAIN——对BP神经网络进行训练 SIM——对BP神经网络进行仿真
  • 深度学习中的动量

    千次阅读 2018-06-08 16:35:23
    动量算法积累了之前梯度指数级衰减的移动平均,并且继续沿该方向移动。 动量的效果如下图所示。 动量的主要目的是解决两个问题: Hessian 矩阵的病态条件和随机梯度的方差。我们通过此图说明动量如何克服这两...
  • 算法交易 基于动量的即日交易策略的基本算法。 该脚本使用Alpaca提供的API。
  • 动量交易 使用动量的非常简单的交易算法
  • 动量算法积累了之前梯度指数级衰减的移动平均,并且继续沿该方向移动。从形式上看,动量算法引入了变量v充当速度角色------它代表参数在参数空间移动的方向和速率。速度被设为负梯度的指数衰减平均。名称动量来自...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 848
精华内容 339
关键字:

动量算法