【深度学习实验】网络优化与正则化(二):基于自适应学习率的优化算法详解:Adagrad、Adadelta、RMSprop

这篇具有很好参考价值的文章主要介绍了【深度学习实验】网络优化与正则化(二):基于自适应学习率的优化算法详解:Adagrad、Adadelta、RMSprop。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  任何数学技巧都不能弥补信息的缺失。
——科尼利厄斯·兰佐斯(Cornelius Lanczos)匈牙利数学家、物理学家

一、实验介绍

  深度神经网络在机器学习中应用时面临两类主要问题:优化问题和泛化问题。

  • 优化问题:深度神经网络的优化具有挑战性。

    • 神经网络的损失函数通常是非凸函数,因此找到全局最优解往往困难。
    • 深度神经网络的参数通常非常多,而训练数据也很大,因此使用计算代价较高的二阶优化方法不太可行,而一阶优化方法的训练效率通常较低。
    • 深度神经网络存在梯度消失梯度爆炸问题,导致基于梯度的优化方法经常失效。
  • 泛化问题:由于深度神经网络的复杂度较高且具有强大的拟合能力,很容易在训练集上产生过拟合现象。因此,在训练深度神经网络时需要采用一定的正则化方法来提高网络的泛化能力。

  目前,研究人员通过大量实践总结了一些经验方法,以在神经网络的表示能力、复杂度、学习效率和泛化能力之间取得良好的平衡,从而得到良好的网络模型。本系列文章将从网络优化和网络正则化两个方面来介绍如下方法:

  • 在网络优化方面,常用的方法包括优化算法的选择参数初始化方法数据预处理方法逐层归一化方法超参数优化方法
  • 在网络正则化方面,一些提高网络泛化能力的方法包括ℓ1和ℓ2正则化权重衰减提前停止丢弃法数据增强标签平滑等。

  本文将介绍基于自适应学习率的优化算法:Adagrad、Adadelta、RMSprop

二、实验环境

  本系列实验使用了PyTorch深度学习框架,相关操作如下:

1. 配置虚拟环境

conda create -n DL python=3.7 
conda activate DL
pip install torch==1.8.1+cu102 torchvision==0.9.1+cu102 torchaudio==0.8.1 -f https://download.pytorch.org/whl/torch_stable.html
conda install matplotlib
 conda install scikit-learn

2. 库版本介绍

软件包 本实验版本 目前最新版
matplotlib 3.5.3 3.8.0
numpy 1.21.6 1.26.0
python 3.7.16
scikit-learn 0.22.1 1.3.0
torch 1.8.1+cu102 2.0.1
torchaudio 0.8.1 2.0.2
torchvision 0.9.1+cu102 0.15.2

三、实验内容

0. 导入必要的库

import torch
import torch.nn.functional as F
from d2l import torch as d2l
from sklearn.datasets import load_iris
from torch.utils.data import Dataset, DataLoader

1. 随机梯度下降SGD算法

  随机梯度下降(Stochastic Gradient Descent,SGD)是一种常用的优化算法,用于训练深度神经网络。在每次迭代中,SGD通过随机均匀采样一个数据样本的索引,并计算该样本的梯度来更新网络参数。具体而言,SGD的更新步骤如下:

  1. 从训练数据中随机选择一个样本的索引。
  2. 使用选择的样本计算损失函数对于网络参数的梯度。
  3. 根据计算得到的梯度更新网络参数。
  4. 重复以上步骤,直到达到停止条件(如达到固定的迭代次数或损失函数收敛)。

a. PyTorch中的SGD优化器

   Pytorch官方教程

optimizer = torch.optim.SGD(model.parameters(), lr=0.2)

b. 使用SGD优化器的前馈神经网络

   【深度学习实验】前馈神经网络(final):自定义鸢尾花分类前馈神经网络模型并进行训练及评价

2.随机梯度下降的改进方法

  传统的SGD在某些情况下可能存在一些问题,例如学习率选择困难和梯度的不稳定性。为了改进这些问题,提出了一些随机梯度下降的改进方法,其中包括学习率的调整和梯度的优化。

a. 学习率调整

