# tensorflow 中的学习率衰减

c u r r e n t _ l r = d e c a y _ f u n ( l e a r n i n g _ r a t e , g l o b a l _ s t e p , θ ) current_lr = decay_fun(learning_rate, global_step, \theta)c u r r e n t _l r =d e c a y _f u n (l e a r n i n g _r a t e ,g l o b a l _s t e p ,θ)

### 1. exponential_decay(指数衰减)

tf.train.exponential_decay(
learning_rate,   # 初始学习率
global_step,
decay_steps,     # 指数函数的指数增长快慢
decay_rate,      # 衰减率系数（指数函数的底数）
staircase=False, # 是否是阶梯型衰减，默认是 False
name=None
)


learning_rate 为初始值，学习率随 global_step 的增长呈指数下降，下降速度由 decay_rate（底数）和 decay_steps（决定指数增长速度）决定。公式：

c u r r e n t _ l r = l e a r n i n g _ r a t e ∗ p o w ( d e c a y _ r a t e , g l o b a l _ s t e p d e c a y _ s t e p s ) current_lr = learning_rate * pow(decay_rate, \frac{global_step}{decay_steps})c u r r e n t _l r =l e a r n i n g _r a t e ∗p o w (d e c a y _r a t e ,d e c a y _s t e p s g l o b a l _s t e p ​)

staircase=True，则 g l o b a l _ s t e p d e c a y _ s t e p s \frac{global_step}{decay_steps}d e c a y _s t e p s g l o b a l _s t e p ​ 取整数，学习率阶梯式下降（每隔 d e c a y _ s t e p s decay_steps d e c a y _s t e p s 步下降一次），否则每一步都衰减。

import matplotlib.pyplot as plt
import tensorflow as tf

global_step = tf.Variable(0, name='global_step', trainable=False)
learning_rate_1 = tf.train.exponential_decay(  # 阶梯型衰减
learning_rate=0.6, global_step=global_step, decay_steps=10,
decay_rate=0.6,
staircase=True
)
learning_rate_2 = tf.train.exponential_decay(  # 步步衰减
learning_rate=0.6, global_step=global_step, decay_steps=10,
decay_rate=0.6,
staircase=False
)

steps, lrs_1, lrs_2 = [], [], []
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for _ in range(60):
current_step, current_lr_1, current_lr_2, _ = sess.run([global_step, learning_rate_1, learning_rate_2, add1])
steps.append(current_step)
lrs_1.append(current_lr_1)
lrs_2.append(current_lr_2)

plt.plot(steps, lrs_1, 'r-', linewidth=2)
plt.plot(steps, lrs_2, 'g-', linewidth=2)
plt.title('exponential_decay')
plt.show()


exponential_decay 学习率衰减

### 2. piecewise_constant(分段常数衰减)

tf.train.piecewise_constant(
x,           # global_step
boundaries,  # List[int]，更新学习率的 step 边界
values,      # lr_list，[base_lr, lr1, lr2, ...]
name=None    # Defaults to 'PiecewiseConstant'
)


boundaries = [10, 20, 30, 40, 50]
values = [0.06, 0.05, 0.04, 0.03, 0.02, 0.01]

import matplotlib.pyplot as plt
import tensorflow as tf

global_step = tf.Variable(0, name='global_step', trainable=False)
learning_rate = tf.train.piecewise_constant(
x=global_step,
boundaries=[10, 20, 30, 40, 50],
values=[0.06, 0.05, 0.04, 0.03, 0.02, 0.01]
)

steps, lrs = [], []
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for _ in range(60):
current_step, current_lr, _ = sess.run([global_step, learning_rate, add1])
steps.append(current_step)
lrs.append(current_lr)

plt.plot(steps, lrs, 'r-', linewidth=2)
plt.title('inverse_time_decay')
plt.show()


inverse_time_decay 学习率衰减

### 3. polynomial_decay(多项式衰减)

tf.train.polynomial_decay(
learning_rate,
global_step,
decay_steps,
end_learning_rate=0.0001,
power=1.0,
cycle=False,
name=None
)


