NN学习技巧之参数最优化的四种方法对比（SGD, Momentum, AdaGrad, Adam）,基于MNIST数据集

最新推荐文章于 2023-02-14 16:23:17 发布
最新推荐文章于 2023-02-14 16:23:17 发布
阅读量1.8k 收藏 8
点赞数
分类专栏： 机器学习 Python 文章标签： 参数优化 SGD Momentum Adam Adagrad
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36607894/article/details/99967111
版权

前面几篇博文分析了每一种参数优化方案，现在做一个对比，代码参考斋藤的红鱼书第六章。

实验对mnist数据集的6万张图片训练，使用5层全连接神经网络（4个隐藏层，每个隐藏层有100个神经元），共迭代2000次，下图是损失函数随着训练迭代次数的变化：

可以看到SGD是最慢的，而AdaGrad最快, 且最终的识别精度也更高，这并不是一定的，跟数据也有关
在这里插入图片描述
贴出部分迭代过程变化：

===========iteration:1200===========
SGD:0.2986528195291609
Momentum:0.1037981040196782
AdaGrad:0.0668137679448615
Adam:0.05010293181776089
===========iteration:1300===========
SGD:0.17833478097202
Momentum:0.06128433751079029
AdaGrad:0.01779291355463178
Adam:0.036788168826807605
===========iteration:1400===========
SGD:0.30288604165486865
Momentum:0.07708723420976107
AdaGrad:0.036239187352732696
Adam:0.03584596636673899
===========iteration:1500===========
SGD:0.21648932214740826
Momentum:0.11593046640138721
AdaGrad:0.033343153287890816
Adam:0.039999528396092415
===========iteration:1600===========
SGD:0.23519516569365168
Momentum:0.06509188355944322
AdaGrad:0.0377409654184555
Adam:0.05803067028715449
===========iteration:1700===========
SGD:0.28851197390150085
Momentum:0.14561108131745754
AdaGrad:0.07160438141432544
Adam:0.07280250583341145
===========iteration:1800===========
SGD:0.14382629146685216
Momentum:0.03977221072571262
AdaGrad:0.015159891599626725
Adam:0.019623602905335474
===========iteration:1900===========
SGD:0.19067465612724083
Momentum:0.053986168113818435
AdaGrad:0.03665586658910679
Adam:0.038508895473566646

主要代码：(完整代码可去图灵社区找红鱼书，随书下载)

# coding: utf-8
# OptimizerCompare.py

import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from MultiLayerNet import MultiLayerNet
from util import smooth_curve
from optimizer import *


# 0:读入MNIST数据==========
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)

train_size = x_train.shape[0]
batch_size = 128
max_iterations = 2000

# 1:进行实验的设置==========
optimizers = {}
optimizers['SGD'] = SGD()
optimizers['Momentum'] = Momentum()
optimizers['AdaGrad'] = AdaGrad()
optimizers['Adam'] = Adam()
# optimizers['RMSprop'] = RMSprop()

networks = {}
train_loss = {}
for key in optimizers.keys():
    networks[key] = MultiLayerNet(
        input_size=784, hidden_size_list=[100, 100, 100, 100],
        output_size=10)
    train_loss[key] = []

# 2:开始训练==========
for i in range(max_iterations):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]

    for key in optimizers.keys():
        grads = networks[key].gradient(x_batch, t_batch)
        optimizers[key].update(networks[key].params, grads)

        loss = networks[key].loss(x_batch, t_batch)
        train_loss[key].append(loss)

    if i % 100 == 0:
        print("===========" + "iteration:" + str(i) + "===========")
        for key in optimizers.keys():
            loss = networks[key].loss(x_batch, t_batch)
            print(key + ":" + str(loss))

# 3.绘制图形==========
markers = {"SGD": "o", "Momentum": "x", "AdaGrad": "s", "Adam": "D"}
x = np.arange(max_iterations)
for key in optimizers.keys():
    plt.plot(x, smooth_curve(train_loss[key]), marker=markers[key], \
    markevery=100, label=key)