【深度学习实验】网络优化与正则化(二):基于自适应学习率的优化算法详解:Adagrad、Adadelta、RMSprop,深度学习实验,深度学习,学习,算法,人工智能,网络优化

  • 学习率衰减(Learning Rate Decay):随着训练的进行,逐渐降低学习率。常见的学习率衰减方法有固定衰减、按照指数衰减、按照时间表衰减等。
  • Adagrad:自适应地调整学习率。Adagrad根据参数在训练过程中的历史梯度进行调整,对于稀疏梯度较大的参数,降低学习率;对于稀疏梯度较小的参数,增加学习率。这样可以在不同参数上采用不同的学习率,提高收敛速度。
  • Adadelta:与Adagrad类似,但进一步解决了Adagrad学习率递减过快的问题。Adadelta不仅考虑了历史梯度,还引入了一个累积的平方梯度的衰减平均,以动态调整学习率。
  • RMSprop:也是一种自适应学习率的方法,通过使用梯度的指数加权移动平均来调整学习率。RMSprop结合了Adagrad的思想,但使用了衰减平均来减缓学习率的累积效果,从而更加稳定。

b. 梯度估计修正

  • Momentum:使用梯度的“加权移动平均”作为参数的更新方向。Momentum方法引入了一个动量项,用于加速梯度下降的过程。通过积累之前的梯度信息,可以在更新参数时保持一定的惯性,有助于跳出局部最优解、加快收敛速度。
  • Nesterov accelerated gradient:Nesterov加速梯度(NAG)是Momentum的一种变体。与Momentum不同的是,NAG会先根据当前的梯度估计出一个未来位置,然后在该位置计算梯度。这样可以更准确地估计当前位置的梯度,并且在参数更新时更加稳定。
  • 梯度截断(Gradient Clipping):为了应对梯度爆炸或梯度消失的问题,梯度截断的方法被提出。梯度截断通过限制梯度的范围,将梯度控制在一个合理的范围内。常见的梯度截断方法有阈值截断和梯度缩放。

3. 梯度估计修正:动量法Momentum

【深度学习实验】网络优化与正则化(一):优化算法:使用动量优化的随机梯度下降算法(Stochastic Gradient Descent with Momentum)

4. 自适应学习率

Adagrad算法

   Adagrad(Adaptive Gradient Algorithm)算法会为每个参数维护一个学习率,该学习率随着时间的推移会逐渐减小。它适用于稀疏数据集,能够有效地处理出现较少的特征。
【深度学习实验】网络优化与正则化(二):基于自适应学习率的优化算法详解:Adagrad、Adadelta、RMSprop,深度学习实验,深度学习,学习,算法,人工智能,网络优化

def init_adagrad_states(feature_dim):
    s_w = torch.zeros((feature_dim, 3))
    s_b = torch.zeros(3)
    return (s_w, s_b)


def adagrad(params, states, hyperparams):
    eps = 1e-6
    for p, s in zip(params, states):
        with torch.no_grad():
            s[:] += torch.square(p.grad)
            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)
        p.grad.data.zero_()
        
  • init_adagrad_states函数用于初始化Adagrad算法中的状态。
    • 创建两个张量 s_ws_b,分别用于保存权重参数和偏置参数的平方梯度累积和。这些状态张量的形状与对应的参数张量相同。
  • adagrad函数使用Adagrad算法来更新模型的参数。
    • 接受三个输入:params表示模型的参数张量列表,states表示Adagrad算法的状态张量列表,hyperparams表示超参数字典,其中包含学习率 lr
    • 在更新参数之前,算法首先定义了一个小量 eps,用于避免除零错误。
    • 对于每个参数张量 p 和对应的状态张量 s,算法执行以下操作:
      • 计算参数梯度的平方。
      • 将平方梯度累积到状态张量 s 中。
      • 使用自适应学习率更新参数 p。这里使用了累积的平方梯度来调整学习率的大小,以更好地适应不同参数的更新需求。
      • 使用 p.grad.data.zero_() 将参数梯度置零,以便下一次迭代时重新计算梯度。

Adadelta算法

   Adadelta算法是Adagrad的改进版本,通过限制累积梯度的历史信息,解决了Adagrad学习率递减过快的问题。它对学习率的调整更加平滑,适合于长期训练的模型。

【深度学习实验】网络优化与正则化(二):基于自适应学习率的优化算法详解:Adagrad、Adadelta、RMSprop,深度学习实验,深度学习,学习,算法,人工智能,网络优化

def init_adadelta_states(feature_dim):
    s_w = torch.zeros((feature_dim, 3))
    s_b = torch.zeros(3)
    delta_w = torch.zeros((feature_dim, 3))
    delta_b = torch.zeros(3)
    return (s_w, s_b, delta_w, delta_b)


