TensorFlow中设置学习率的方式

最新推荐文章于 2024-06-14 09:37:08 发布
最新推荐文章于 2024-06-14 09:37:08 发布
阅读量934 收藏 5
点赞数 1
文章标签： 人工智能 python
原文链接：http://www.cnblogs.com/chenzhen0530/p/10632937.html
版权

目录

  上文深度神经网络中各种优化算法原理及比较中介绍了深度学习中常见的梯度下降优化算法；其中，有一个重要的超参数——学习率\(\alpha\)需要在训练之前指定，学习率设定的重要性不言而喻：过小的学习率会降低网络优化的速度，增加训练时间；而过大的学习率则可能导致最后的结果不会收敛，或者在一个较大的范围内摆动；因此，在训练的过程中，根据训练的迭代次数调整学习率的大小，是非常有必要的；

  因此，本文主要介绍TensorFlow中如何使用学习率、TensorFlow中的几种学习率设置方式；文章中参考引用文献将不再具体文中说明，在文章末尾处会给出所有的引用文献链接；

  本主要主要介绍的学习率设置方式有：

  • 指数衰减: tf.train.exponential_decay()
  • 分段常数衰减: tf.train.piecewise_constant()
  • 自然指数衰减: tf.train.natural_exp_decay()
  • 多项式衰减tf.train.polynomial_decay()
  • 倒数衰减tf.train.inverse_time_decay()
  • 余弦衰减tf.train.cosine_decay()

1. 指数衰减

tf.train.exponential_decay(
    learning_rate,
    global_step, 
    decay_steps, 
    decay_rate,
    staircase=False, 
    name=None):
参数用法
learning_rate初始学习率；
global_step迭代次数；
decay_steps衰减周期，当staircase=True时，学习率在\(decay\_steps\)内保持不变，即得到离散型学习率；
decay_rate衰减率系数；
staircase是否定义为离散型学习率，默认False；
name名称，默认ExponentialDecay；

计算方式：

decayed_learning_rate = learning_rate * decay_rate ^ (global_step / decay_steps)
# 如果staircase=True，则学习率会在得到离散值，每decay_steps迭代次数，更新一次；

示例：

# coding:utf-8
import matplotlib.pyplot as plt
import tensorflow as tf

global_step = tf.Variable(0, name='global_step', trainable=False) # 迭代次数

y = []
z = []
EPOCH = 200

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for global_step in range(EPOCH):
        # 阶梯型衰减
        learing_rate1 = tf.train.exponential_decay(
            learning_rate=0.5, global_step=global_step, decay_steps=10, decay_rate=0.9, staircase=True)
        # 标准指数型衰减
        learing_rate2 = tf.train.exponential_decay(
            learning_rate=0.5, global_step=global_step, decay_steps=10, decay_rate=0.9, staircase=False)
        lr1 = sess.run([learing_rate1])
        lr2 = sess.run([learing_rate2])
        y.append(lr1)
        z.append(lr2)

x = range(EPOCH)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_ylim([0, 0.55])

plt.plot(x, y, 'r-', linewidth=2)
plt.plot(x, z, 'g-', linewidth=2)
plt.title('exponential_decay')
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.legend(labels = ['staircase', 'continus'], loc = 'upper right')
plt.show()

3.png

2. 分段常数衰减

tf.train.piecewise_constant(
    x, 
    boundaries, 
    values, 
    name=None):
参数用法
x相当于global_step，迭代次数；
boundaries列表，表示分割的边界；
values列表，分段学习率的取值；
name名称，默认PiecewiseConstant；

计算方式：

# parameter
global_step = tf.Variable(0, trainable=False)
boundaries = [100, 200]
values = [1.0, 0.5, 0.1]
# learning_rate
learning_rate = tf.train.piecewise_constant(global_step, boundaries, values)
# 解释
# 当global_step=[1, 100]时，learning_rate=1.0;
# 当global_step=[101, 200]时，learning_rate=0.5;
# 当global_step=[201, ~]时，learning_rate=0.1;

示例：

# coding:utf-8

import matplotlib.pyplot as plt
import tensorflow as tf