plt.xlabel("iterations")
plt.ylabel("loss")
plt.ylim(0, 1)
plt.legend()
plt.show()
doubleslow;
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
MNIST手写数字识别（二）几种模型优化方式介绍
MirrorN的博客
11-08 4575
本篇的主要内容有： 动态衰减法设置可变学习率 为损失函数添加正则项 滑动平均模型介绍 为了让MNIST数字识别模型更准确，学习几种常用的模型优化手段： 学习率的优化 学习率的设置一定程度上也会影响模型的训练，如果学习率过小，那么将会经过很长时间才会收敛到想要的结果，反之，学习率过大则可能会导致不收敛的结果，比如：优化 J(x) = x^{2}， 如果设置学习率为 1，那么整个过程： 可以看到...
2.7mnist手写数字识别之训练调试与优化精讲(百度架构师手把手带你零基础实践深度学习原版笔记系列)
aiAI
10-12 1686
2.7mnist手写数字识别之训练调试与优化精讲(百度架构师手把手带你零基础实践深度学习原版笔记系列) 目录 2.7mnist手写数字识别之训练调试与优化精讲(百度架构师手把手带你零基础实践深度学习原版笔记系列) 概述 计算模型的分类准确率 检查模型训练过程，识别潜在训练问题 加入校验或测试，更好评价模型效果 加入正则化项，避免模型过拟合 过拟合现象 导致过拟合原因 过拟合的成因与防控 正则化项 可视化分析 使用Matplotlib库绘制损失随训练下降的曲线图 使用Visu.
各种优化方法总结比较（sgd/momentum/Nesterov/adagrad/adadelta）
热门推荐
blue_jjw的专栏
02-10 3万+
转自：点击打开链接 前言 这里讨论的优化问题指的是，给定目标函数f(x)，我们需要找到一组参数x，使得f(x)的值最小。 本文以下内容假设读者已经了解机器学习基本知识，和梯度下降的原理。 SGD SGD指stochastic gradient descent，即随机梯度下降。是梯度下降的batch版本。 对于训练数据集，我们首先将其分成n个batch，每个bat
神经网络优化算法及代码实现——从SGD、Momentum、AdaGrad、RMSProp到Adam
JayShaun的博客
05-31 2385
文章目录梯度下降（Gradient Descent ）带动量的梯度下降（Gradient Descent + Momentum）Nesterov MomentumAdaGradRMSPropAdam 梯度下降（Gradient Descent ） x:=x−α⋅dxx := x-\alpha \cdot {\rm{d}}xx:=x−α⋅dx 其中α\alphaα为学习率。代码如下： while ...
Pytorch实现MNIST（附SGD、Adam、AdaBound不同优化器下的训练比较）
YYyyy
03-04 4989
  学习工具最快的方法就是在使用的过程中学习，也就是在工作中（解决实际问题中）学习。文章结尾处附完整代码。 一、数据准备   在Pytorch中提供了MNIST的数据，因此我们只需要使用Pytorch提供的数据即可。 from torchvision import datasets, transforms # batch_size 是指每次送入网络进行训练的数据量 batch_size = 64 ...