def adadelta(params, states, hyperparams):
    rho, eps = hyperparams['rho'], 1e-6
    for p, s, delta in zip(params, states[:2], states[2:]):
        with torch.no_grad():
            s[:] = rho * s + (1 - rho) * torch.square(p.grad)
            update = (torch.sqrt(delta + eps) / torch.sqrt(s + eps)) * p.grad
            p[:] -= update
            delta[:] = rho * delta + (1 - rho) * torch.square(update)
        p.grad.data.zero_()
  • init_adadelta_states函数用于初始化Adadelta算法的状态。
    • 创建了四个张量 s_ws_bdelta_wdelta_b,分别用于保存权重参数和偏置参数的梯度平方累积和以及参数更新的累积平方梯度。这些状态张量的形状与对应的参数张量相同。
  • adadelta函数使用Adadelta算法来更新模型的参数。
    • 接受三个输入:params表示模型的参数张量列表,states表示Adadelta算法的状态张量列表,hyperparams表示超参数字典,其中包含衰减率 rho
    • 在更新参数之前,算法首先定义了两个小量:rho表示衰减率,用于平衡历史梯度和当前梯度的贡献,eps用于避免除零错误。
    • 对于每个参数张量 p 和对应的状态张量 sdelta,算法执行以下操作:
      • 计算参数梯度的平方。
      • 使用衰减率 rho 更新状态张量 s:使用历史梯度和当前梯度的加权平均,以平衡参数更新的速度。
      • 计算参数更新的值 update:使用参数更新的累积平方梯度来调整更新的幅度。
      • 使用更新值 update 更新参数 p:根据调整后的学习率大小来更新参数。
      • 使用衰减率 rho 更新累积平方梯度 delta
      • 使用 p.grad.data.zero_() 将参数梯度置零,以便下一次迭代时重新计算梯度。

RMSprop算法

   RMSprop(Root Mean Square Propagation)算法是一种针对Adagrad算法的改进方法,通过引入衰减系数来平衡历史梯度和当前梯度的贡献。它能够更好地适应不同参数的变化情况,对于非稀疏数据集表现较好。

【深度学习实验】网络优化与正则化(二):基于自适应学习率的优化算法详解:Adagrad、Adadelta、RMSprop,深度学习实验,深度学习,学习,算法,人工智能,网络优化

def init_rmsprop_states(feature_dim):
    s_w = torch.zeros((feature_dim, 3))
    s_b = torch.zeros(3)
    return (s_w, s_b)


def rmsprop(params, states, hyperparams):
    gamma, eps = hyperparams['gamma'], 1e-6
    for p, s in zip(params, states):
        with torch.no_grad():
            s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)
            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)
        p.grad.data.zero_()
        
  • init_rmsprop_states函数用于初始化RMSprop算法中的状态。
    • 创建两个张量 s_ws_b,分别用于保存权重参数和偏置参数的梯度平方累积和。这些状态张量的形状与对应的参数张量相同。
  • rmsprop函数使用RMSprop算法来更新模型的参数。
    • 它接受三个输入:params表示模型的参数张量列表,states表示RMSprop算法的状态张量列表,hyperparams表示超参数字典,其中包含学习率 lr 和衰减率 gamma
    • 在更新参数之前,算法首先定义了两个小量:gamma表示衰减率,用于平衡历史梯度和当前梯度的贡献,eps用于避免除零错误。
    • 对于每个参数张量 p 和对应的状态张量 s,算法执行以下操作:
      • 使用 torch.square(p.grad) 计算参数梯度的平方。
      • 使用衰减率 gamma 更新状态张量 s:使用了历史梯度和当前梯度的加权平均,以平衡参数更新的速度。
      • 使用自适应学习率更新参数 p:使用了累积的梯度平方来调整学习率的大小,以更好地适应不同参数的更新需求。
      • 使用 p.grad.data.zero_() 将参数梯度置零,以便下一次迭代时重新计算梯度。

算法测试

batch_size = 24

# 构建训练集
train_dataset = IrisDataset(mode='train')
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

lr = 0.02
train(adagrad, init_adagrad_states(4), {'lr': lr}, train_loader, 4)
# train(rmsprop, init_rmsprop_states(4), {'lr': lr, 'gamma': 0.9}, train_loader, 4)
  • IrisDataset类:

    • 参照前文:【深度学习实验】前馈神经网络(七):批量加载数据(直接加载数据→定义类封装数据)
  • train函数:

    • 参照前文:【深度学习实验】网络优化与正则化(一):优化算法:使用动量优化的随机梯度下降算法(Stochastic Gradient Descent with Momentum)