global_step = tf.Variable(0, name='global_step', trainable=False)
boundaries = [10, 20, 30]
learing_rates = [0.1, 0.07, 0.025, 0.0125]

y = []
N = 40

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for global_step in range(N):
        learing_rate = tf.train.piecewise_constant(global_step, boundaries=boundaries, values=learing_rates)
        lr = sess.run([learing_rate])
        y.append(lr)

x = range(N)
plt.plot(x, y, 'r-', linewidth=2)
plt.title('piecewise_constant')
plt.show()

4.png

3. 自然指数衰减

类似与指数衰减，同样与当前迭代次数相关，只不过以e为底；

tf.train.natural_exp_decay(
    learning_rate,
    global_step,
    decay_steps,
    decay_rate,
    staircase=False,
    name=None
)
参数用法
learning_rate初始学习率；
global_step迭代次数；
decay_steps衰减周期，当staircase=True时，学习率在\(decay\_steps\)内保持不变，即得到离散型学习率；
decay_rate衰减率系数；
staircase是否定义为离散型学习率，默认False；
name名称，默认ExponentialTimeDecay；

计算方式：

decayed_learning_rate = learning_rate * exp(-decay_rate * global_step)
# 如果staircase=True，则学习率会在得到离散值，每decay_steps迭代次数，更新一次；

示例：

# coding:utf-8

import matplotlib.pyplot as plt
import tensorflow as tf

global_step = tf.Variable(0, name='global_step', trainable=False)

y = []
z = []
w = []
m = []
EPOCH = 200

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for global_step in range(EPOCH):

        # 阶梯型衰减
        learing_rate1 = tf.train.natural_exp_decay(
            learning_rate=0.5, global_step=global_step, decay_steps=10, decay_rate=0.9, staircase=True)

        # 标准指数型衰减
        learing_rate2 = tf.train.natural_exp_decay(
            learning_rate=0.5, global_step=global_step, decay_steps=10, decay_rate=0.9, staircase=False)

        # 阶梯型指数衰减
        learing_rate3 = tf.train.exponential_decay(
            learning_rate=0.5, global_step=global_step, decay_steps=10, decay_rate=0.9, staircase=True)

        # 标准指数衰减
        learing_rate4 = tf.train.exponential_decay(
            learning_rate=0.5, global_step=global_step, decay_steps=10, decay_rate=0.9, staircase=False)

        lr1 = sess.run([learing_rate1])
        lr2 = sess.run([learing_rate2])
        lr3 = sess.run([learing_rate3])
        lr4 = sess.run([learing_rate4])

        y.append(lr1)
        z.append(lr2)
        w.append(lr3)
        m.append(lr4)

x = range(EPOCH)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_ylim([0, 0.55])

plt.plot(x, y, 'r-', linewidth=2)
plt.plot(x, z, 'g-', linewidth=2)
plt.plot(x, w, 'r--', linewidth=2)
plt.plot(x, m, 'g--', linewidth=2)

plt.title('natural_exp_decay')
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.legend(labels = ['natural_staircase', 'natural_continus', 'staircase', 'continus'], loc = 'upper right')
plt.show()

5.png

可以看到自然指数衰减对学习率的衰减程度远大于一般的指数衰减；

4. 多项式衰减

tf.train.polynomial_decay(
    learning_rate, 
    global_step, 
    decay_steps,
    end_learning_rate=0.0001, 
    power=1.0,
    cycle=False, name=None):
参数用法
learning_rate初始学习率；
global_step迭代次数；
decay_steps衰减周期；
end_learning_rate最小学习率，默认0.0001；
power多项式的幂，默认1；
cyclebool，表示达到最低学习率时，是否升高再降低，默认False；
name名称，默认PolynomialDecay；

计算方式：

# 如果cycle=False
global_step = min(global_step, decay_steps)
decayed_learning_rate = (learning_rate - end_learning_rate) *
                          (1 - global_step / decay_steps) ^ (power) +
                          end_learning_rate
# 如果cycle=True
decay_steps = decay_steps * ceil(global_step / decay_steps)
decayed_learning_rate = (learning_rate - end_learning_rate) *
                          (1 - global_step / decay_steps) ^ (power) +
                          end_learning_rate