基于深度学习的MNIST数据集训练与手写数字识别
Oasis___的博客
05-10 1604
本文为某课程实验报告，如有错误欢迎指正
基于pytorch的MNIST数据集的四层CNN，测试准确率99.77%
eye_s1的博客
06-08 9708
基于pytorch的MNIST数据集的四层CNN，测试准确率99.77%MNIST数据集环境配置文件存储结构代码引入库调用GPU初始化变量导入数据集并进行数据增强导入测试集加载测试集查看部分图片model结构权值初始化实例化网络，设置优化器定义存储数据的列表定义训练函数定义测试函数查看模型的识别能力训练模型可视化训练结果预测mnist数据集中的图片预测手写数字图片预处理加载模型预测手写数字（单张）预测手写数字（多张）调整参数，优化模型五层结构参考 MNIST数据集 MNIST 数据集已经是一个被”嚼烂”了的
本文主要描述了如何使用Pytorch(深度学习框架)构建一个简单的卷积神经网络，并对MNIST数据集进行了训练和测试.zip
最新发布
01-14
本篇文章将深入探讨如何使用PyTorch构建一个针对MNIST数据集的简单卷积神经网络（CNN）。MNIST数据集是手写数字识别的经典基准，包含60,000个训练样本和10,000个测试样本，每个样本都是28x28像素的灰度图像。 首先...
深度学习框架tensorflow学习与应用6（优化器SGD、ADAM、Adadelta、Momentum、RMSProp比较）
qq_37791134的博客
12-02 9039
看到一个图片，就是那个表情包，大家都知道： Adadelta 》 NAG 》 Momentum》Remsprop 》Adagrad 》SGD 但是我觉得看情况而定，比如有http://blog.51cto.com/12568470/1898367常见优化算法 (tensorflow对应参数)就认为实际工作上实践中觉得是ADAM ，但是谁说的准呢是吧，每个工程师的场景不一样，得到的实践的经...
【优化算法对比】：SGD、Adam、RMSprop的优劣分析
随着模型复杂度的增加，优化算法不仅要快速收敛到局部最小值，同时还要保证在非凸、大规模数据集上的稳定性和效率。本章将概述优化算法的基础知识，并为后续章节深入分析不同的优化技术奠定基础。在此基础上，我们将...
NNDL 作业11：优化算法比较
qq_58153224的博客
12-06 617
这个就是上面函数俯视角度的梯度方向。箭头长的 地方表示梯度大，短的地方表示梯度小，而且两端的梯度方向明显偏离最优点方向。 SGD算法： 随机梯度下降法是对GD的简化，因为SGD在每一步放弃了对梯度准确性的追求，每步仅仅随机采样少量样本来计算梯度。但是这也导致了他的一个很大的缺点就是对导数的梯度采集的不够准确，它只随机采取了样品中的部分梯度代替了所有样本的梯度，所以梯度方向显示出了很强的波动性。其他的算法： Momentum、AdaGrad Momentum动量法是对前几步 的梯度进行加
sgd,adam和adagrad哪个好
weixin_42577735的博客
02-14 492
SGD，Adam和Adagrad都是梯度下降优化算法，它们都可以用来训练神经网络。这三种算法的主要区别在于它们对学习率的调整方式不同。 SGD(随机梯度下降)是最简单的优化算法，它每次仅使用一个样本来更新参数。 Adam是SGD的变种，它除了使用动量项来提高收敛速度外，还使用了类似于RMSProp的变量来调整学习率。 Adagrad是一种自适应学习率优化方法，它通过调整每个参数的学习率来提高收敛...
机器学习训练与参数优化的一般过程 (讨论)
minfanphd的博客
07-03 514
摘要: 在实际机器学习应用中, 不但要进行模型的训练, 还要进行输入参数的控制. 本文描述了一般性的过程, 仅供参考.
Adam算法
小杨的博客
09-22 1328
momentum算法和AdaGrad算法的融合 class Adam: """Adam (http://arxiv.org/abs/1412.6980v8)""" def __init__(self, lr=0.001, beta1=0.9, beta2=0.999): self.lr = lr self.beta1 = beta1 ...
NN中的学习技巧之（一）参数的最优化之 Momentum
wulimmya的博客
08-20 5270
前面的博文里说了SGD，最基础的一个梯度下降优化算法，在SGD之后还有很多改进版本的算法，比如动量法，下面我降动量法扥别作用于两个函数，第一个是完美凸函数，第二个则是非凸的香蕉函数 函数1：（Rosenbrock函数） f(x,y)=(a−x)2+b(y−x2)2f(x,y)=(a-x)^2+b(y-x^2)^2f(x,y)=(a−x)2+b(y−x2)2 取a=1,b=100 从下图可以看出，...
Deep Learning 最优化方法之Momentum（动量）
WitsMakeMen的专栏
09-14 1397
转自：https://blog.csdn.net/bvl10101111/article/details/72615621 本文是Deep Learning 之 最优化方法系列文章的Momentum（动量）方法。主要参考Deep Learning 一书。 整个优化系列文章列表： Deep Learning 之 最优化方法 Deep Learning 最优化方法之SGD Deep Lear...
【caffe】SGD模式调参概念理解
a200800170331的专栏
06-05 2234
1、SGD概念理解？2、caffe设置SGD的方法是什么？对应的公式是什么？
炼丹笔记（一）MNIST
LittleDragorse的博客
05-19 264
一、从SGDm到Adam MNIST是每个炼丹术士都要尝试的一颗丹药，众所周知，同一种丹药可能有着不同的数十乃至数百种丹方。在尝试了入门中的入门级丹方：三层FC夹BN并取得了98%纯度的好结果后，我开始尝试二级丹方：CNN。所用丹方为两层CNN接Pooling，后接两层FC，ReLU激活。 在料想之中，FC都已经98纯了，CNN一出，那不是手到擒来？于是我手持SGDm款炼丹铲，向Model中加入了其他所需原料。但没想到的是，甫一测试，结果却没有显著变好（十轮还是在98%左右），而且还有一个奇怪的陡坡——这个
【MNIST】
weixin_39915444的博客
08-11 4991
1. Normal Neural Network： 首先我用的是两层（input layer 和 output layer）的feed-forward的神经网络结构来训练数据, y = wx + b, 在输出层用的是softmax求概率，算loss用的是交叉熵的办法，选用梯度下降法来最小化loss更新参数w和b，通过对比output和input对应的label，计算出准确率，因为此网络结构较简单...
1.使用PyTorch实现LeNet网络 2.使用本地文件夹的 Fashion MNIST 对LeNet进行训练和测试，优化算法采用SGD或Adam，torch.optim.SGD 或 torch.optim.Adam 3.分别绘制训练和测试的损失函数曲线和分类正确率曲线 4.调节BatchSize、学习率，并依据测试损失曲线的拐点确定最佳模型，保存该模型 5.使用测试集测试所保存模型的性能，以混淆矩阵展示
05-11
好的，我来给你讲解一下使用PyTorch实现LeNet网络的具体步骤： 1.导入所需要的库 ```python import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms import matplotlib.pyplot as plt import numpy as np ``` 2.定义LeNet网络 ```python class LeNet(nn.Module): def __init__(self): super(LeNet, self).__init__() self.conv1 = nn.Conv2d(1, 6, 5) self.pool1 = nn.MaxPool2d(2, 2) self.conv2 = nn.Conv2d(6, 16, 5) self.pool2 = nn.MaxPool2d(2, 2) self.fc1 = nn.Linear(16 * 4 * 4, 120) self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = self.pool1(torch.relu(self.conv1(x))) x = self.pool2(torch.relu(self.conv2(x))) x = x.view(-1, 16 * 4 * 4) x = torch.relu(self.fc1(x)) x = torch.relu(self.fc2(x)) x = self.fc3(x) return x ``` 3.加载数据集 ```python batch_size = 64 transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))]) trainset = torchvision.datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2) testset = torchvision.datasets.FashionMNIST(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2) ``` 4.定义优化器和损失函数 ```python net = LeNet() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) ``` 5.训练模型并绘制损失函数曲线和分类正确率曲线 ```python epochs = 10 train_losses = [] train_accs = [] test_losses = [] test_accs = [] for epoch in range(epochs): running_loss = 0.0 running_acc = 0.0 for i, data in enumerate(trainloader, 0): inputs, labels = data optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() _, predicted = torch.max(outputs.data, 1) running_acc += (predicted == labels).sum().item() train_loss = running_loss / len(trainloader.dataset) train_acc = running_acc / len(trainloader.dataset) train_losses.append(train_loss) train_accs.append(train_acc) test_loss = 0.0 test_acc = 0.0 with torch.no_grad(): for data in testloader: inputs, labels = data outputs = net(inputs) loss = criterion(outputs, labels) test_loss += loss.item() _, predicted = torch.max(outputs.data, 1) test_acc += (predicted == labels).sum().item() test_loss /= len(testloader.dataset) test_acc /= len(testloader.dataset) test_losses.append(test_loss) test_accs.append(test_acc) print('Epoch [%d/%d], Train Loss: %.4f, Train Accuracy: %.4f, Test Loss: %.4f, Test Accuracy: %.4f' % (epoch + 1, epochs, train_loss, train_acc, test_loss, test_acc)) plt.plot(train_losses, label='Training Loss') plt.plot(test_losses, label='Testing Loss') plt.legend() plt.show() plt.plot(train_accs, label='Training Accuracy') plt.plot(test_accs, label='Testing Accuracy') plt.legend() plt.show() ``` 6.保存最佳模型 ```python best_test_loss = min(test_losses) best_epoch = test_losses.index(best_test_loss) print('Best Epoch: %d, Best Test Loss: %.4f' % (best_epoch + 1, best_test_loss)) torch.save(net.state_dict(), 'best_model.pth') ``` 7.使用混淆矩阵展示模型性能 ```python confusion_matrix = torch.zeros(10, 10) with torch.no_grad(): for data in testloader: inputs, labels = data outputs = net(inputs) _, predicted = torch.max(outputs, 1) for i in range(len(labels)): confusion_matrix[labels[i]][predicted[i]] += 1 classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot') plt.figure(figsize=(10, 10)) plt.imshow(confusion_matrix, interpolation='nearest', cmap=plt.cm.Blues) plt.title('Confusion Matrix') plt.colorbar() tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45) plt.yticks(tick_marks, classes) plt.xlabel('Predicted label') plt.ylabel('True label') plt.show() ``` 通过以上步骤，我们就可以完成使用PyTorch实现LeNet网络的训练和测试，并且得到最佳模型，最后使用混淆矩阵展示模型性能。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值