c u r r e n t _ l r = ( l e a r n i n g _ r a t e − e n d _ l e a r n i n g _ r a t e ) ∗ p o w ( 1 − g l o b a l _ s t e p d e c a y _ s t e p s , p o w e r ) + e n d _ l e a r n i n g _ r a t e \begin{aligned} current_lr &= (learning_rate – end_learning_rate) * pow(1 – \frac{global_step}{decay_steps}, power) \ &+ end_learning_rate \end{aligned}c u r r e n t _l r ​=(l e a r n i n g _r a t e −e n d _l e a r n i n g _r a t e )∗p o w (1 −d e c a y _s t e p s g l o b a l _s t e p ​,p o w e r )+e n d _l e a r n i n g _r a t e ​

import matplotlib.pyplot as plt
import tensorflow as tf

global_step = tf.Variable(0, name='global_step', trainable=False)
learning_rate_1 = tf.train.polynomial_decay(
learning_rate=0.102, global_step=global_step, decay_steps=10,
end_learning_rate=0.011,
power=1.0,
cycle=False
)
learning_rate_2 = tf.train.polynomial_decay(
learning_rate=0.1, global_step=global_step, decay_steps=10,
end_learning_rate=0.01,
power=1.0,
cycle=True
)

steps, lrs_1, lrs_2 = [], [], []
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for _ in range(60):
current_step, current_lr_1, current_lr_2, _ = sess.run([global_step, learning_rate_1, learning_rate_2, add1])
steps.append(current_step)
lrs_1.append(current_lr_1)
lrs_2.append(current_lr_2)

plt.plot(steps, lrs_1, 'r-', linewidth=2)
plt.plot(steps, lrs_2, 'g-', linewidth=2)
plt.title('polynomial_decay')
plt.show()


polynomial_decay 学习率衰减

• 红线表示 cycle=False，当迭代次数超过 decay_steps 后，保持 end_learning_rate 不再改变；绿线表示 cycle=True，当迭代次数超过 decay_steps 后，学习率从 end_learning_rate 上升到一个数值后，再次执行衰减。
• 可见周期并未变大
[En]

you can see that the cycle has not become larger.*

• 多项式衰减中设置学习率可以往复升降的目的是为了防止神经网络后期训练的学习率过小，导致网络参数陷入某个局部最优解出不来，设置学习率升高机制，有可能使网络跳出局部最优解[1]
• 上升的值是逐渐变小的，因为随着d e c a y _ s t e p s decay_steps d e c a y _s t e p s 逐渐变大，g l o b a l _ s t e p d e c a y _ s t e p s \frac{global_step}{decay_steps}d e c a y _s t e p s g l o b a l _s t e p ​ 趋向于 1，最后可能几乎没有上升。像不像一山更比一山矮？刚开始跳得远，最后跳得近。

### 4. natural_exp_decay(自然指数衰减)

tf.train.natural_exp_decay(    learning_rate,    global_step,    decay_steps,    decay_rate,    staircase=False,    name=None)

learning_rate 为初始值，学习率随 global_step 的增长呈自然指数衰减，衰减速度由 decay_stepsdecay_rate（指数变化快慢）决定。公式：

c u r r e n t _ l r = l e a r n i n g _ r a t e ∗ e x p ( − d e c a y _ r a t e ∗ g l o b a l _ s t e p d e c a y _ s t e p s ) current_lr = learning_rate * exp(-decay_rate * \frac{global_step}{decay_steps})c u r r e n t _l r =l e a r n i n g _r a t e ∗e x p (−d e c a y _r a t e ∗d e c a y _s t e p s g l o b a l _s t e p ​)

import matplotlib.pyplot as plt
import tensorflow as tf

global_step = tf.Variable(0, name='global_step', trainable=False)
learning_rate_1 = tf.train.natural_exp_decay(
learning_rate=0.6, global_step=global_step, decay_steps=10,
decay_rate=0.6,
staircase=True
)
learning_rate_2 = tf.train.natural_exp_decay(
learning_rate=0.6, global_step=global_step, decay_steps=10,
decay_rate=0.6,
staircase=False
)

