深入理解神经网络学习率(定义、影响因素、常见调参方法、关键代码实现)

2024-04-16 20:28
文章标签 代码 实现 学习 常见 方法 定义 深入 理解 神经网络 关键 影响 因素 调参

本文主要是介绍深入理解神经网络学习率(定义、影响因素、常见调参方法、关键代码实现)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

什么是学习率？

有哪些影响因素？

常用调整方法？

博主介绍：✌专注于前后端、机器学习、人工智能应用领域开发的优质创作者、秉着互联网精神开源贡献精神，答疑解惑、坚持优质作品共享。本人是掘金/腾讯云/阿里云等平台优质作者、擅长前后端项目开发和毕业项目实战，深受全网粉丝喜爱与支持✌有需要可以联系作者我哦！

🍅文末三连哦🍅

👇🏻 精彩专栏推荐订阅👇🏻 不然下次找不到哟

一、什么是学习率？

深度学习中的学习率（Learning Rate）是一个至关重要的超参数，它决定了模型在训练过程中更新权重参数的速度与方向。在使用梯度下降法（Gradient Descent）或其变种（如随机梯度下降，Stochastic Gradient Descent, SGD）优化模型时，学习率扮演着核心角色。

具体来说，在每次迭代过程中，模型计算损失函数关于各个参数的梯度，这个梯度指示了参数应当朝着哪个方向调整以最小化损失。学习率就是这个调整过程中的“步伐”大小，即参数更新的量。数学表达式通常是这样的：

w_{t+1} = w_t - \eta \cdot \nabla_w J(w_t)

其中：
w_t是在时间步 t 时模型的参数。
\eta是学习率。
\nabla_w J(w_t)是在当前参数下损失函数J 关于参数w的梯度。

如果学习率设置得过大，那么在每一步迭代中，模型参数可能会跨过最优解，导致震荡或者发散，这被称为“振荡现象”或“不稳定性”。相反，如果学习率设置得太小，模型收敛到最优解的速度将会非常慢，而且可能会陷入局部极小点，而不是全局最优解。

二、有哪些常见的影响因素？

  1. 问题的复杂度：问题的复杂度反映了模型在训练过程中需要调整的参数数量和模型的复杂度。通常情况下，更复杂的问题需要更小的学习率来确保模型的稳定性和收敛性。

  2. 数据集的大小：数据集的大小直接影响了模型训练的稳定性和泛化能力。对于较大的数据集，通常可以使用较大的学习率来加快收敛速度；而对于较小的数据集，则需要使用较小的学习率以避免过拟合。

  3. 学习率的初始值：学习率的初始值对模型的训练过程和性能有重要影响。选择合适的初始学习率是一个关键的调参过程，通常需要进行实验和调整来找到最佳的初始学习率。

  4. 优化算法的选择：不同的优化算法对学习率的敏感度不同。一些优化算法（如Adam、Adagrad等）具有自适应学习率调整的能力，可以在训练过程中动态地调整学习率，而另一些算法（如SGD）则需要手动调整学习率。

  5. 学习率衰减策略：学习率衰减策略决定了学习率在训练过程中的变化方式。合适的学习率衰减策略可以提高模型的训练稳定性和泛化能力，对于长时间的训练任务尤为重要。

  6. 初始参数值：初始参数值对于模型的训练过程和学习率的选择也有影响。不同的初始参数值可能会导致模型在训练过程中出现不同的收敛速度和性能。

  7. 训练数据的分布：训练数据的分布对模型的训练过程和学习率的选择有直接影响。如果训练数据是非平稳的或者存在类别不平衡的情况，可能需要采用不同的学习率调整策略来保证模型的训练效果。

  8. 模型架构的选择：不同的模型架构对于学习率的选择和训练过程的稳定性有不同的要求。一些复杂的模型架构可能需要更小的学习率和更复杂的优化算法来进行训练。

三、常用调整方法？

1、固定学习率

这是最简单的学习率调整方法，即在整个训练过程中保持学习率不变。这种方法的优点是简单直观，但缺点是可能无法很好地适应不同阶段的训练过程，导致训练过程不稳定或收敛速度过慢。 如0.1、0.01、0.001等。

2. 学习率衰减（Learning Rate Decay）


学习率衰减是一种常用的学习率调整方法，它随着训练的进行逐渐减小学习率，以提高模型训练的稳定性和泛化能力。常见的学习率衰减方法包括：