5. 代码整合(以RMSprop算法为例)

import torch
from torch import nn
import torch.nn.functional as F
from d2l import torch as d2l
from sklearn.datasets import load_iris
from torch.utils.data import Dataset, DataLoader


class FeedForward(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(FeedForward, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.act = nn.Sigmoid()

    def forward(self, inputs):
        outputs = self.fc1(inputs)
        outputs = self.act(outputs)
        outputs = self.fc2(outputs)
        return outputs


def evaluate_loss(net, data_iter, loss):
    """评估给定数据集上模型的损失

    Defined in :numref:`sec_model_selection`"""
    metric = d2l.Accumulator(2)  # 损失的总和,样本数量
    for X, y in data_iter:
        X = X.to(torch.float32)
        out = net(X)
        #         y = d2l.reshape(y, out.shape)
        l = loss(out, y.long())
        metric.add(d2l.reduce_sum(l), d2l.size(l))
    return metric[0] / metric[1]


def train(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):
    """Defined in :numref:`sec_minibatches`"""
    # 初始化模型
    w = torch.normal(mean=0.0, std=0.01, size=(feature_dim, 3),
                     requires_grad=True)
    b = torch.zeros((3), requires_grad=True)
    # 训练模型
    animator = d2l.Animator(xlabel='epoch', ylabel='loss',
                            xlim=[0, num_epochs], ylim=[0.9, 1.1])
    n, timer = 0, d2l.Timer()

    # 这是一个单层线性层
    net = lambda X: d2l.linreg(X, w, b)
    loss = F.cross_entropy
    for _ in range(num_epochs):
        for X, y in data_iter:
            X = X.to(torch.float32)
            l = loss(net(X), y.long()).mean()
            l.backward()
            trainer_fn([w, b], states, hyperparams)
            n += X.shape[0]
            if n % 48 == 0:
                timer.stop()
                animator.add(n / X.shape[0] / len(data_iter),
                             (evaluate_loss(net, data_iter, loss),))
                timer.start()
    print(f'loss: {animator.Y[0][-1]:.3f}, {timer.avg():.3f} sec/epoch')

    return timer.cumsum(), animator.Y[0]


def load_data(shuffle=True):
    x = torch.tensor(load_iris().data)
    y = torch.tensor(load_iris().target)

    # 数据归一化
    x_min = torch.min(x, dim=0).values
    x_max = torch.max(x, dim=0).values
    x = (x - x_min) / (x_max - x_min)

    if shuffle:
        idx = torch.randperm(x.shape[0])
        x = x[idx]
        y = y[idx]
    return x, y


class IrisDataset(Dataset):
    def __init__(self, mode='train', num_train=120, num_dev=15):
        super(IrisDataset, self).__init__()
        x, y = load_data(shuffle=True)
        if mode == 'train':
            self.x, self.y = x[:num_train], y[:num_train]
        elif mode == 'dev':
            self.x, self.y = x[num_train:num_train + num_dev], y[num_train:num_train + num_dev]
        else:
            self.x, self.y = x[num_train + num_dev:], y[num_train + num_dev:]

    def __getitem__(self, idx):
        return self.x[idx], self.y[idx]

    def __len__(self):
        return len(self.x)


def init_rmsprop_states(feature_dim):
    s_w = torch.zeros((feature_dim, 3))
    s_b = torch.zeros(3)
    return (s_w, s_b)


def rmsprop(params, states, hyperparams):
    gamma, eps = hyperparams['gamma'], 1e-6
    for p, s in zip(params, states):
        with torch.no_grad():
            s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)
            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)
        p.grad.data.zero_()


# batch_size = 1
batch_size = 24
# batch_size = 120

# 分别构建训练集、验证集和测试集
train_dataset = IrisDataset(mode='train')

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

lr = 0.02
train(rmsprop, init_rmsprop_states(4), {'lr': lr, 'gamma': 0.9}, train_loader, 4)

【深度学习实验】网络优化与正则化(二):基于自适应学习率的优化算法详解:Adagrad、Adadelta、RMSprop,深度学习实验,深度学习,学习,算法,人工智能,网络优化文章来源地址https://www.toymoban.com/news/detail-734205.html