steps, lrs_1, lrs_2 = [], [], []
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for _ in range(60):
current_step, current_lr_1, current_lr_2, _ = sess.run([global_step, learning_rate_1, learning_rate_2, add1])
steps.append(current_step)
lrs_1.append(current_lr_1)
lrs_2.append(current_lr_2)

plt.plot(steps, lrs_1, 'r-', linewidth=2)
plt.plot(steps, lrs_2, 'g-', linewidth=2)
plt.title('natural_exp_decay')
plt.show()


natural_exp_decay 学习率衰减

e x p o n e n t i a l _ l r = l e a r n i n g _ r a t e ∗ p o w ( d e c a y _ r a t e , g l o b a l _ s t e p d e c a y _ s t e p s ) n a t u r a l _ e x p _ l r = l e a r n i n g _ r a t e ∗ e x p ( − d e c a y _ r a t e ∗ g l o b a l _ s t e p d e c a y _ s t e p s ) = l e a r n i n g _ r a t e ∗ p o w ( e − d e c a y _ r a t e , g l o b a l _ s t e p d e c a y _ s t e p s ) \begin{aligned} exponential_lr &= learning_rate * pow(decay_rate, \frac{global_step}{decay_steps}) \ natural_exp_lr &= learning_rate * exp(-decay_rate * \frac{global_step}{decay_steps}) \ &= learning_rate * pow(e^{-decay_rate}, \frac{global_step}{decay_steps}) \ \end{aligned}e x p o n e n t i a l _l r n a t u r a l _e x p _l r ​=l e a r n i n g _r a t e ∗p o w (d e c a y _r a t e ,d e c a y _s t e p s g l o b a l _s t e p ​)=l e a r n i n g _r a t e ∗e x p (−d e c a y _r a t e ∗d e c a y _s t e p s g l o b a l _s t e p ​)=l e a r n i n g _r a t e ∗p o w (e −d e c a y _r a t e ,d e c a y _s t e p s g l o b a l _s t e p ​)​

### 5. inverse_time_decay(倒数衰减)

tf.train.inverse_time_decay(
learning_rate,
global_step,
decay_steps,
decay_rate,
staircase=False,
name=None
)


[En]

This is similar to exponential decay, except that the exponential function is replaced by the reciprocal function, which may fall relatively slowly. Formula:

c u r r e n t _ l r = l e a r n i n g _ r a t e / ( 1 + d e c a y _ r a t e ∗ g l o b a l _ s t e p d e c a y _ s t e p s ) current_lr =learning_rate / (1 + decay_rate * \frac{global_step}{decay_steps})c u r r e n t _l r =l e a r n i n g _r a t e /(1 +d e c a y _r a t e ∗d e c a y _s t e p s g l o b a l _s t e p ​)

import matplotlib.pyplot as plt
import tensorflow as tf

global_step = tf.Variable(0, name='global_step', trainable=False)
learning_rate_1 = tf.train.inverse_time_decay(
learning_rate=0.1, global_step=global_step, decay_steps=10,
decay_rate=0.2,
staircase=True
)
learning_rate_2 = tf.train.inverse_time_decay(
learning_rate=0.1, global_step=global_step, decay_steps=10,
decay_rate=0.2,
staircase=False
)

steps, lrs_1, lrs_2 = [], [], []
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for _ in range(60):
current_step, current_lr_1, current_lr_2, _ = sess.run([global_step, learning_rate_1, learning_rate_2, add1])
steps.append(current_step)
lrs_1.append(current_lr_1)
lrs_2.append(current_lr_2)

plt.plot(steps, lrs_1, 'r-', linewidth=2)
plt.plot(steps, lrs_2, 'g-', linewidth=2)
plt.title('inverse_time_decay')
plt.show()


inverse_time_decay 学习率衰减

### 6. 各种余弦衰减

#### 6.1 cosine_decay(余弦衰减)

tf.train.cosine_decay(
learning_rate,
global_step,
decay_steps,
alpha=0.0,
name=None
)