示例：

# coding:utf-8
import matplotlib.pyplot as plt
import tensorflow as tf

y = []
z = []
EPOCH = 200

global_step = tf.Variable(0, name='global_step', trainable=False)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for global_step in range(EPOCH):
        # cycle=False
        learing_rate1 = tf.train.polynomial_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=50,
            end_learning_rate=0.01, power=0.5, cycle=False)
        # cycle=True
        learing_rate2 = tf.train.polynomial_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=50,
            end_learning_rate=0.01, power=0.5, cycle=True)

        lr1 = sess.run([learing_rate1])
        lr2 = sess.run([learing_rate2])
        y.append(lr1)
        z.append(lr2)

x = range(EPOCH)
fig = plt.figure()
ax = fig.add_subplot(111)
plt.plot(x, z, 'g-', linewidth=2)
plt.plot(x, y, 'r--', linewidth=2)
plt.title('polynomial_decay')
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.legend(labels=['cycle=True', 'cycle=False'], loc='uppper right')
plt.show()

6.png

可以看到学习率在decay_steps=50迭代次数后到达最小值；同时，当cycle=False时，学习率达到预设的最小值后，就保持最小值不再变化；当cycle=True时，学习率将会瞬间增大，再降低；

多项式衰减中设置学习率可以往复升降的目的：时为了防止在神经网络训练后期由于学习率过小，导致网络参数陷入局部最优，将学习率升高，有可能使其跳出局部最优；

5. 倒数衰减

inverse_time_decay(
    learning_rate,
    global_step,
    decay_steps,
    decay_rate,
    staircase=False,
    name=None):
参数用法
learning_rate初始学习率；
global_step迭代次数；
decay_steps衰减周期；
decay_rate学习率衰减参数；
staircase是否得到离散型学习率，默认False；
name名称；默认InverseTimeDecay；

计算方式：

# 如果staircase=False，即得到连续型衰减学习率；
decayed_learning_rate = learning_rate / (1 + decay_rate * global_step / decay_step)

# 如果staircase=True，即得到离散型衰减学习率；
decayed_learning_rate = learning_rate / (1 + decay_rate * floor(global_step / decay_step))

示例：

# coding:utf-8

import matplotlib.pyplot as plt
import tensorflow as tf

y = []
z = []
EPOCH = 200
global_step = tf.Variable(0, name='global_step', trainable=False)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for global_step in range(EPOCH):
        # 阶梯型衰减
        learing_rate1 = tf.train.inverse_time_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=20,
            decay_rate=0.2, staircase=True)

        # 连续型衰减
        learing_rate2 = tf.train.inverse_time_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=20,
            decay_rate=0.2, staircase=False)

        lr1 = sess.run([learing_rate1])
        lr2 = sess.run([learing_rate2])

        y.append(lr1)
        z.append(lr2)

x = range(EPOCH)
fig = plt.figure()
ax = fig.add_subplot(111)
plt.plot(x, z, 'r-', linewidth=2)
plt.plot(x, y, 'g-', linewidth=2)
plt.title('inverse_time_decay')
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.legend(labels=['continus', 'staircase'])
plt.show()

7.png

同样可以看到，随着迭代次数的增加，学习率在逐渐减小，同时减小的幅度也在降低；

6. 余弦衰减

之前使用TensorFlow的版本是1.4，没有学习率的余弦衰减；之后升级到了1.9版本，发现多了四个有关学习率余弦衰减的方法；下面将进行介绍：

6.1 标准余弦衰减

来源于：[Loshchilov & Hutter, ICLR2016], SGDR: Stochastic Gradient Descent with Warm Restarts. https://arxiv.org/abs/1608.03983

tf.train.cosine_decay(
    learning_rate, 
    global_step, 
    decay_steps, 
    alpha=0.0, 
    name=None):
参数用法
learning_rate初始学习率；
global_step迭代次数；
decay_steps衰减周期；
alpha最小学习率，默认为0；
name名称，默认CosineDecay；

计算方式：