指数衰减（Exponential Decay）：学习率按指数函数衰减，如 $\alpha = \alpha_0 \times e^{-kt}$，其中 $\alpha_0$是初始学习率，$k$是衰减率，$t$是训练的迭代次数。

initial_learning_rate = 0.1
gamma = 0.95  # 衰减率
decay_steps = 100  # 每多少步衰减一次
learning_rate = initial_learning_rate * gamma ** (step / decay_steps)# 或者在PyTorch中使用内置scheduler
scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=gamma)

余弦衰减（Cosine Decay）：学习率按余弦函数衰减，即 $\alpha = \alpha_0 \times (1 + \cos(\frac{t}{T} \times \pi))$，其中 $\alpha_0$是初始学习率，$T$是衰减周期，$t$是当前迭代次数。

initial_learning_rate = 0.1
total_epochs = 100
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=total_epochs, eta_min=0)# 或者使用带有余弦重启的版本
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=total_epochs // 2)

线性衰减（Linear Decay）：学习率按线性函数衰减，如$\alpha = \alpha_0 - kt$，其中 $\alpha_0$ 是初始学习率，$k$是衰减率，$t$是训练的迭代次数。

class LinearDecayScheduler(torch.optim.lr_scheduler._LRScheduler):def __init__(self, optimizer, initial_lr, decay_rate, total_iters):self.decay_rate = decay_rateself.total_iters = total_iterssuper().__init__(optimizer, last_epoch=-1)def get_lr(self):current_iter = self.last_epoch + 1  # PyTorch的last_epoch从0开始计数lr = self.base_lrs[0] - (self.base_lrs[0] * self.decay_rate * (current_iter / self.total_iters))return [lr for _ in self.base_lrs]# 使用示例
optimizer = optim.SGD(model.parameters(), lr=initial_lr)
scheduler = LinearDecayScheduler(optimizer, initial_lr, decay_rate, total_iters)# 在训练循环中调用scheduler.step()以更新学习率
for epoch in range(num_epochs):for iter in range(num_iters_per_epoch):scheduler.step()# ... 训练步骤 ...

3、自适应学习率算法

自适应学习率算法是一类可以自动调整学习率的优化算法，它们根据参数的梯度信息动态地调整学习率。常见的自适应学习率算法包括：

  • Adam（Adaptive Moment Estimation）
  • Adagrad（Adaptive Gradient Algorithm）
  • RMSProp（Root Mean Square Propagation）
  • Adadelta（Adaptive Delta） 这些算法通过考虑历史梯度信息或者自适应地调整学习率的大小来提高模型训练的效率和性能。
Adam算法：

Adam（Adaptive Moment Estimation）是一种自适应学习率算法，结合了动量（Momentum）和自适应学习率调整机制，能够在不同参数的梯度变化范围内自适应地调整学习率，从而提高模型的训练速度和性能。

下面是Adam算法的公式：

1. 初始化参数：
   - $m$和$v$分别为零向量，与模型参数形状相同
   - $\beta_1$和 $\beta_2$是动量和梯度平方的指数衰减率
   - $\alpha$ 是学习率
   - $\epsilon$是一个很小的数，避免除以零

2. 在每个迭代步骤$t$中，对每个参数\theta做如下更新：
   - 计算梯度 $g_t$
   - 更新一阶矩估计：$m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t$
   - 更新二阶矩估计：$v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2$
   - 矫正一阶矩估计：$\hat{m}_t = \frac{m_t}{1 - \beta_1^t}$
   - 矫正二阶矩估计：$\hat{v}_t = \frac{v_t}{1 - \beta_2^t}$
   - 更新参数：$\theta _{t+1} = \theta _t - \frac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t$

Python代码示例，实现了Adam算法的应用：

import numpy as npclass AdamOptimizer:def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8):self.learning_rate = learning_rateself.beta1 = beta1self.beta2 = beta2self.epsilon = epsilonself.m = Noneself.v = Noneself.t = 0def update(self, parameters, gradients):if self.m is None:self.m = np.zeros_like(parameters)self.v = np.zeros_like(parameters)self.t += 1self.m = self.beta1 * self.m + (1 - self.beta1) * gradientsself.v = self.beta2 * self.v + (1 - self.beta2) * (gradients ** 2)m_hat = self.m / (1 - self.beta1 ** self.t)v_hat = self.v / (1 - self.beta2 ** self.t)parameters -= self.learning_rate * m_hat / (np.sqrt(v_hat) + self.epsilon)# 使用示例
# 初始化优化器
optimizer = AdamOptimizer(learning_rate=0.001)
# 定义模型参数和梯度
parameters = np.random.randn(10)
gradients = np.random.randn(10)
# 更新参数
optimizer.update(parameters, gradients)
 Adagrad算法:

Adagrad（Adaptive Gradient Algorithm），它能够根据每个参数的历史梯度信息自适应地调整学习率。Adagrad会为每个参数维护一个学习率，使得在训练过程中，梯度较大的参数拥有较小的学习率，而梯度较小的参数拥有较大的学习率，从而更好地适应不同参数的更新需求。

以下是Adagrad算法的主要步骤：

1. 初始化参数：
   - 初始化参数 \theta为随机值
   - 初始化梯度累积变量 $r$为零向量，与参数 \theta形状相同
   - 初始化全局学习率 $\alpha$
   - 初始化一个很小的常数 $\epsilon$，避免除以零

2. 在每个迭代步骤 $t$中，对每个参数 $\theta _i$做如下更新：
   - 计算梯度$g_t$
   - 将梯度的平方累积到$r$ 中：$r_t = r_{t-1} + g_t^2$
   - 计算参数的学习率：$lr = \frac{\alpha}{\sqrt{r_t} + \epsilon}$
   - 更新参数：$\theta _{t+1} = \theta _t - lr \cdot g_t$

Adagrad的特点是随着训练的进行，由于 $r$中累积了梯度的平方值，学习率会逐渐减小，从而保证了模型在训练过程中的稳定性和收敛性。

Python代码示例，实现了Adagrad算法的应用：

import numpy as npclass AdagradOptimizer:def __init__(self, learning_rate=0.01, epsilon=1e-8):self.learning_rate = learning_rateself.epsilon = epsilonself.r = Nonedef update(self, parameters, gradients):if self.r is None:self.r = np.zeros_like(parameters)self.r += gradients ** 2lr = self.learning_rate / (np.sqrt(self.r) + self.epsilon)parameters -= lr * gradients# 使用示例
# 初始化优化器
optimizer = AdagradOptimizer(learning_rate=0.01)
# 定义模型参数和梯度
parameters = np.random.randn(10)
gradients = np.random.randn(10)
# 更新参数
optimizer.update(parameters, gradients)
RMSProp算法：

RMSProp（Root Mean Square Propagation），它对Adagrad算法进行了改进，解决了Adagrad算法在训练过程中学习率不断减小的问题。RMSProp算法通过使用梯度平方的移动平均来调整学习率，从而实现了对学习率的自适应调整，使得模型的训练更加稳定和高效。

以下是RMSProp算法的主要步骤：

1. 初始化参数：
   - 初始化参数\theta为随机值
   - 初始化梯度平方的指数加权移动平均变量$v$为零向量，与参数 \theta 形状相同
   - 初始化全局学习率 $\alpha$
   - 初始化一个很小的常数$\epsilon$，避免除以零

2. 在每个迭代步骤 $t$ 中，对每个参数 $\theta _i$做如下更新：
   - 计算梯度$g_t$
   - 将梯度的平方累积到 $v$ 中：$v_t = \beta v_{t-1} + (1 - \beta) g_t^2$，其中$\beta$是一个衰减率，通常取0.9
   - 计算参数的学习率：$lr = \frac{\alpha}{\sqrt{v_t} + \epsilon}$
   - 更新参数：$\theta _{t+1} = \theta _t - lr \cdot g_t$

RMSProp算法通过使用梯度平方的指数加权移动平均来调整学习率，使得学习率的调整更加平滑，从而提高了模型训练的稳定性和泛化能力。

Python代码示例，实现了RMSProp算法的应用：

class RMSPropOptimizer:def __init__(self, learning_rate=0.01, beta=0.9, epsilon=1e-8):self.learning_rate = learning_rateself.beta = betaself.epsilon = epsilonself.v = Nonedef update(self, parameters, gradients):if self.v is None:self.v = np.zeros_like(parameters)self.v = self.beta * self.v + (1 - self.beta) * (gradients ** 2)lr = self.learning_rate / (np.sqrt(self.v) + self.epsilon)parameters -= lr * gradients# 使用示例
# 初始化优化器
optimizer = RMSPropOptimizer(learning_rate=0.01)
# 定义模型参数和梯度
parameters = np.random.randn(10)
gradients = np.random.randn(10)
# 更新参数
optimizer.update(parameters, gradients)
Adadelta算法 ：