g l o b a l _ s t e p = m i n ( g l o b a l _ s t e p , d e c a y _ s t e p s ) c o s i n e _ d e c a y = 0.5 ∗ ( 1 + c o s ( p i ∗ g l o b a l _ s t e p d e c a y _ s t e p s ) ) c u r r e n t _ l r = l e a r n i n g _ r a t e ∗ ( ( 1 − a l p h a ) ∗ c o s i n e _ d e c a y + a l p h a ) \begin{aligned} global_step &= min(global_step, decay_steps) \ cosine_decay &= 0.5 * (1 + cos(pi * \frac{global_step}{decay_steps})) \ current_lr &= learning_rate * ((1 – alpha) * cosine_decay + alpha) \end{aligned}g l o b a l _s t e p c o s i n e _d e c a y c u r r e n t _l r ​=m i n (g l o b a l _s t e p ,d e c a y _s t e p s )=0 .5 ∗(1 +c o s (p i ∗d e c a y _s t e p s g l o b a l _s t e p ​))=l e a r n i n g _r a t e ∗((1 −a l p h a )∗c o s i n e _d e c a y +a l p h a )​

#### 6.2 cosine_decay_restarts(重启式余弦衰减)

tf.train.cosine_decay_restarts(
learning_rate,
global_step,
first_decay_steps,
t_mul=2.0,
m_mul=1.0,
alpha=0.0,
name=None
)


### 6.3 linear_cosine_decay(线性余弦衰减)

tf.train.linear_cosine_decay(
learning_rate,
global_step,
computation.

decay_steps,
num_periods=0.5,
alpha=0.0,
beta=0.001,
name=None
)


[En]

At the same time, the double attenuation of linear attenuation and cosine attenuation is reflected in the multiplication of the two. Formula:

g l o b a l _ s t e p = m i n ( g l o b a l _ s t e p , d e c a y _ s t e p s ) l i n e a r _ d e c a y = d e c a y _ s t e p s − g l o b a l _ s t e p d e c a y _ s t e p s = 1 − g l o b a l _ s t e p d e c a y _ s t e p s c o s i n e _ d e c a y = 0.5 ∗ ( 1 + c o s ( p i ∗ 2 ∗ n u m _ p e r i o d s ∗ g l o b a l _ s t e p d e c a y _ s t e p s ) ) c u r r e n t _ l r = l e a r n i n g _ r a t e ∗ ( ( a l p h a + l i n e a r _ d e c a y ) ∗ c o s i n e _ d e c a y + b e t a ) = l e a r n i n g _ r a t e ∗ ( ( 1 + a l p h a − g l o b a l _ s t e p d e c a y _ s t e p s ) ∗ c o s i n e _ d e c a y + b e t a ) \begin{aligned} global_step &= min(global_step, decay_steps) \ linear_decay &= \frac{decay_steps – global_step}{decay_steps} = 1 – \frac{global_step}{decay_steps} \ cosine_decay &= 0.5 * (1 + cos(pi * 2 * num_periods * \frac{global_step}{decay_steps})) \ current_lr &= learning_rate * ((alpha + linear_decay) * cosine_decay + beta) \ &= learning_rate * ((1 + alpha – \frac{global_step}{decay_steps}) * cosine_decay + beta) \end{aligned}g l o b a l _s t e p l i n e a r _d e c a y c o s i n e _d e c a y c u r r e n t _l r ​=m i n (g l o b a l _s t e p ,d e c a y _s t e p s )=d e c a y _s t e p s d e c a y _s t e p s −g l o b a l _s t e p ​=1 −d e c a y _s t e p s g l o b a l _s t e p ​=0 .5 ∗(1 +c o s (p i ∗2 ∗n u m _p e r i o d s ∗d e c a y _s t e p s g l o b a l _s t e p ​))=l e a r n i n g _r a t e ∗((a l p h a +l i n e a r _d e c a y )∗c o s i n e _d e c a y +b e t a )=l e a r n i n g _r a t e ∗((1 +a l p h a −d e c a y _s t e p s g l o b a l _s t e p ​)∗c o s i n e _d e c a y +b e t a )​