到了这里,关于【深度学习实验】网络优化与正则化(二):基于自适应学习率的优化算法详解:Adagrad、Adadelta、RMSprop的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 基于适应度相关算法优化的BP神经网络(预测应用) - 附代码

    摘要:本文主要介绍如何用适应度相关算法优化BP神经网络并应用于预测。 本案例数据一共2000组,其中1900组用于训练,100组用于测试。数据的输入为2维数据,预测的输出为1维数据 2.1 BP神经网络参数设置 神经网络参数如下: 2.2 适应度相关算法应用 适应度相关算法原理请参

    2024年02月11日
    浏览(40)
  • 智能优化算法应用:基于适应度相关算法3D无线传感器网络(WSN)覆盖优化 - 附代码

    摘要:本文主要介绍如何用适应度相关算法进行3D无线传感器网(WSN)覆盖优化。 本文主要基于0/1模型,进行寻优。在二维平面上传感器节点的感知范围是一个以节点为圆心,半径为 R n R_n R n ​ 的圆形区域,该圆形区域通常被称为该节点的“感知圆盘”, R n R_n R n ​ 称为传感

    2024年02月03日
    浏览(43)
  • 【ML算法学习】多核最大均值差异(MK-MMD)与深度适应网络(DAN)

    (1)原点矩、中心矩 引言 :当我们描述一个随机变量 x x x 的时候,最直接的方法就是给出它的概率分布函数 f ( x ) f(x) f ( x ) 。一些简单的分布可以这么干,但是对于一些复杂的、高维的随机变量,我们无法给出它们的分布函数。这时候可以用随机变量的矩来描述一个随机

    2024年02月03日
    浏览(138)
  • 深度学习实验3 - 卷积神经网络

    手写二维卷积的实现,并在至少一个数据集上进行实验,从训练时间、预测精度、Loss变化等角度分析实验结果(最好使用图表展示) 使用torch.nn实现二维卷积,并在至少一个数据集上进行实验,从训练时间、预测精度、Loss变化等角度分析实验结果(最好使用图表展示) 不同

    2024年02月14日
    浏览(49)
  • 【深度学习】实验05 构造神经网络示例

    神经网络是一种仿生学原理的机器学习算法,灵感来源于人脑的神经系统。它由多个神经元(或称为节点)组成,这些神经元通过连接权重形成复杂的网络结构,用来学习和提取输入数据的特征,并用于分类、回归、聚类等任务。 注明:该代码用来训练一个神经网络,网络拟

    2024年02月10日
    浏览(44)
  • 神经网络与深度学习(二)——性能优化

    简单的考虑,把所有权值在[-1,1]区间内按均值或高斯分布 进行初始化。 Xavier初始化:为了使得网络中信息更好的流动,每一层输 出的方差应该尽量相等。因此需要实现下面的均匀分布: 数据包括 训练数据 验证数据 测试数据 通常,三者比例为 70 70%,15%,15%70 或 60 60%,20%,20%60,当

    2024年04月15日
    浏览(35)
  • [深度学习实战]基于PyTorch的深度学习实战(上)[变量、求导、损失函数、优化器]

    PyTorch——开源的Python机器学习库   用了Matlab搭建神经网络才愈发感觉\\\" 人生苦短,我用PyTorch “是多么正确。毕竟 新的神经网络架构还是得自己一点点敲 ,现在是一点都笑不出来了, 指望Matlab提供的老框架和训练算法也做不出什么算法方法的突破,顶多就是在实现功能上

    2024年02月17日
    浏览(45)
  • 【深度学习】基于华为MindSpore的手写体图像识别实验

    1 实验介绍 1.1 简介 Mnist手写体图像识别实验是深度学习入门经典实验。Mnist数据集包含60,000个用于训练的示例和10,000个用于测试的示例。这些数字已经过尺寸标准化并位于图像中心,图像是固定大小(28x28像素),其值为0到255。为简单起见,每个图像都被平展并转换为784(28*28)个

    2023年04月08日
    浏览(38)
  • 基于PyTorch深度学习遥感影像地物分类与目标检测、分割及遥感影像问题深度学习优化

    我国高分辨率对地观测系统重大专项已全面启动,高空间、高光谱、高时间分辨率和宽地面覆盖于一体的全球天空地一体化立体对地观测网逐步形成,将成为保障国家安全的基础性和战略性资源。未来10年全球每天获取的观测数据将超过10PB,遥感大数据时代已然来临。随着小

    2024年02月11日
    浏览(53)
  • MATLAB算法实战应用案例精讲-【深度学习】基于优化的元学习

    目录 元学习 1 元学习概念 2 元学习含义 3 元学习单位 4 基学习器和元学习器

    2024年02月11日
    浏览(50)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包