global_step = min(global_step, decay_steps)
cosine_decay = 0.5 * (1 + cos(pi * global_step / decay_steps))
decayed = (1 - alpha) * cosine_decay + alpha
decayed_learning_rate = learning_rate * decayed

示例：

# coding:utf-8
import matplotlib.pyplot as plt
import tensorflow as tf

y = []
z = []
EPOCH = 200
global_step = tf.Variable(0, name='global_step', trainable=False)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for global_step in range(EPOCH):
        # 余弦衰减
        learing_rate1 = tf.train.cosine_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=50)
        learing_rate2 = tf.train.cosine_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=100)

        lr1 = sess.run([learing_rate1])
        lr2 = sess.run([learing_rate2])
        y.append(lr1)
        z.append(lr2)

x = range(EPOCH)
fig = plt.figure()
ax = fig.add_subplot(111)
plt.plot(x, y, 'r-', linewidth=2)
plt.plot(x, z, 'b-', linewidth=2)
plt.title('cosine_decay')
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.legend(labels=['decay_steps=50', 'decay_steps=100'],z loc='upper right')
plt.show()

8.png

6.2 重启余弦衰减

来源于：[Loshchilov & Hutter, ICLR2016], SGDR: Stochastic Gradient Descent with Warm Restarts. https://arxiv.org/abs/1608.03983

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):
参数用法
learning_rate初始学习率；
global_step迭代次数；
first_decay_steps衰减周期；
t_mulUsed to derive the number of iterations in the i-th period
m_mulUsed to derive the initial learning rate of the i-th period:
alpha最小学习率，默认为0；
name名称，默认SGDRDecay；

示例：

# coding:utf-8
import matplotlib.pyplot as plt
import tensorflow as tf

y = []
z = []
EPOCH = 100
global_step = tf.Variable(0, name='global_step', trainable=False)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for global_step in range(EPOCH):
        # 重启余弦衰减
        learing_rate1 = tf.train.cosine_decay_restarts(learning_rate=0.1, global_step=global_step,
                                           first_decay_steps=40)
        learing_rate2 = tf.train.cosine_decay_restarts(learning_rate=0.1, global_step=global_step,
                                                       first_decay_steps=60)

        lr1 = sess.run([learing_rate1])
        lr2 = sess.run([learing_rate2])
        y.append(lr1)
        z.append(lr2)

x = range(EPOCH)
fig = plt.figure()
ax = fig.add_subplot(111)
plt.plot(x, y, 'r-', linewidth=2)
plt.plot(x, z, 'b-', linewidth=2)
plt.title('cosine_decay')
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.legend(labels=['decay_steps=40', 'decay_steps=60'], loc='upper right')
plt.show()

9.png

6.3 线性余弦噪声

来源于：[Bello et al., ICML2017] Neural Optimizer Search with RL. https://arxiv.org/abs/1709.07417

tf.train.linear_cosine_decay(
    learning_rate,
    global_step,
    decay_steps,
    num_periods=0.5,
    alpha=0.0,
    beta=0.001,
    name=None):
参数用法
learning_rate初始学习率；
global_step迭代次数；
decay_steps衰减周期；
num_periodsNumber of periods in the cosine part of the decay.
alpha最小学习率；
beta同上；
name名称，

计算方式：

global_step = min(global_step, decay_steps)
linear_decay = (decay_steps - global_step) / decay_steps)
cosine_decay = 0.5 * (1 + cos(pi * 2 * num_periods * global_step / decay_steps))
decayed = (alpha + linear_decay) * cosine_decay + beta
decayed_learning_rate = learning_rate * decayed

示例：

# coding:utf-8
import matplotlib.pyplot as plt
import tensorflow as tf

y = []
z = []
EPOCH = 100
global_step = tf.Variable(0, name='global_step', trainable=False)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for global_step in range(EPOCH):
        # 线性余弦衰减
        learing_rate1 = tf.train.linear_cosine_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=40,
            num_periods=0.2, alpha=0.5, beta=0.2)
        learing_rate2 = tf.train.linear_cosine_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=60,
            num_periods=0.2, alpha=0.5, beta=0.2)

        lr1 = sess.run([learing_rate1])
        lr2 = sess.run([learing_rate2])
        y.append(lr1)
        z.append(lr2)