（1）与线性衰减相乘的效果为：后期相对前期衰减更快（线性衰减的叠加）；
（2） num_periods 可以灵活设置衰减期内余弦函数的周期数，默认是半个周期（余弦值从 1 到 0），若设置为默认值，则和 cosine_decay 相同。

#### 6.4 noisy_linear_cosine_decay(噪声线性余弦衰减)

tf.train.noisy_linear_cosine_decay(
learning_rate,
global_step,
decay_steps,
initial_variance=1.0,
variance_decay=0.55,
num_periods=0.5,
alpha=0.0,
beta=0.001,
name=None
)


d e c a y e d = ( a l p h a + l i n e a r _ d e c a y + e p s _ t ) ∗ c o s i n e _ d e c a y + b e t a decayed = (alpha + linear_decay + eps_t) * cosine_decay + beta d e c a y e d =(a l p h a +l i n e a r _d e c a y +e p s _t )∗c o s i n e _d e c a y +b e t a

#### 6.5 对以上四种余弦衰减策略，画在同一张图中：

import matplotlib.pyplot as plt
import tensorflow as tf

global_step = tf.Variable(0, name='global_step', trainable=False)
learning_rate_1 = tf.train.cosine_decay(
learning_rate=0.3, global_step=global_step, decay_steps=50,
alpha=0.01
)
learning_rate_2 = tf.train.cosine_decay_restarts(
learning_rate=0.3, global_step=global_step, first_decay_steps=10,
t_mul=1.5,
m_mul=0.8,
alpha=0.011
)
learning_rate_3 = tf.train.linear_cosine_decay(
learning_rate=0.3, global_step=global_step, decay_steps=50,
num_periods=3.0,
alpha=0.0,
beta=0.2
)
learning_rate_4 = tf.train.noisy_linear_cosine_decay(
learning_rate=0.1, global_step=global_step, decay_steps=50,
initial_variance=0.01,
variance_decay=0.1,
num_periods=0.2,
alpha=0.5,
beta=0.2
)

steps, lrs_1, lrs_2, lrs_3, lrs_4 = [], [], [], [], []
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for _ in range(60):
current_step, current_lr_1, current_lr_2, current_lr_3, current_lr_4, _ = sess.run(
[global_step, learning_rate_1, learning_rate_2, learning_rate_3, learning_rate_4, add1]
)
steps.append(current_step)
lrs_1.append(current_lr_1)
lrs_2.append(current_lr_2)
lrs_3.append(current_lr_3)
lrs_4.append(current_lr_4)

plt.plot(steps, lrs_1, 'r-', linewidth=2)
plt.plot(steps, lrs_2, 'g-', linewidth=2)
plt.plot(steps, lrs_3, 'b-', linewidth=2)
plt.plot(steps, lrs_4, 'y-', linewidth=2)
plt.title('cosine_decay')
plt.show()


inverse_time_decay 学习率衰减

### References

Original: https://blog.csdn.net/qq_32527569/article/details/124087621
Author: SATAN 先生
Title: tensorflow 中的学习率衰减

(0)

### 大家都在看

• #### “利用ARIMA模型对时间序列进行分析的经典案例（详细代码）”一文中会遇到的问题总结（二）

最近又有好些朋友来咨询掌柜关于 使用ARIMA模型对时间序列进行预测的👉这篇博客 中遇到了一些问题，这里掌柜再次收集大家的问题来一一解答。 PS: 本博客假定大家已经具备ARIMA…

人工智能 2023年7月16日
0145
• #### 【HTML粉色跳动爱心】效果展示+源代码

目录 * – 一、源代码 – + 1.1 index.html + 1.2 style.css + 1.3 js文件 – 二、效果展示 一、源代…

人工智能 2023年7月31日
0156
• #### 机器学习入门（3）——决策树（分类树）

文章目录 3.1决策树模型 3.2生成决策树 * 概念 方法 3.3切分特征的选择 * 3.3.1信息熵 3.3.2条件信息熵 3.3.3信息增益 3.3.4信息增益比 3.3.5…

