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

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

目录

什么是学习率?

有哪些影响因素?

常用调整方法?


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

🍅文末三连哦🍅

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

一、什么是学习率?

深度学习中的学习率(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

相关文章

SpringBoot3实现Gzip压缩优化的技术指南

《SpringBoot3实现Gzip压缩优化的技术指南》随着Web应用的用户量和数据量增加,网络带宽和页面加载速度逐渐成为瓶颈,为了减少数据传输量,提高用户体验,我们可以使用Gzip压缩HTTP响应,... 目录1、简述2、配置2.1 添加依赖2.2 配置 Gzip 压缩3、服务端应用4、前端应用4.1 N

Linux换行符的使用方法详解

《Linux换行符的使用方法详解》本文介绍了Linux中常用的换行符LF及其在文件中的表示,展示了如何使用sed命令替换换行符,并列举了与换行符处理相关的Linux命令,通过代码讲解的非常详细,需要的... 目录简介检测文件中的换行符使用 cat -A 查看换行符使用 od -c 检查字符换行符格式转换将

Go标准库常见错误分析和解决办法

《Go标准库常见错误分析和解决办法》Go语言的标准库为开发者提供了丰富且高效的工具,涵盖了从网络编程到文件操作等各个方面,然而,标准库虽好,使用不当却可能适得其反,正所谓工欲善其事,必先利其器,本文将... 目录1. 使用了错误的time.Duration2. time.After导致的内存泄漏3. jsO

SpringBoot实现数据库读写分离的3种方法小结

《SpringBoot实现数据库读写分离的3种方法小结》为了提高系统的读写性能和可用性,读写分离是一种经典的数据库架构模式,在SpringBoot应用中,有多种方式可以实现数据库读写分离,本文将介绍三... 目录一、数据库读写分离概述二、方案一:基于AbstractRoutingDataSource实现动态

Python FastAPI+Celery+RabbitMQ实现分布式图片水印处理系统

《PythonFastAPI+Celery+RabbitMQ实现分布式图片水印处理系统》这篇文章主要为大家详细介绍了PythonFastAPI如何结合Celery以及RabbitMQ实现简单的分布式... 实现思路FastAPI 服务器Celery 任务队列RabbitMQ 作为消息代理定时任务处理完整

springboot循环依赖问题案例代码及解决办法

《springboot循环依赖问题案例代码及解决办法》在SpringBoot中,如果两个或多个Bean之间存在循环依赖(即BeanA依赖BeanB,而BeanB又依赖BeanA),会导致Spring的... 目录1. 什么是循环依赖?2. 循环依赖的场景案例3. 解决循环依赖的常见方法方法 1:使用 @La

Java枚举类实现Key-Value映射的多种实现方式

《Java枚举类实现Key-Value映射的多种实现方式》在Java开发中,枚举(Enum)是一种特殊的类,本文将详细介绍Java枚举类实现key-value映射的多种方式,有需要的小伙伴可以根据需要... 目录前言一、基础实现方式1.1 为枚举添加属性和构造方法二、http://www.cppcns.co

使用Python实现快速搭建本地HTTP服务器

《使用Python实现快速搭建本地HTTP服务器》:本文主要介绍如何使用Python快速搭建本地HTTP服务器,轻松实现一键HTTP文件共享,同时结合二维码技术,让访问更简单,感兴趣的小伙伴可以了... 目录1. 概述2. 快速搭建 HTTP 文件共享服务2.1 核心思路2.2 代码实现2.3 代码解读3.

使用C#代码在PDF文档中添加、删除和替换图片

《使用C#代码在PDF文档中添加、删除和替换图片》在当今数字化文档处理场景中,动态操作PDF文档中的图像已成为企业级应用开发的核心需求之一,本文将介绍如何在.NET平台使用C#代码在PDF文档中添加、... 目录引言用C#添加图片到PDF文档用C#删除PDF文档中的图片用C#替换PDF文档中的图片引言在当

Java中的String.valueOf()和toString()方法区别小结

《Java中的String.valueOf()和toString()方法区别小结》字符串操作是开发者日常编程任务中不可或缺的一部分,转换为字符串是一种常见需求,其中最常见的就是String.value... 目录String.valueOf()方法方法定义方法实现使用示例使用场景toString()方法方法