Adadelta是对RMSProp算法的改进。与RMSProp不同的是，Adadelta算法不需要手动设置一个全局学习率，而是使用了一个更加简洁的学习率调整策略，使得模型训练过程更加稳定和高效。

以下是Adadelta算法的主要步骤：

1. 初始化参数：
   - 初始化参数\theta为随机值
   - 初始化梯度平方的指数加权移动平均变量$v$为零向量，与参数\theta 形状相同
   - 初始化更新量的指数加权移动平均变量 $s$为零向量，与参数 \theta形状相同
   - 初始化一个很小的常数$\epsilon$，避免除以零
   - 初始化一个很小的常数 $\gamma$，用于控制更新量的调整幅度，通常取0.9

2. 在每个迭代步骤$t$中，对每个参数 $\theta _i$做如下更新：
   - 计算梯度$g_t$
   - 将梯度的平方累积到 $v$ 中：$v_t = \gamma v_{t-1} + (1 - \gamma) g_t^2$
   - 计算参数的更新量：$\Delta \theta _t = - \frac{\sqrt{s_{t-1} + \epsilon}}{\sqrt{v_t} + \epsilon} g_t$
   - 将更新量的平方累积到 $s$中：$s_t = \gamma s_{t-1} + (1 - \gamma) (\Delta \theta _t)^2$
   - 更新参数：$\theta _{t+1} = \theta _t + \Delta \theta _t$

Adadelta算法通过使用更新量的指数加权移动平均来调整学习率，使得学习率的调整更加平滑，从而提高了模型训练的稳定性和泛化能力。

Python代码示例，实现了Adadelta算法的应用：

class AdadeltaOptimizer:def __init__(self, gamma=0.9, epsilon=1e-8):self.gamma = gammaself.epsilon = epsilonself.v = Noneself.s = Nonedef update(self, parameters, gradients):if self.v is None:self.v = np.zeros_like(parameters)self.s = np.zeros_like(parameters)self.v = self.gamma * self.v + (1 - self.gamma) * (gradients ** 2)delta_theta = - np.sqrt(self.s + self.epsilon) / np.sqrt(self.v + self.epsilon) * gradientsself.s = self.gamma * self.s + (1 - self.gamma) * (delta_theta ** 2)parameters += delta_theta# 使用示例
# 初始化优化器
optimizer = AdadeltaOptimizer()
# 定义模型参数和梯度
parameters = np.random.randn(10)
gradients = np.random.randn(10)
# 更新参数
optimizer.update(parameters, gradients)

4、多项式衰减（Polynomial Decay）

多项式衰减（Polynomial Decay）是一种学习率调整策略，通过多项式函数对学习率进行衰减，从而在训练过程中逐渐降低学习率。多项式衰减通常用于训练过程中的学习率衰减策略之一，可以帮助模型在训练后期更好地收敛，并提高模型的泛化能力。

多项式衰减的公式通常表示为：

\alpha = \alpha_0 \times (1 - \frac{t}{T})^p

其中：
- \alpha是当前迭代步骤的学习率；
- \alpha_0是初始学习率；
- t是当前迭代步骤；
- T是总的迭代次数；
- p是多项式衰减的指数，控制衰减的速率。

多项式衰减策略通过调整指数 p的大小来控制学习率的衰减速率。当p > 1时，学习率将以多项式函数形式缓慢衰减；当p = 1时，学习率以线性方式衰减；当0 < p < 1时，学习率将以多项式函数形式快速衰减。

Python代码示例，演示了如何实现多项式衰减策略：

def polynomial_decay(initial_learning_rate, current_step, decay_steps, power):"""多项式衰减函数Args:- initial_learning_rate: 初始学习率- current_step: 当前迭代步骤- decay_steps: 衰减步数- power: 多项式衰减的指数Returns:- 当前迭代步骤的学习率"""return initial_learning_rate * (1 - current_step / decay_steps) ** power# 使用示例
initial_learning_rate = 0.01
decay_steps = 1000
power = 0.5for step in range(1, 1001):current_learning_rate = polynomial_decay(initial_learning_rate, step, decay_steps, power)print("Step {}: Learning Rate = {:.6f}".format(step, current_learning_rate))

总结