人工智能 2023年7月3日
0120
• #### SparkDF操作与SQL交互和相关函数整理

SparkDF与SparkSQL交互操作函数笔记 * – + 一、生成DF方式 + * 1.toDF * 2.createDataFrame * 3.list 转 DF…

人工智能 2023年7月16日
084
• #### SimplE：SimplE Embedding for Link Prediction in Knowledge Graphs+代码

文章目录 1 介绍 * 1.1 知识图谱 1.2 知识图谱补全方法 1.3知识图谱补全（Knowledge Graph Completion，KGC） 1.4 关系分类 2 模型 …

人工智能 2023年6月1日
0127
• #### R语言F分布函数F Distribution（df, pf, qf & rf ）实战

R语言F分布函数F Distribution（df, pf, qf & rf ）实战 目录 R语言F分布函数F Distribution（df, pf, qf & …

人工智能 2023年7月17日
0148
• #### 【超详细】支持向量机（SVM）数学推导

目录 一、硬间隔SVM（Hard Margin SVM) 二、对偶问题（Dual Problem) 1.将有约束问题转变为无约束问题 2.强对偶关系 3.计算拉格朗日函数的最小值 …

人工智能 2023年6月24日
0172
• #### 构建神经网络对鸢尾花进行多分类分析

鸢尾花数据在机器学习中经常会运用到，并且其中的数据可以进行三分类的操作，机器学习算法对其的应用例子特别多。最近在学习神经网络方面的知识，所以运用了神经网络方面的知识对其数据进行分析…

人工智能 2023年7月1日
0144
• #### 《Python数据分析与应用》第4章Pandas统计分析（1） 实训部分

《Python数据分析与应用》第4章Pandas统计分析（1） 实训部分（源于大学课程python数据分析) 实训1 读取并查看P2P网络贷款数据主表的基本信息 2.利用ndim属…

人工智能 2023年6月19日
0124
• #### 深度学习3D可视化工具——Zetane Engine

神经网络在工作的时候，里面到底是什么样？ 为了能透视这个”AI黑箱”中的过程，加拿大蒙特利尔一家公司开发一个3D可视化工具Zetane Engine。只需要…

人工智能 2023年6月16日
0151
• #### Softmax分类器及交叉熵损失（通俗易懂）

在说分类器前我们先了解一下 线性分类 线性函数y = kx + b ，在对于多种类别、多个特征时可将W看做一个矩阵，纵向表示类别，横向表示特征值，现在有3个类别，每个类别只有2个特…

人工智能 2023年6月15日
0218
• #### Linux系统下detectron2安装（cuda11为例）

Linux系统下detectron2安装（cuda11为例） detectron2官方Requirements 1.Linux or macOS with Python ≥ 3.6…

人工智能 2023年7月23日
0133
• #### Anaconda安装tensorflow和keras包

1.背景 在Anaconda中无法直接安装这两个包，安装过程异常漫长。 2.准备工作 添加清华源 1.在Anaconda prompt中(可利用全局搜索查找)运行 conda co…

人工智能 2023年5月23日
0126
• #### 【OpenCV 例程300篇】49. 直方图处理之局部直方图处理（cv2.createCLAHE）

『youcans 的 OpenCV 例程300篇 – 总目录』 【youcans 的 OpenCV 例程300篇】49. 直方图处理之局部直方图处理（cv2.creat…

人工智能 2023年7月19日
0152
• #### 在Ubuntu18系统下安装著名的C/C++图像处理开源软件库 Opencv3.x及简单的运用

文章目录 一、opencv是什么？ 二、安装过程 * 1.下载压缩包 2、将文件移动到home并解压文件、进入该目录 3、安装cmake和依赖库 三、实例应用 * 1、编写一个打开…

人工智能 2023年6月20日
0132
• #### Pandas的主要数学计算方法

可用于Series和DataFrame df = pd.DataFrame({‘key1’:np.arange(10), ‘key2’:np.random.rand(10)*10}…

人工智能 2023年7月8日
0149