精华内容
下载资源
问答
  • 下降率
    千次阅读
    2021-07-30 08:04:44

    同比增长百分比=(当年的指标值-去年同期的值)÷去年同期的值*100%

    某个指标的同期比=(当年的某个指标的值-去年同期这个指标的值)/去年同期这个指标的值

    即:同比增长率=(当年的指标值-去年同期的值)÷去年同期的值*100%

    一、市场价格分析计算公式

    (一)当期环比增长(下降)率计算公式

    根据批发市场价格分析需要,环比分为日环比、周环比、月环比和年环比。

    当期环比增长(下降)率(%)=[(当期价格/上期价格)-1]*100%

    说明:

    (1)如果计算值为正值(+),则称增长率;如果计算值为负值(-),则称下降率。

    (2)如果当期指当日、当周、当月和当年,则上期相应指昨日、上周、上月和上年。

    (二)当期同比增长(下降)率计算公式

    当期同比增长(下降)率(%)=[(当期价格/上年年同期价格)-1]*100%

    说明:

    (1)如果计算值为正值(+),则称增长率;如果计算值为负值(-),则称下降率。

    (2)如果当期指当日、当周和当月,则上年同期相应指上年同日、上年同周和上年同月。

    同比增长率与增长率的区别

    说明:

    (1)同比增长率是含有增长率的意思,是另一种方式的增长率。

    (2)同比增长率计算时,有特定的时间限制,不像增长率那样,范围大,定义宽泛,而同比增长率,一般是指和去年同期相比较的增长率。

    扩展资料:

    同比增长分类:

    同比发展速度主要是为了消除季节变动的影响,用以说明当期发展水平与Last year同期发展水平对比而达到的相对发展速度。如,当期2月比Last year2月,当期6月比Last year6月等。

    其计算公式为:同比发展速度=(当期发展水平/Last year同期发展水平-1)*100% 在实际工作中,经常使用这个指标,如某年、某季、某月与上年同期对比计算的发展速度,就是同比发展速度。

    1、环比

    环比分为日环比、周环比、月环比和年环比。

    环比发展速度是以报告期水平与其前一期水平对比(相邻期间的比较),所得到的动态相对数。表明现象逐期的发展变动程度。如计算一年内各月与前一个月对比,即2月比1月,3月比2月,4月比3月 ……12月比11月,说明逐月的发展程度。

    2、定基比

    定基比发展速度也叫总速度,是报告期水平与某一固定时期水平之比,表明这种现象在较长时期内总的发展速度。如"九五"期间各年水平都以1995年水平为基期进行对比,一年内各月水平均以上年12月水平为基期进行对比,就是定基发展速度。

    更多相关内容
  • 一元二次方程应用题增长率下降率PPT学习教案.pptx
  • 实际问题与一元二次方程增长率下降率PPT学习教案.pptx
  • 一元二次方程应用题增长率下降率精讲PPT学习教案.pptx
  • 本文研究了自1970年代初以来在韩国实施的计划生育政策,该政策导致生育Swift下降,目前是世界上生育最低的国家之一。 基于对来自韩国各大学的250多名本科生的访谈,并结合官方的人口统计数据,研究了总生育...
  • 梯度下降算法公式推导

    千次阅读 2020-03-03 15:36:48
    梯度下降数学解释: 场景假设 梯度下降法的基本思想可以类比为一个下山的过程。 假设这样一个场景:一个人被困在山上,需要从山上下来(找到山的最低点)。但此时山上的浓雾很大,导致可视度很低;因此,下山的路径...

    梯度下降数学解释:在这里插入图片描述

    • 场景假设

    梯度下降法的基本思想可以类比为一个下山的过程。
    假设这样一个场景:一个人被困在山上,需要从山上下来(找到山的最低点)。但此时山上的浓雾很大,导致可视度很低;因此,下山的路径就无法确定,必须利用自己周围的信息一步一步地找到下山的路。这个时候,便可利用梯度下降算法来帮助自己下山。怎么做呢,首先以他当前的所处的位置为基准,寻找这个位置最陡峭的地方,然后朝着下降方向走一步,然后又继续以当前位置为基准,再找最陡峭的地方,再走直到最后到达最低处;同理上山也是如此,只是这时候就变成梯度上升算法了

    • 泰勒展开式
      在这里插入图片描述
      泰勒展开式的目的是拟合,将上图的曲线拟合成直线,虽然存在误差,但只要不影响实际情况,我们就可以直接在这条直线下进行讨论(更高维度也是如此)
      于是我们有直线方程
    f(x)-f(x₀)≈(x-x₀)•f'(x₀)
    

    PS:场景中说的是下山,但那是在空间坐标系下讨论,这里为了方便,只在平面坐标系下做讨论,但是不管维度是多少,原理是一样的。

    • 梯度下降
      梯度:函数在给定点上升最快的方向,其本质就是导数(斜率)

    首先,我们有一个可微分(可微<=>可导)的函数。这个函数就代表着一座山。我们的目标就是找到这个函数的最小值(此时导数为0),也就是山底。根据之前的场景假设,最快的下山的方式就是找到当前位置最陡峭的方向,然后沿着此方向向下走(梯度的反方向),就能让函数值下降的最快!因为梯度的方向就是函数之变化最快的方向
    所以,我们重复利用这个方法,反复求取梯度,最后就能到达局部的最小值,这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向,也就是场景中测量方向的手段。

    • 梯度下降公式推导
      θ=[x] θ₀=[x0]
      解释:因为这里讨论的是一维(直线需要在二维下进行讨论,不然没有意义),所以 [] 内只有一个变量;如果是三维那么 [] 里就应该有三个变量[a,b,c],以此类推,最终我们把这个集合赋值给θ,方便日后讨论。
      此时我们有
    f(θ)-f(θ₀)≈(θ-θ₀)•▽f(θ₀)
    

    因为这是一个可微分方程,所以(θ-θ₀)是一个微小向量,我们知道标量*单位向量=向量,所以令:

    (θ-θ₀)=ŋν(其中  ŋ是标量,ν是单位向量)
    注意:(θ-θ₀)不能太大,否则线性近似就不够准确
    

    重点,局部下降的目的是希望每次θ更新 -> f(θ)↓ ,重复这个过程,直到▽f(θ₀)=0。所以:

    f(θ)-f(θ₀) ≈ (θ-θ₀)•▽f(θ₀) = ŋν•▽f(θ₀) < 0
    因为ŋ是标量,且一般设定为正数,所以可以忽略,则不等式变成:
    ν•▽f(θ₀) < 0     其中ν是需要我们求解的
    那么,这个不等式在表达什么
    我们知道▽f(θ₀)是当前位置的梯度方向,
    也就是说当ν的方向是梯度的反方向时,
    不等式能最大程度的小,也就保证了ν的方向是局部下降最快的方向
    

    在这里插入图片描述
    将这个公式跟开头的公式对比,事情到这里就结束了,我们终于获得了梯度下降的公式,有没有发现公式推导出来后,f(θ)-f(θ₀)不见了,因为只要满足梯度下降公式,f(θ)就会一直下降(前提:(θ-θ₀)不太大),而我们只需要在图像上观察f(θ)的值就好了
    在这里插入图片描述

    • 单变量示例
      在这里插入图片描述
    • 神经网络
      梯度下降公式在神经网络中用于对(w,b)的更新,是的,你只需要将θ替换成 w 或 b ,▽J(θ) 替换成 损失函数对 w 或 b 的偏导数,其中 α 是 学习率(人为设置),最后你就可以获得局部最优模型了。

    PS:后向传播算法的目的在于快速计算神经网络中各层参数的梯度,它与梯度下降算法是包含关系。

    感谢启发:https://blog.csdn.net/weixin_42278173/article/details/81511646?utm_source=app

    https://blog.csdn.net/qq_41800366/article/details/86583789?utm_source=app

    展开全文
  • 可进行DC1D 的最速下降反演,计算出视电阻,画出曲线图
  • 梯度下降、学习

    千次阅读 2022-02-26 14:45:44
    三,学习 一,问题实例 求函数 func(X, Y)=X*X + Y*Y*2的最小值。 double f(double x, double y) { return x * x + y * y* 2; } 虽然最小值显然是f(0,0)=0,但是同样可以用梯度下降算法来求, 而对于一些...

    目录

    一,问题实例

    二,梯度下降 Gradient Descent

    三,学习率

    四,随机梯度下降 SGD

    五,自适应学习率

    AdaGrad(自适应梯度下降)

    Momentum(带动量的梯度下降)

    RMSProp(Root Mean Square Prop)

    Adam(Adaptive Moment Estimation)


    一,问题实例

    求函数 func(X, Y)=X*X + Y*Y*2的最小值。

    double f(double x, double y)
    {
    	return x * x + y * y* 2;
    }

    虽然最小值显然是f(0,0)=0,但是同样可以用梯度下降算法来求,

    而对于一些复杂的函数就很难求出最小值,只能用梯度下降算法求近似局部最小值了。

    二,梯度下降 Gradient Descent

    代码:

    int main()
    {
    	double x = 10, y = 10, eta = 0.1, d = 0.01;
    	for (int i = 0; i < 20; i++) {
    		double dfx = (f(x + d, y) - f(x, y)) / d;
    		double dfy = (f(x, y + d) - f(x, y)) / d;
    		x -= eta * dfx;
    		y -= eta * dfy;
    		cout << x << " " << y << " " << f(x, y) << endl;
    	}
    	return 0;
    }

    输出:

    7.999 5.998 135.936
    6.3982 3.5968 66.8109
    5.11756 2.15608 35.4868
    4.09305 1.29165 20.0898
    3.27344 0.772989 11.9104
    2.61775 0.461793 7.27912
    2.0932 0.275076 4.53282
    1.67356 0.163046 2.85397
    1.33785 0.0958273 1.8082
    1.06928 0.0554964 1.14952
    0.854423 0.0312978 0.731998
    0.682538 0.0167787 0.466422
    0.545031 0.00806722 0.297189
    0.435025 0.00284033 0.189262
    0.34702 -0.000295799 0.120423
    0.276616 -0.00217748 0.0765257
    0.220293 -0.00330649 0.0485507
    0.175234 -0.00398389 0.0307387
    0.139187 -0.00439034 0.0194116
    0.11035 -0.0046342 0.01222

    大概需要20-50次迭代

    三,学习率

    上面的η (eta)就是学习率。

    如果学习率调为0.01,大概需要200次迭代,因为函数在(0,0)附近很平缓,所以需要的迭代次数很多。

    如果学习率调为0.3,只需要10次迭代:

    3.997 -2.006 24.0241
    1.5958 0.3952 2.85894
    0.63532 -0.08504 0.418095
    0.251128 0.011008 0.0633076
    0.0974512 -0.0082016 0.00963127
    0.0359805 -0.00435968 0.00133261
    0.0113922 -0.00512806 0.000182376
    0.00155688 -0.00497439 5.19129e-05
    -0.00237725 -0.00500512 5.57538e-05
    -0.0039509 -0.00499898 6.55891e-05

    如果学习率继续调大,一旦超过某个值(这个例子中大概是0.5)就会出现极端恶劣的情况:

    左右徘徊,甚至直接变成发散的,没能收敛。

    所以,对于梯度下降算法,如何选择学习率是个重要且困难的事情。

    而且,学习率不能是一个值通用所有特征,不同的参数需要不同的学习率。

    四,随机梯度下降 SGD

    SGD算法是每次从样本中随机抽出一组,训练后按梯度更新一次。

    随机梯度下降算法通常还有三种不同的应用方式,它们分别是SGD、Batch-SGD、Mini-Batch SGD
    a.SGD是最基本的随机梯度下降,它是指每次参数更新只使用一个样本,这样可能导致更新较慢;
    b.Batch-SGD是批随机梯度下降,它是指每次参数更新使用所有样本,即把所有样本都代入计算一遍,然后取它们的参数更新均值,来对参数进行一次性更新,这种更新方式较为粗糙;
    c.Mini-Batch-SGD是小批量随机梯度下降,它是指每次参数更新使用一小批样本。

    五,自适应学习率

    无论是梯度下降还是随机梯度下降,都面临一个问题,学习率如果太小需要的迭代次数太多,如果太大可能左右徘徊很难接近局部最优解。

    AdaGrad(自适应梯度下降)

    ada就是自适应的意思。

    看到不同的博主有不同的讲解,第一种:

    在梯度下降的基础上,新增一个变量记录每次迭代的梯度的平方和dsum。

    每次进行梯度更新时,梯度除以sqrt(dsum)即可。

    int main()
    {
    	double x = 10, y = 10, eta = 10, d = 0.01;
    	double dsum = 0;
    	for (int i = 0; i < 20; i++) {
    		double dfx = (f(x + d, y) - f(x, y)) / d;
    		double dfy = (f(x, y + d) - f(x, y)) / d;
    		dsum += dfx * dfx + dfy * dfy;
    		x -= eta * dfx / sqrt(dsum);
    		y -= eta * dfy / sqrt(dsum);
    		cout << x << " " << y << " " << f(x, y) << endl;
    	}
    	return 0;
    }

    如果设定的初始学习率是1,那还是有学习率太小的问题。

    但是如果学习率大一些,从10到1000都可以,在20次迭代内都可以到很好的结果。

    以上面的代码(10)为例:

    5.52786 1.05573 32.7864
    3.13717 0.139068 9.8805
    1.79191 0.0157085 3.21145
    1.02487 -0.00197106 1.05037
    0.585676 -0.00455448 0.343058
    0.333859 -0.00493435 0.111511
    0.189412 -0.00499032 0.0359266
    0.106542 -0.00499857 0.0114011
    0.0589963 -0.00499979 0.00353056
    0.0317176 -0.00499997 0.001056
    0.0160666 -0.005 0.000308134
    0.00708685 -0.005 0.000100223
    0.00193479 -0.005 5.37434e-05
    -0.00102119 -0.005 5.10428e-05
    -0.00271718 -0.005 5.7383e-05
    -0.00369024 -0.005 6.36179e-05
    -0.00424853 -0.005 6.805e-05
    -0.00456885 -0.005 7.08744e-05
    -0.00475263 -0.005 7.25875e-05
    -0.00485807 -0.005 7.36009e-05

    可以看出来收敛非常快。

    第二种:

    各个维度单独算梯度的平方和dsum*,每次进行梯度更新时,各个维度的梯度除以各自的sqrt(dsum*)

    int main()
    {
    	double x = 10, y = 10, eta = 1000, d = 0.01;
    	double dsumx = 0, dsumy = 0;
    	for (int i = 0; i < 20; i++) {
    		double dfx = (f(x + d, y) - f(x, y)) / d;
    		double dfy = (f(x, y + d) - f(x, y)) / d;
    		dsumx = dsumx + dfx * dfx;
    		dsumy = dsumy + dfy * dfy;
    		x -= eta * dfx / sqrt(dsumx);
    		y -= eta * dfy / sqrt(dsumy);
    		cout << x << " " << y << " " << f(x, y) << endl;
    	}
    	return 0;
    }

    在本文的例子中,这种方法效果更好。

    Momentum(带动量的梯度下降)

    在梯度下降的基础上,新增一个变量把每次迭代的梯度累积求和,同时采用衰减率对累积的和进行衰减。

    int main()
    {
    	double x = 10, y = 10, eta = 1, d = 0.01;
    	double dsumx = 0, dsumy = 0, gamma = 0.9;
    	for (int i = 0; i < 200; i++) {
    		double dfx = (f(x + d, y) - f(x, y)) / d;
    		double dfy = (f(x, y + d) - f(x, y)) / d;
    		dsumx = dsumx * gamma + dfx * (1 - gamma);
    		dsumy = dsumy * gamma + dfy * (1 - gamma);
    		x -= eta * dsumx;
    		y -= eta * dsumy;
    		cout << x << " " << y << " " << f(x, y) << endl;
    	}
    	return 0;
    }

    当学习率较大时,还是会发生左右徘徊甚至不能收敛的情况。

    RMSProp(Root Mean Square Prop)

    RMSProp是像AdaGrad一样计算梯度的累积平方和,又像Momentum一样做衰减。

    int main()
    {
    	double x = 10, y = 10, eta = 1000, d = 0.01;
    	double dsumx = 0, dsumy = 0, gamma = 0.999;
    	for (int i = 0; i < 50; i++) {
    		double dfx = (f(x + d, y) - f(x, y)) / d;
    		double dfy = (f(x, y + d) - f(x, y)) / d;
    		dsumx = dsumx * gamma + dfx * dfx * (1 - gamma);
    		dsumy = dsumy * gamma + dfy * dfy * (1 - gamma);
    		x -= eta * dfx / sqrt(dsumx);
    		y -= eta * dfy / sqrt(dsumy);
    		cout << x << " " << y << " " << f(x, y) << endl;
    	}
    	return 0;
    }

    RMSProp能适应的初始学习率的范围比AdaGrad和Momentum要广。

    Adam(Adaptive Moment Estimation)

    Adam算法是将Momentum算法和RMSProp算法结合起来。

    int main()
    {
    	double x = 10, y = 10, eta = 1, d = 0.01;
    	double dsumx1 = 0, dsumy1 = 0, gamma1 = 0.9, gt1 = 1;
    	double dsumx2 = 0, dsumy2 = 0, gamma2 = 0.999, gt2 = 1;
    	for (int i = 0; i < 200; i++) {
    		double dfx = (f(x + d, y) - f(x, y)) / d;
    		double dfy = (f(x, y + d) - f(x, y)) / d;
    		dsumx1 = dsumx1 * gamma1 + dfx * (1 - gamma1);
    		dsumy1 = dsumy1 * gamma1 + dfy * (1 - gamma1);
    		dsumx2 = dsumx2 * gamma2 + dfx * dfx * (1 - gamma2);
    		dsumy2 = dsumy2 * gamma2 + dfy * dfy * (1 - gamma2);
    		gt1 *= gamma1, gt2 *= gamma2;
    		x -= eta * dsumx1 / (1 - gt1) / sqrt(dsumx2 / (1 - gt2));
    		y -= eta * dsumy1 / (1 - gt1) / sqrt(dsumy2 / (1 - gt2));
    		cout << x << " " << y << " " << f(x, y) << endl;
    	}
    	return 0;
    }

    Adam算法能适应的初始学习率的范围也很广。

    展开全文
  • 亚洲半导体代工产能利用率下降.pdf
  • pytorch学习率下降策略

    千次阅读 2021-01-23 00:25:30
    阶段离散下降调整策略 连续下降调整策略 周期性调整策略 自适应调整策略 自定义调整策略

    阶段离散下降调整策略:

    首先“阶段离散”下降调整这个词不是个专有名词,它只是一个形容。
    符合这种调整策略的方法,一般是step,step学习率下降策略是最为常用的一种,表现为,在初始学习率的基础上,每到一个阶段学习率将以gamma的指数倍下降,通常情况下gamma为0.1。显然随着训练迭代学习率会变的越来越小,但是不管怎么变,这个数都在趋近于0,永远不会到0.
    效果类似于:

    # lr = 0.05     if epoch < 30        
    # lr = 0.005    if 30 <= epoch < 60        
    # lr = 0.0005   if 60 <= epoch < 90
    

    pytorch中定义了两种方法做这件事,分别是等间隔调整学习率(Step),按需调整学习率(MultiStep),实际上它们的效果是一致的

    等间隔下降调整策略

    等间隔的调整是在定义间隔是什么,即step_size,当训练的epoch满足step_size时,学习率就调整一次,last_epoch对step_size取整。

    class StepLR(_LRScheduler):
        def __init__(self, optimizer, step_size, gamma=0.1, last_epoch=-1, verbose=False):
            self.step_size = step_size
            self.gamma = gamma
            super(StepLR, self).__init__(optimizer, last_epoch, verbose)
    
        def get_lr(self):
            if not self._get_lr_called_within_step:
                warnings.warn("To get the last learning rate computed by the scheduler, "
                              "please use `get_last_lr()`.", UserWarning)
    
            if (self.last_epoch == 0) or (self.last_epoch % self.step_size != 0):
                return [group['lr'] for group in self.optimizer.param_groups]
            return [group['lr'] * self.gamma
                    for group in self.optimizer.param_groups]
    
        def _get_closed_form_lr(self):
            return [base_lr * self.gamma ** (self.last_epoch // self.step_size)
                    for base_lr in self.base_lrs]
    

    按需下降调整策略

    按需调整学习率是在直接定义目标是什么,训练中,当前的epoch达到目标的时候,学习率调整,milestones就是定义的一系列目标,当last_epoch不在milestones中时,学习率保持不变,相反的,则gamma的指数倍调整,当然gamma是个小数,所以学习率越来越小。

    class MultiStepLR(_LRScheduler):
        def __init__(self, optimizer, milestones, gamma=0.1, last_epoch=-1, verbose=False):
            self.milestones = Counter(milestones)
            self.gamma = gamma
            super(MultiStepLR, self).__init__(optimizer, last_epoch, verbose)
    
        def get_lr(self):
            if not self._get_lr_called_within_step:
                warnings.warn("To get the last learning rate computed by the scheduler, "
                              "please use `get_last_lr()`.", UserWarning)
    
            if self.last_epoch not in self.milestones:
                return [group['lr'] for group in self.optimizer.param_groups]
            return [group['lr'] * self.gamma ** self.milestones[self.last_epoch]
                    for group in self.optimizer.param_groups]
    
        def _get_closed_form_lr(self):
            milestones = list(sorted(self.milestones.elements()))
            return [base_lr * self.gamma ** bisect_right(milestones, self.last_epoch)
                    for base_lr in self.base_lrs]
    

    连续下降调整策略:

    “连续”下降这个词不是个专有名词,它只是一个形容。
    符合这种下降策略的方法有,线性下降策略,cos下降策略,指数衰减下降策略,前两种在Pytorch没有实现。它们的表现是,随着训练迭代,学习率的变化时逐步减少的,不会出现step方式的阶段下降,并且到迭代结束时,学习率为0,而不是一个非常小的值。

    线性下降调整策略

    线性下降策略非常好理解,就是学习率与迭代周期是线性关系,初始学习率和周期确定了,下降的斜率也就确定了。

     lr = args.lr * (1 - (current_iter - warmup_iter) / (max_iter - warmup_iter))
    

    cos下降调整策略

    cos下降策略到最后一步迭代的最后时,系数刚好为cos(pi/2),即为0,开始迭代时系数为为cos(0),即为1,中间遵循余弦曲线的方式下降。

    lr = args.lr * (1 + cos(pi * (current_iter - warmup_iter) / (max_iter - warmup_iter))) / 2
    

    指数衰减调整策略

    指数衰减调整策略的计算方式和step是一样的,都是当前的epoch作为指数, gamma作为底数,即gamma**epoch。不同之处在于,指数衰减下降策略是每个epoch都会做的,可以看做在epoch间连续,其次,更为重要的是,选择指数衰减下降策略时gamma不能选择为0.1,否则几个epoch过去,学习率就非常趋近于0了,所以一般是0.9。

    class ExponentialLR(_LRScheduler):
        def __init__(self, optimizer, gamma, last_epoch=-1, verbose=False):
            self.gamma = gamma
            super(ExponentialLR, self).__init__(optimizer, last_epoch, verbose)
    
        def get_lr(self):
            if not self._get_lr_called_within_step:
                warnings.warn("To get the last learning rate computed by the scheduler, "
                              "please use `get_last_lr()`.", UserWarning)
    
            if self.last_epoch == 0:
                return self.base_lrs
            return [group['lr'] * self.gamma
                    for group in self.optimizer.param_groups]
    
        def _get_closed_form_lr(self):
            return [base_lr * self.gamma ** self.last_epoch
                    for base_lr in self.base_lrs]
    
    

    周期性调整策略:

    周期性调整的特点是不再从始至终单调的下降,而是会出现上升的情况。

    余弦退火调整策略

    以余弦函数为周期,并在每个周期最大值时重新设置学习率。以初始学习率为最大学习率,以 2∗Tmax 为周期,在一个周期内先下降,后上升。

    class CosineAnnealingLR(_LRScheduler):
    	def __init__(self, optimizer, T_max, eta_min=0, last_epoch=-1, verbose=False):
            self.T_max = T_max
            self.eta_min = eta_min
            super(CosineAnnealingLR, self).__init__(optimizer, last_epoch, verbose)
    
        def get_lr(self):
            if not self._get_lr_called_within_step:
                warnings.warn("To get the last learning rate computed by the scheduler, "
                              "please use `get_last_lr()`.", UserWarning)
    
            if self.last_epoch == 0:
                return self.base_lrs
            elif (self.last_epoch - 1 - self.T_max) % (2 * self.T_max) == 0:
                return [group['lr'] + (base_lr - self.eta_min) *
                        (1 - math.cos(math.pi / self.T_max)) / 2
                        for base_lr, group in
                        zip(self.base_lrs, self.optimizer.param_groups)]
            return [(1 + math.cos(math.pi * self.last_epoch / self.T_max)) /
                    (1 + math.cos(math.pi * (self.last_epoch - 1) / self.T_max)) *
                    (group['lr'] - self.eta_min) + self.eta_min
                    for group in self.optimizer.param_groups]
    
        def _get_closed_form_lr(self):
            return [self.eta_min + (base_lr - self.eta_min) *
                    (1 + math.cos(math.pi * self.last_epoch / self.T_max)) / 2
                    for base_lr in self.base_lrs]
    

    循环调整策略

    在这里插入图片描述
    循环调整顾名思义,就是以一个周期和一个上下界反复调整学习率,这个方法出自《Cyclical Learning Rates for Training Neural Networks》,这么做的理由是要避免模型进入局部最优的状态,也就是鞍点(saddle points)。而循环学习率方法使得一个范围(base_lr ~ max_lr)里的学习率在训练中都能得到运用,也就是说,在下边界和上边界中,那个最佳的学习率将会在训练中有机会运用到训练中。

    torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr, max_lr, 
    							step_size_up=2000,
    							step_size_down=None, mode='triangular', gamma=1.0, scale_fn=None, 
    							scale_mode='cycle', cycle_momentum=True, base_momentum=0.8,
    							max_momentum=0.9, last_epoch=-1)
    
    

    自适应调整策略:

    顾名思义,之前的调整策略都是在出初始学习率和训练周期固定好之后就确定下来的规则,不会根据训练状态的变化而变化,自适应的调整则不同,依训练状况伺机调整,该法通过监测某一指标的变化情况,当该指标不再怎么变化的时候,就是调整学习率的时机。

    ReduceLROnPlateau

    ReduceLROnPlateau的名字很直观,就是在持续平稳的状态时下降学习率,当某指标不再变化(下降或升高),则调整学习率,这是非常实用的学习率调整策略。例如,当验证集的 loss 不再下降时,进行学习率调整;或者监测验证集的 accuracy,当accuracy 不再上升时,则调整学习率。

    class ReduceLROnPlateau(object):
        def __init__(self, optimizer, mode='min', factor=0.1, patience=10,
                     threshold=1e-4, threshold_mode='rel', cooldown=0,
                     min_lr=0, eps=1e-8, verbose=False):
    
            if factor >= 1.0:
                raise ValueError('Factor should be < 1.0.')
            self.factor = factor
    
            # Attach optimizer
            if not isinstance(optimizer, Optimizer):
                raise TypeError('{} is not an Optimizer'.format(
                    type(optimizer).__name__))
            self.optimizer = optimizer
    
            if isinstance(min_lr, list) or isinstance(min_lr, tuple):
                if len(min_lr) != len(optimizer.param_groups):
                    raise ValueError("expected {} min_lrs, got {}".format(
                        len(optimizer.param_groups), len(min_lr)))
                self.min_lrs = list(min_lr)
            else:
                self.min_lrs = [min_lr] * len(optimizer.param_groups)
    
            self.patience = patience
            self.verbose = verbose
            self.cooldown = cooldown
            self.cooldown_counter = 0
            self.mode = mode
            self.threshold = threshold
            self.threshold_mode = threshold_mode
            self.best = None
            self.num_bad_epochs = None
            self.mode_worse = None  # the worse value for the chosen mode
            self.eps = eps
            self.last_epoch = 0
            self._init_is_better(mode=mode, threshold=threshold,
                                 threshold_mode=threshold_mode)
            self._reset()
    
        def _reset(self):
            """Resets num_bad_epochs counter and cooldown counter."""
            self.best = self.mode_worse
            self.cooldown_counter = 0
            self.num_bad_epochs = 0
    
        def step(self, metrics, epoch=None):
            # convert `metrics` to float, in case it's a zero-dim Tensor
            current = float(metrics)
            if epoch is None:
                epoch = self.last_epoch + 1
            else:
                warnings.warn(EPOCH_DEPRECATION_WARNING, UserWarning)
            self.last_epoch = epoch
    
            if self.is_better(current, self.best):
                self.best = current
                self.num_bad_epochs = 0
            else:
                self.num_bad_epochs += 1
    
            if self.in_cooldown:
                self.cooldown_counter -= 1
                self.num_bad_epochs = 0  # ignore any bad epochs in cooldown
    
            if self.num_bad_epochs > self.patience:
                self._reduce_lr(epoch)
                self.cooldown_counter = self.cooldown
                self.num_bad_epochs = 0
    
            self._last_lr = [group['lr'] for group in self.optimizer.param_groups]
    
        def _reduce_lr(self, epoch):
            for i, param_group in enumerate(self.optimizer.param_groups):
                old_lr = float(param_group['lr'])
                new_lr = max(old_lr * self.factor, self.min_lrs[i])
                if old_lr - new_lr > self.eps:
                    param_group['lr'] = new_lr
                    if self.verbose:
                        print('Epoch {:5d}: reducing learning rate'
                              ' of group {} to {:.4e}.'.format(epoch, i, new_lr))
    
        @property
        def in_cooldown(self):
            return self.cooldown_counter > 0
    
        def is_better(self, a, best):
            if self.mode == 'min' and self.threshold_mode == 'rel':
                rel_epsilon = 1. - self.threshold
                return a < best * rel_epsilon
    
            elif self.mode == 'min' and self.threshold_mode == 'abs':
                return a < best - self.threshold
    
            elif self.mode == 'max' and self.threshold_mode == 'rel':
                rel_epsilon = self.threshold + 1.
                return a > best * rel_epsilon
    
            else:  # mode == 'max' and epsilon_mode == 'abs':
                return a > best + self.threshold
    
        def _init_is_better(self, mode, threshold, threshold_mode):
            if mode not in {'min', 'max'}:
                raise ValueError('mode ' + mode + ' is unknown!')
            if threshold_mode not in {'rel', 'abs'}:
                raise ValueError('threshold mode ' + threshold_mode + ' is unknown!')
    
            if mode == 'min':
                self.mode_worse = inf
            else:  # mode == 'max':
                self.mode_worse = -inf
    
            self.mode = mode
            self.threshold = threshold
            self.threshold_mode = threshold_mode
    
        def state_dict(self):
            return {key: value for key, value in self.__dict__.items() if key != 'optimizer'}
    
        def load_state_dict(self, state_dict):
            self.__dict__.update(state_dict)
            self._init_is_better(mode=self.mode, threshold=self.threshold, threshold_mode=self.threshold_mode)
    

    自定义调整策略:

    LambdaLR

    LambdaLR可以为不同参数组设定不同学习率调整策略。

    torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1)
    

    与其他调整规则的区别在于,optimizer和lr_lambda可以是list,对应之后,相应的参数就会根据对应规则调整

    展开全文
  • 神经网络基础-梯度下降和BP算法

    万次阅读 多人点赞 2018-07-21 21:31:51
    在吴恩达老师的课程中,给出了两幅动图来讲解更新对梯度下降的影响: 当梯度下降很小或合适时候,我们会得到如下的过程,模型最终会走向最优解。 当我们的更新设置过高时,我们的步长会让我们不得不在...
  • 钢铁行业周报:高炉开工上升,社会库存下降,钢材淡季需求显韧性.pdf
  • python计算公司销售额的同比增长

    万次阅读 2018-11-10 11:32:40
    同比、环比一直在很多场合中广泛地被使用到,今天是基于一个小数据集来计算一下销售额的同比增长,对于同比和环比的了解之前主要是来源于业务方面的需求,这里为了更加准确定义同比,贴上百度百科的定义如下: ...
  • 钢铁行业周报:库存继续下降,开工继续上升
  • 房地产行业周报:销售环比下降,土地溢价上升
  • 地产行业周报:成交环比下降,去化延续回落
  • 钢铁行业周报:高炉产能利用连续6周环比下降
  • 钢铁行业周报:高炉开工继续下降,关注板块反弹行情
  • 钢铁行业周报:高炉开工略有下降,钢价小幅反弹
  • 银行理财周报:理财收益环比下降,非净值型产品发行占比下降.pdf
  • 梯度下降学习的设定策略

    万次阅读 多人点赞 2019-04-23 14:39:38
    本文转载自卢明冬的博客-梯度下降学习的设定策略 1.学习的重要性 1)学习设置太小,需要花费过多的时间来收敛 2)学习设置较大,在最小值附近震荡却无法收敛到最小值 3)进入局部极值点就收敛,没有真正找到...
  • BP神经网络模型及梯度下降

    千次阅读 2018-08-27 15:38:02
    BP神经网络模型及梯度下降法 BP(Back Propagation)网络是1985年由Rumelhart和McCelland为首的科学家小组提出,是一种按误差逆传播算法训练的多层前馈网络,是目前应用最广泛的神经网络模型之一。 BP网络能...
  • 梯度下降学习的影响

    千次阅读 2021-02-23 02:11:25
    梯度下降-学习的影响 调试梯度下降。 绘制一个在x轴上具有迭代次数的图。 现在在梯度下降的迭代次数上绘制成本函数J(θ)。 如果J(θ)增大,则可能需要减小α。 自动收敛测试。 如果在一次迭代中J(θ)的减小...
  • 针对原始的样本(1,2) 针对线性回归的函数 y=kx 对应的损失函数是 y=2kx^2, 那我们的方向就是希望最小化这个损失函数,得到最终的k值,然后再代入到 ...方法二:采用梯度下降与学习的方法去求得最后的k值...
  • 众所周知,precision-recall曲线通常呈下降趋势,也即使用同一检索方法对不同检索用例进行检索,若检索结果的准确越高,召回总会反而越低。本人对这一现象表示好奇,一直想搞明白其中的道理,也在网上查过相关...
  • 4)自适应学习 自适应学习从某种程度上讲也算是动态调整学习的范畴,不过更偏向于通过某种算法来根据实时情况计算出最优学习,而不是人为固定一个简单策略让梯度下降按部就班地实行。 3.学习的设定策略 ...
  • 2019年18周地产周报:楼市销售平稳,土地溢价有所下降
  • 图解深度学习-梯度下降学习可视化梯度下降学习问题 梯度下降学习问题 用最简单的SGD做实验,讨论学习问题。 学习如果太小,则会下降很慢,需要很多次迭代,如果太大,就会出现发散,具体可以动手调试,也...
  • 钢铁行业行业周度报告:高炉开工续升,库存下降减缓
  • 钢铁行业周报:库存下降加速,开工继续上升,钢价将维持震荡

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 323,720
精华内容 129,488
关键字:

下降率