x = range(EPOCH)
fig = plt.figure()
ax = fig.add_subplot(111)
plt.plot(x, y, 'r-', linewidth=2)
plt.plot(x, z, 'b-', linewidth=2)
plt.title('linear_cosine_decay')
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.legend(labels=['decay_steps=40', 'decay_steps=60'], loc='upper right')
plt.show()

10.png

6.4 噪声余弦衰减

来源于：[Bello et al., ICML2017] Neural Optimizer Search with RL. https://arxiv.org/abs/1709.07417

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):
参数用法
learning_rate初始学习率；
global_step迭代次数；
decay_steps衰减周期；
initial_varianceinitial variance for the noise.
variance_decaydecay for the noise's variance.
num_periodsNumber of periods in the cosine part of the decay.
alpha最小学习率；
beta查看计算公式；
name名称，默认NoisyLinearCosineDecay；

计算方式：

global_step = min(global_step, decay_steps)
linear_decay = (decay_steps - global_step) / decay_steps)
cosine_decay = 0.5 * (
    1 + cos(pi * 2 * num_periods * global_step / decay_steps))
decayed = (alpha + linear_decay + eps_t) * cosine_decay + beta
decayed_learning_rate = learning_rate * decayed

示例：

# coding:utf-8
import matplotlib.pyplot as plt
import tensorflow as tf

y = []
z = []
EPOCH = 100
global_step = tf.Variable(0, name='global_step', trainable=False)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for global_step in range(EPOCH):
        # # 噪声线性余弦衰减
        learing_rate1 = tf.train.noisy_linear_cosine_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=40,
            initial_variance=0.01, variance_decay=0.1, num_periods=2, alpha=0.5, beta=0.2)
        learing_rate2 = tf.train.noisy_linear_cosine_decay(
            learning_rate=0.1, global_step=global_step, decay_steps=60,
            initial_variance=0.01, variance_decay=0.1, num_periods=2, alpha=0.5, beta=0.2)

        lr1 = sess.run([learing_rate1])
        lr2 = sess.run([learing_rate2])
        y.append(lr1)
        z.append(lr2)

x = range(EPOCH)
fig = plt.figure()
ax = fig.add_subplot(111)
plt.plot(x, y, 'r-', linewidth=2)
plt.plot(x, z, 'b-', linewidth=2)
plt.title('noisy_linear_cosine_decay')
ax.set_xlabel('step')
ax.set_ylabel('learing rate')
plt.legend(labels=['decay_steps=40', 'decay_steps=60'], loc='upper right')
plt.show()

11.png

 写在最后，将TensorFlow中提供的所有学习率衰减的方式大致地使用了一遍，突然发现，掌握的也仅仅是TensorFlow中提供了哪些衰减方式、大致如何使用；然而，当涉及到某种具体的衰减方式、参数如何设置与背后的数学意义，以及不同的方法适用于什么情况....等等一些问题，仍不能掌握。如有可能，在之后使用的过程中，当发现有新的理解，再回来补充。

  如有错误，请不吝指正，谢谢。

  这里感谢未雨愁眸-tensorflow中学习率更新策略的博文，本文主要参考该篇文章；当然在其他地方也有看到类似文章，至于说首发何人何处，却未从考证；

博主个人网站：https://chenzhen.onliine

Reference

转载于:https://www.cnblogs.com/chenzhen0530/p/10632937.html