学习率作为深度学习模型训练过程中的关键调控变量，其重要性不言而喻。在今天的讨论中，我们深入剖析了学习率的概念及其在优化算法中的作用机制。学习率代表了参数更新的步伐大小，直接影响模型收敛的速度和结果的质量。当学习率设定过高时，可能导致模型在寻找最优解的过程中产生剧烈振荡，甚至无法收敛；反之，过低的学习率虽能确保稳定性，却会导致收敛速度过于缓慢，浪费大量计算资源。

针对这一问题，我们探讨了多种动态调整学习率的方法。首先，介绍了传统固定学习率之外的指数衰减、多项式衰减以及步长衰减等策略、还有自适应学习率方法如AdaGrad、RMSprop和Adam因其能够根据各参数的历史梯度信息自动调整学习率而备受青睐，它们有效地解决了传统学习率调整方法存在的诸多局限性。

最后，创作不易！非常感谢大家的关注、点赞、评论啦！谢谢三连哦！好人好运连连，学习进步！工作顺利哦！ 

这篇关于深入理解神经网络学习率(定义、影响因素、常见调参方法、关键代码实现)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/909810。

相关文章

Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
Python版本信息获取方法详解与实战

Python版本信息获取方法详解与实战

《Python版本信息获取方法详解与实战》在Python开发中,获取Python版本号是调试、兼容性检查和版本控制的重要基础操作,本文详细介绍了如何使用sys和platform模块获取Python的主... 目录1. python版本号获取基础2. 使用sys模块获取版本信息2.1 sys模块概述2.1.1
阅读更多...
Python实现字典转字符串的五种方法

Python实现字典转字符串的五种方法

《Python实现字典转字符串的五种方法》本文介绍了在Python中如何将字典数据结构转换为字符串格式的多种方法,首先可以通过内置的str()函数进行简单转换;其次利用ison.dumps()函数能够... 目录1、使用json模块的dumps方法：2、使用str方法：3、使用循环和字符串拼接：4、使用字符
阅读更多...
Python版本与package版本兼容性检查方法总结

Python版本与package版本兼容性检查方法总结

《Python版本与package版本兼容性检查方法总结》：本文主要介绍Python版本与package版本兼容性检查方法的相关资料,文中提供四种检查方法,分别是pip查询、conda管理、PyP... 目录引言为什么会出现兼容性问题方法一：用 pip 官方命令查询可用版本方法二：conda 管理包环境方法
阅读更多...
Linux云服务器手动配置DNS的方法步骤

Linux云服务器手动配置DNS的方法步骤

《Linux云服务器手动配置DNS的方法步骤》在Linux云服务器上手动配置DNS（域名系统）是确保服务器能够正常解析域名的重要步骤,以下是详细的配置方法,包括系统文件的修改和常见问题的解决方案,需要... 目录1. 为什么需要手动配置 DNS？2. 手动配置 DNS 的方法方法 1：修改 /etc/res
阅读更多...
深入理解Mysql OnlineDDL的算法

深入理解Mysql OnlineDDL的算法

《深入理解MysqlOnlineDDL的算法》本文主要介绍了讲解MysqlOnlineDDL的算法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小... 目录一、Online DDL 是什么？二、Online DDL 的三种主要算法2.1COPY（复制法）
阅读更多...
Linux下利用select实现串口数据读取过程

Linux下利用select实现串口数据读取过程

《Linux下利用select实现串口数据读取过程》文章介绍Linux中使用select、poll或epoll实现串口数据读取,通过I/O多路复用机制在数据到达时触发读取,避免持续轮询,示例代码展示设... 目录示例代码（使用select实现）代码解释总结在 linux 系统里，我们可以借助 select、
阅读更多...
Linux挂载linux/Windows共享目录实现方式

Linux挂载linux/Windows共享目录实现方式

《Linux挂载linux/Windows共享目录实现方式》：本文主要介绍Linux挂载linux/Windows共享目录实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地... 目录文件共享协议linux环境作为服务端（NFS）在服务器端安装 NFS创建要共享的目录修改 NFS 配
阅读更多...
通过React实现页面的无限滚动效果

通过React实现页面的无限滚动效果

《通过React实现页面的无限滚动效果》今天我们来聊聊无限滚动这个现代Web开发中不可或缺的技术,无论你是刷微博、逛知乎还是看脚本,无限滚动都已经渗透到我们日常的浏览体验中,那么,如何优雅地实现它呢？... 目录1. 早期的解决方案2. 交叉观察者：IntersectionObserver2.1 Inter
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2