weixin_34260991
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
6.Tensorflow 学习率设置
qq_19645269的博客
02-23 2163
6.1 学习率设置的重要性 在使用梯度下降进行最小化 f(x)f(x)f(x), 初始值为xix_ixi​, 则xi+1x_{i+1}xi+1​公式为 xi+1=xi−lr∂f(xi)∂xix_{i+1}=x_i -lr \frac{\partial f(x_i)}{\partial x_i}xi+1​=xi​−lr∂xi​∂f(xi​)​ lr为learning rate,学习率。学习率过大可能会导致无法得到很好的收敛，学习率过小会导致收敛过慢。 例如，优化目标为f(x)=x2f(x) = x^2f(x)
tensorflow学习笔记(4)-学习率
qq_37633207的博客
05-27 419
　　　　　　　　　　　　　　tensorflow学习笔记(4)-学习率 首先学习率如下图 所以在实际运用中我们会使用指数衰减的学习率 在tf中有这样一个函数 tf.train.exponential_decay(learning_rate, global_step, decay_steps, decay_rate, staircase=False, name=None) 首先看下...
**探索AdamW与余弦学习率周期的魅力——开启深度学习新篇章**
最新发布
gitblog_00095的博客
06-14 456
探索AdamW与余弦学习率周期的魅力——开启深度学习新篇章 项目地址:https://gitcode.com/mpyrozhok/adamwr 在深度学习的浩瀚海洋中，优化器和学习率策略如同舵手和风帆，引领着模型训练的方向和速度。今天，我们将一起深入探讨一款融合了AdamW优化算法与余弦退火学习率调度器的开源项目，它不仅革新了我们的认识，更带来了实践上的突破。 一、项目简介 该项目巧妙地结合了《D...
TensorFlow优化模型之学习率的设置
修炼之路
10-29 2万+
一、学习率 使用TensorFlow训练一个模型时，我们需要通过优化函数来使得我们训练的模型损失值达到最小，常用的优化算法有随机梯度下降、批量梯度下降，而在使用优化算法的时候，我们都需要设置一个学习率（learning rate），而学习率的设置在训练模型的时候也是非常重要的，因为学习率控制了每次更新参数的幅度。如果学习率太大就会导致更新的幅度太大，就有可能会跨过损失值的极小值（不说最小值的原因
Tensorflow设置学习速率
健身房
06-27 1601
  在Tensorflow中，为解决设定学习率(learning rate)问题，提供了tf.train.exponential_decay函数实现指数衰减学习率。首先使用较大学习率，目的是快速得到一个比较优的解；然后通过迭代逐步减小学习率，目的是使模型在训练后期更加稳定： decayed_learning_rate = learining_rate * decay_rate^(global_step / decay_steps) decayed_learning_rate：每一轮优化时使用的学习率。
tensorflow1.x学习之 8-学习率的调整与TensorBoard
qq_33489955的博客
12-27 248
​。
TensorFlow实现指数衰减学习率的方法
09-18
本文将详细介绍如何在TensorFlow中实现指数衰减学习率，并通过具体的示例代码帮助读者更好地理解这一概念。 #### 1. 指数衰减学习率的基本原理 指数衰减学习率是通过一个指数函数随着时间推移逐渐降低学习率的方法...
Tensorflow全局设置可见GPU编号操作
09-16
在这段代码中，`config = tf.ConfigProto()`创建了一个配置对象，`config.gpu_options.visible_device_list = str(device_num)`设置了可见的GPU设备编号，这里的`device_num`是你想要让TensorFlow使用的GPU的编号。...
基于Tensorflow的中文分词模型.zip
03-27
总的来说，这个项目提供了一个利用TensorFlow实现的中文分词解决方案，涵盖了从数据处理到模型构建、训练和评估的全过程，对于深入理解和实践深度学习在中文自然语言处理中的应用具有很高的价值。
Tensorflow 实现迁移学习.zip
01-22
在这个“Tensorflow 实现迁移学习”的资料中，我们主要探讨如何使用TensorFlow这一强大的深度学习框架进行迁移学习。 首先，让我们了解什么是TensorFlow。TensorFlow是由Google开发的一个开源库，用于各种机器学习...
tensorflow学习率设置方式
linchuhai的博客
12-08 1736
1. 指数衰减方式 当选择指数衰减方式更新学习率时，学习率的更新公式如下：                                    也就是当模型的参数每更新decay_steps次时，学习率就更新一次，变为原来的decay_rate倍。 import tensorflow as tf learning_rate = tf.train.exponential_decay( ...
tensorflow中model.compile的学习率怎么设置
weixin_42594427的博客
01-11 1203
在 TensorFlow 中, 可以在编译模型时通过设置 "optimizer" 参数来设置学习率。该参数可以是一个优化器类的实例, 例如 tf.keras.optimizers.Adam, tf.keras.optimizers.SGD 等, 或者是一个优化器类的字符串(字符串会自动解析为对应的优化器类). 在构造优化器类的实例时, 可以通过设置其参数来设置学习率. 例如, 使用 Adam 优化...
TensorFlow笔记之神经网络优化——学习率
qust1508060414的博客
07-29 3354
学习率：表示了每次更新参数的幅度大小。学习率过大，会导致待优化的参数在最小值附近波动，不收敛；学习率过小，会导致待优化的参数收敛缓慢。        在训练过程中，参数的更新相纸损失函数梯度下降的方向。参数的更新公式为：        假设损失函数为 loss = (w + 1)2。梯度是损失函数 loss 的导数为 ∇=2w+2。如参数初值为 5，学习率为 0.2，则参数和损失函数更新如下：...
tensorflow learning rate的设置
wuguangbin1230的博客
07-29 1457
一、分段常数衰减 tf.train.piecewise_constan() 二、指数衰减 tf.train.exponential_decay() 三、自然指数衰减 tf.train.natural_exp_decay() 四、多项式衰减 tf.train.polynomial_decay() 五、余弦衰减 tf.train.cosine_decay() 线性余弦衰减 tf.train.linear_cosine_decay() 噪声线性余弦衰减 ...
Tensorflow框架 -- 学习率的设置
DAOCHI
10-17 507
深度学习的训练中，学习率的初始值对训练的最终结果有着较大的影响，过大或过小的学习率可能使得网络无法收敛，或者收敛很慢，因此需要选择合适的初值，并且要合理的降低学习率； 参考博客：https://www.cnblogs.com/chenzhen0530/p/10632937.html 下面主要介绍如下几种常见的学习率衰减方式： 指数衰减 分段常数衰减 本文主要是tensorflow中学习率衰...
tensorflow中常用学习率更新策略
热门推荐
牧野的博客
04-20 2万+
神经网络训练过程中，根据每batch训练数据前向传播的结果，计算损失函数，再由损失函数根据梯度下降法更新每一个网络参数，在参数更新过程中使用到一个学习率（learning rate），用来定义每次参数更新的幅度。过小的学习率会降低网络优化的速度，增加训练时间，过大的学习率可能导致网络参数在最终的极优值两侧来回摆动，导致网络不能收敛。实践中证明有效的方法是设置一个根据迭代次数衰减的学习率，可以兼顾训...
Tensorflow实现学习率衰减
DRACOYU的博客
12-22 737
Tensorflow实现学习率衰减 觉得有用的话,欢迎一起讨论相互学习~Follow Me 参考文献Deeplearning AI Andrew NgTensorflow1.2 API 学习率衰减(learning rate decay) 加快学习算法的一个办法就是随时间慢慢减少学习率,我们将之称为学习率衰减(learning rate decay) 概括 假设你要使用mini-ba...
神经网络 Python TensorFlow 设置学习率（学习笔记）
Monica
01-20 1829
#学习率设为1 import tensorflow as tf training_steps=10 learning_rate=1 x=tf.Variable(tf.constant(5,dtype=tf.float32),name='x') y=tf.square(x) train_op=tf.train.GradientDescentOptimizer(learning_rate).m...
Tensorflow笔记—6—神经网络优化之学习率，指数衰减学习率和滑动平均
qq_43201403的博客
10-09 1129
一. 学习率 学习率 learning_rate: 表示了每次参数更新的幅度大小。学习率过大，会导致待优化的参数在最小值附近波动，不收敛；学习率过小，会导致待优化的参数收敛缓慢 在训练过程中，参数的更新向着损失函数减小的方向 参数的更新公式为：Wn+1= Wn- learning_rate▽ 假设损失函数 loss = (w + 1)^2。梯度是损失函数 loss 的导数为 ▽ =...
tensorflow中学习率怎么设置
03-27
在 TensorFlow 中，可以使用优化器（如 Adam）来设置学习率。例如，在创建 Adam 优化器时可以通过设置 learning_rate 参数来设置学习率。 ```python optimizer = tf.optimizers.Adam(learning_rate=0.001) ``` 也...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值