Pytorch实现MNIST（附SGD、Adam、AdaBound不同优化器下的训练比较）

最新推荐文章于 2024-04-25 09:39:12 发布
最新推荐文章于 2024-04-25 09:39:12 发布
阅读量4.9k 收藏 34
点赞数 6
分类专栏： 深度学习 文章标签： pytorch 深度学习 MNIST
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyhaohaoxuexi/article/details/88133007
版权

  学习工具最快的方法就是在使用的过程中学习，也就是在工作中（解决实际问题中）学习。文章结尾处附完整代码。

一、数据准备

  在Pytorch中提供了MNIST的数据，因此我们只需要使用Pytorch提供的数据即可。

from torchvision import datasets, transforms
# batch_size 是指每次送入网络进行训练的数据量
batch_size = 64
# MNIST Dataset
# MNIST数据集已经集成在pytorch datasets中，可以直接调用
train_dataset = datasets.MNIST(root='./data/',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)

test_dataset = datasets.MNIST(root='./data/',
                              train=False,
                              transform=transforms.ToTensor())

train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False)

二、建立网络

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 输入1通道，输出10通道，kernel 5*5
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=10, kernel_size=5)
        # 输入10通道，输出20通道，kernel 5*5
        self.conv2 = nn.Conv2d(10, 20, 5)
        # 输入20通道，输出40通道，kernel 3*3
        self.conv3 = nn.Conv2d(20, 40, 3)
		# 2*2的池化层
        self.mp = nn.MaxPool2d(2)
        # 全连接层(输入特征数，输出)
        self.fc = nn.Linear(40, 10)

    def forward(self, x):
        # in_size = 64
        # one batch 此时的x是包含batchsize维度为4的tensor，即(batchsize，channels，x，y)
        # x.size(0)指batchsize的值，把batchsize的值作为网络的in_size
        in_size = x.size(0)
        # x: 64*1*28*28
        x = F.relu(self.mp(self.conv1(x)))
        # x: 64*10*12*12  (n+2p-f)/s + 1 = 28 - 5 + 1 = 24,所以在没有池化的时候是24*24,池化层为2*2 ，所以池化之后为12*12
        x = F.relu(self.mp(self.conv2(x)))
        # x: 64*20*4*4 同理，没有池化的时候是12 - 5 + 1 = 8 ，池化后为4*4
        x = F.relu(self.mp(self.conv3(x)))
        # 输出x : 64*40*2*2

        x = x.view(in_size, -1)  # 平铺 tensor 相当于resharp
        # print(x.size())
        # x: 64*320
        x = self.fc(x)
        # x: 64*10
        # print(x.size())
        return F.log_softmax(x)  #64*10

三、开始训练

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

model = Net()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


def train(epoch):
    # enumerate()枚举、列举，对于一个可迭代/遍历的对象，enumerate将其组成一个索引序列，利用它可以同时获得索引和值
    for batch_idx, (data, target) in enumerate(train_loader): #batch_idx是enumerate（）函数自带的索引，从0开始
        # data.size():[64, 1, 28, 28]
        # target.size():[64]
        output = model(data)
        # output:64*10
        loss = F.nll_loss(output, target)
        # 每200次，输出一次数据
        if batch_idx % 200 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.
                  format(
                epoch,
                batch_idx * len(data),
                len(train_loader.dataset),
                100. * batch_idx / len(train_loader),
                loss.item()))

        optimizer.zero_grad()   # 所有参数的梯度清零
        loss.backward()         # 即反向传播求梯度
        optimizer.step()        # 调用optimizer进行梯度下降更新参数
        
# 实验入口
for epoch in range(1, 10):
    train(epoch)

  对于训练中的一些参数解释如下：

  • batch_idx：batch的索引，即batch的数量。
  • batch_size：每次送入网络的数据量

四、测试模型


def test():
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data, target = Variable(data, volatile=True), Variable(target)
        output = model(data.cuda())
        # 累加loss
        test_loss += F.nll_loss(output, target.cuda(), size_average=False).item()
        # get the index of the max log-probability
        # 找出每列（索引）概率意义下的最大值
        pred = output.data.max(1, keepdim=True)[1]
        # print(pred)
        correct += pred.eq(target.data.view_as(pred).cuda()).cuda().sum()

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

# 实验入口
for epoch in range(1, 10):
    print("test num"+str(epoch))
    train(epoch)
    test()

在此展示结果的最后一次：
在这里插入图片描述
可以看到，我们使用SGD作为优化器的优化函数时，测试集后来达到的正确率为92%

五、提高测试集正确率

5.1 增加训练次数（SGD版）

  如题，我们将训练次数增至30，优化函数仍然使用SGD，即只在入口循环处改变epoch的取值范围。为了节省空间，结果只输出测试集loss和正确率。
  我们可以看到，在num18时，测试集的正确率收敛，达到了96%；loss也是在0.1附近波动。

Test set: Average loss: 2.2955, Accuracy: 1018/10000 (10%)

test num1

Test set: Average loss: 2.2812, Accuracy: 2697/10000 (26%)

test num2

Test set: Average loss: 2.2206, Accuracy: 3862/10000 (38%)

test num3

Test set: Average loss: 1.8014, Accuracy: 6100/10000 (61%)

test num4

Test set: Average loss: 0.7187, Accuracy: 8049/10000 (80%)

test num5

Test set: Average loss: 0.4679, Accuracy: 8593/10000 (85%)

test num6

Test set: Average loss: 0.3685, Accuracy: 8898/10000 (88%)

test num7

Test set: Average loss: 0.3006, Accuracy: 9108/10000 (91%)

test num8

Test set: Average loss: 0.2713, Accuracy: 9177/10000 (91%)

test num9

Test set: Average loss: 0.2343, Accuracy: 9270/10000 (92%)

test num10

Test set: Average loss: 0.2071, Accuracy: 9370/10000 (93%)

test num11

Test set: Average loss: 0.1910, Accuracy: 9413/10000 (94%)

test num12

Test set: Average loss: 0.1783, Accuracy: 9453/10000 (94%)

test num13

Test set: Average loss: 0.1612, Accuracy: 9482/10000 (94%)

test num14

Test set: Average loss: 0.1603, Accuracy: 9497/10000 (94%)

test num15

Test set: Average loss: 0.1522, Accuracy: 9526/10000 (95%)

test num16

Test set: Average loss: 0.1410, Accuracy: 9555/10000 (95%)

test num17

Test set: Average loss: 0.1338, Accuracy: 9573/10000 (95%)

test num18

Test set: Average loss: 0.1307, Accuracy: 9588/10000 (95%)

test num19

Test set: Average loss: 0.1212, Accuracy: 9610/10000 (96%)

test num20

Test set: Average loss: 0.1232, Accuracy: 9622/10000 (96%)

test num21

Test set: Average loss: 0.1149, Accuracy: 9646/10000 (96%)

test num22

Test set: Average loss: 0.1104, Accuracy: 9652/10000 (96%)

test num23

Test set: Average loss: 0.1072, Accuracy: 9668/10000 (96%)

test num24

Test set: Average loss: 0.1113, Accuracy: 9646/10000 (96%)

test num25

Test set: Average loss: 0.1037, Accuracy: 9659/10000 (96%)

test num26

Test set: Average loss: 0.0970, Accuracy: 9700/10000 (97%)

test num27

Test set: Average loss: 0.1013, Accuracy: 9692/10000 (96%)

test num28

Test set: Average loss: 0.1015, Accuracy: 9675/10000 (96%)

test num29

Test set: Average loss: 0.0952, Accuracy: 9711/10000 (97%)

test num30

Test set: Average loss: 0.0885, Accuracy: 9727/10000 (97%)


Process finished with exit code 0
5.2 Adam版（训练次数：30）

  Adam还是名副其实的老大，第一次就已经达到了SGD收敛时候的loss值和正确率。我们可以看到，在num26时，Adam优化函数下的模型对于测试集的预测正确率达到了99%，loss为0.0397，但是正确率似乎并没有收敛到99%。

test num1

Test set: Average loss: 0.1108, Accuracy: 9660/10000 (96%)

test num2

Test set: Average loss: 0.0932, Accuracy: 9709/10000 (97%)

test num3

Test set: Average loss: 0.0628, Accuracy: 9800/10000 (98%)

test num4

Test set: Average loss: 0.0562, Accuracy: 9813/10000 (98%)

test num5

Test set: Average loss: 0.0478, Accuracy: 9832/10000 (98%)

test num6

Test set: Average loss: 0.0442, Accuracy: 9850/10000 (98%)

test num7

Test set: Average loss: 0.0386, Accuracy: 9863/10000 (98%)

test num8

Test set: Average loss: 0.0768, Accuracy: 9753/10000 (97%)

test num9

Test set: Average loss: 0.0343, Accuracy: 9879/10000 (98%)

test num10

Test set: Average loss: 0.0347, Accuracy: 9877/10000 (98%)

test num11

Test set: Average loss: 0.0494, Accuracy: 9825/10000 (98%)

test num12

Test set: Average loss: 0.0571, Accuracy: 9811/10000 (98%)

test num13

Test set: Average loss: 0.0342, Accuracy: 9887/10000 (98%)

test num14

Test set: Average loss: 0.0400, Accuracy: 9870/10000 (98%)

test num15

Test set: Average loss: 0.0339, Accuracy: 9889/10000 (98%)

test num16

Test set: Average loss: 0.0371, Accuracy: 9889/10000 (98%)

test num17

Test set: Average loss: 0.0402, Accuracy: 9872/10000 (98%)

test num18

Test set: Average loss: 0.0434, Accuracy: 9887/10000 (98%)

test num19

Test set: Average loss: 0.0377, Accuracy: 9877/10000 (98%)

test num20

Test set: Average loss: 0.0402, Accuracy: 9883/10000 (98%)

test num21

Test set: Average loss: 0.0407, Accuracy: 9886/10000 (98%)

test num22

Test set: Average loss: 0.0482, Accuracy: 9871/10000 (98%)

test num23

Test set: Average loss: 0.0414, Accuracy: 9891/10000 (98%)

test num24

Test set: Average loss: 0.0407, Accuracy: 9890/10000 (98%)

test num25

Test set: Average loss: 0.0403, Accuracy: 9898/10000 (98%)

test num26

Test set: Average loss: 0.0397, Accuracy: 9902/10000 (99%)

test num27

Test set: Average loss: 0.0491, Accuracy: 9873/10000 (98%)

test num28

Test set: Average loss: 0.0416, Accuracy: 9896/10000 (98%)

test num29

Test set: Average loss: 0.0450, Accuracy: 9897/10000 (98%)

test num30

Test set: Average loss: 0.0500, Accuracy: 9875/10000 (98%)


Process finished with exit code 0
5.3 AdaBound版（训练次数：30）

  AdaBound即最近北大、浙大本科生新提出的训练速度比肩Adam，性能媲美SGD的优化算法。
  可以看到，在num4、num5时就正确率已经达到了98%，loss已经比Adam收敛时候的loss低。而在num8的时候，正确率突破99%！loss达到了0.0303！，在接下来的几次训练中，正确率和loss有细微的波动，但是随着训练次数的增加，正确率和loss还是达到了最佳的收敛值，波动并不是特别大。

test num1

Test set: Average loss: 0.1239, Accuracy: 9614/10000 (96%)

test num2

Test set: Average loss: 0.0965, Accuracy: 9704/10000 (97%)

test num3

Test set: Average loss: 0.0637, Accuracy: 9794/10000 (97%)

test num4

Test set: Average loss: 0.0485, Accuracy: 9852/10000 (98%)

test num5

Test set: Average loss: 0.0403, Accuracy: 9870/10000 (98%)

test num6

Test set: Average loss: 0.0513, Accuracy: 9836/10000 (98%)

test num7

Test set: Average loss: 0.0446, Accuracy: 9856/10000 (98%)

test num8

Test set: Average loss: 0.0303, Accuracy: 9910/10000 (99%)

test num9

Test set: Average loss: 0.0411, Accuracy: 9873/10000 (98%)

test num10

Test set: Average loss: 0.0422, Accuracy: 9870/10000 (98%)

test num11

Test set: Average loss: 0.0319, Accuracy: 9894/10000 (98%)

test num12

Test set: Average loss: 0.0303, Accuracy: 9905/10000 (99%)

test num13

Test set: Average loss: 0.0338, Accuracy: 9897/10000 (98%)

test num14

Test set: Average loss: 0.0313, Accuracy: 9904/10000 (99%)

test num15

Test set: Average loss: 0.0285, Accuracy: 9920/10000 (99%)

test num16

Test set: Average loss: 0.0319, Accuracy: 9917/10000 (99%)

test num17

Test set: Average loss: 0.0427, Accuracy: 9884/10000 (98%)

test num18

Test set: Average loss: 0.0351, Accuracy: 9894/10000 (98%)

test num19

Test set: Average loss: 0.0337, Accuracy: 9897/10000 (98%)

test num20

Test set: Average loss: 0.0321, Accuracy: 9910/10000 (99%)

test num21

Test set: Average loss: 0.0354, Accuracy: 9908/10000 (99%)

test num22

Test set: Average loss: 0.0332, Accuracy: 9905/10000 (99%)

test num23

Test set: Average loss: 0.0347, Accuracy: 9904/10000 (99%)

test num24

Test set: Average loss: 0.0362, Accuracy: 9906/10000 (99%)

test num25

Test set: Average loss: 0.0402, Accuracy: 9900/10000 (99%)

test num26

Test set: Average loss: 0.0380, Accuracy: 9900/10000 (99%)

test num27

Test set: Average loss: 0.0378, Accuracy: 9914/10000 (99%)

test num28

Test set: Average loss: 0.0356, Accuracy: 9913/10000 (99%)

test num29

Test set: Average loss: 0.0360, Accuracy: 9912/10000 (99%)


Process finished with exit code 0

六、完整代码

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable
import adabound

# Training settings
batch_size = 64

# TODO dataset 和 dataloader
# MNIST Dataset
# MNIST数据集已经集成在pytorch datasets中，可以直接调用
train_dataset = datasets.MNIST(root='./data/',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)

test_dataset = datasets.MNIST(root='./data/',
                              train=False,
                              transform=transforms.ToTensor())

# Data Loader (Input Pipeline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False)


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 输入1通道，输出10通道，kernel 5*5
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, 5)
        self.conv3 = nn.Conv2d(20, 40, 3)

        self.mp = nn.MaxPool2d(2)
        # fully connect
        self.fc = nn.Linear(40, 10)#（in_features, out_features）

    def forward(self, x):
        # in_size = 64
        # one batch 此时的x是包含batchsize维度为4的tensor，即(batchsize，channels，x，y)
        # x.size(0)指batchsize的值    把batchsize的值作为网络的in_size
        in_size = x.size(0)
        # x: 64*1*28*28
        x = F.relu(self.mp(self.conv1(x)))
        # x: 64*10*12*12  (n+2p-f)/s + 1 = 28 - 5 + 1 = 24,所以在没有池化的时候是24*24,池化层为2*2 ，所以池化之后为12*12
        x = F.relu(self.mp(self.conv2(x)))
        # x: 64*20*4*4 同理，没有池化的时候是12 - 5 + 1 = 8 ，池化后为4*4
        x = F.relu(self.mp(self.conv3(x)))
        # 输出x : 64*40*2*2

        x = x.view(in_size, -1)  # 平铺 tensor 相当于resharp
        # print(x.size())
        # x: 64*320
        x = self.fc(x)
        # x:64*10
        # print(x.size())
        return F.log_softmax(x)  #64*10


model = Net()
model.cuda()
# optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.5)
# optimizer = adabound.AdaBound(model.parameters(), lr=1e-3, final_lr=0.1)
optimizer = optim.Adam(model.parameters(), lr=0.001)

def train(epoch):
    # enumerate()枚举、列举，对于一个可迭代/遍历的对象，enumerate将其组成一个索引序列，利用它可以同时获得索引和值
    for batch_idx, (data, target) in enumerate(train_loader):  # batch_idx是enumerate（）函数自带的索引，从0开始
        # data.size():[64, 1, 28, 28]
        # target.size():[64]
        output = model(data.cuda())
        # print(batch_idx)
        # output:64*10
        loss = F.nll_loss(output, target.cuda())
        # 每200次，输出一次数据
        # if batch_idx % 200 == 0:
        #     print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.
        #           format(
        #         epoch,
        #         batch_idx * len(data),
        #         len(train_loader.dataset),
        #         100. * batch_idx / len(train_loader),
        #         loss.item()))

        optimizer.zero_grad()   # 所有参数的梯度清零
        loss.backward()         #即反向传播求梯度
        optimizer.step()        #调用optimizer进行梯度下降更新参数


def test():
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data, target = Variable(data, volatile=True), Variable(target)
        output = model(data.cuda())
        # 累加loss
        test_loss += F.nll_loss(output, target.cuda(), size_average=False).item()
        # get the index of the max log-probability
        # 找出每列（索引）概率意义下的最大值
        pred = output.data.max(1, keepdim=True)[1]
        # print(pred)
        correct += pred.eq(target.data.view_as(pred).cuda()).cuda().sum()

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))


for epoch in range(1, 30):
    print("test num"+str(epoch))
    train(epoch)
    test()

七、参考资料及获得的帮助

  • AdaBound详解【首发】
  • 完成本次实验得到了何树林同学的大力支持
  • 本次实验的代码在网上参考修改，由于不慎关闭了相关页面……找不到出处了，如果有雷同，请及时告诉我，以便在此声明参考出处。
IMU_YY
关注
  • 6
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
使用KNN根据深度自编码器降维特征识别MNIST数据集手写体数字(pytorch+scikit learn)
qq_35153620的博客
11-27 1603
目标：实现无监督的数据降维，并根据降维信息实现KNN分类 内容： 1.自编码器降维 自编码器是为使神经网络学习数据原始特征，将高维数据特征用低维数据特征表示，是一种无监督的表征学习方法。 其包含编码器部分和解码器部分，编码器负责学习数据的低维嵌入特征，解码器负责将编码学习到的低维特征重新构建回原始数据特征，俩者就好像数据通信的编码和解码过程。 自编码器一般使用MSE损失函数，使重构建的特...
pytorch实现mnist分类的示例讲解
09-18
4. 设置优化器：选择合适的优化器（如SGD或Adam）并初始化。 5. 训练模型：调用`train`函数，传入模型、设备、数据加载器和优化器。 6. 测试模型：调用`test`函数，评估模型在测试集上的表现。 通过这样的流程，...
NN学习技巧之参数最优化的四种方法对比（SGD, Momentum, AdaGrad, Adam）,基于MNIST数据集
wulimmya的博客
08-21 1810
前面几篇博文分析了每一种参数优化方案，现在做一个对比，代码参考斋藤的红鱼书第六章。 实验对mnist数据集的6万张图片训练，使用5层全连接神经网络（4个隐藏层，每个隐藏层有100个神经元），共迭代2000次，下图是损失函数随着训练迭代次数的变化： 可以看到SGD是最慢的，而AdaGrad最快, 且最终的识别精度也更高，这并不是一定的，跟数据也有关 主要代码：(完整代码可去图灵社区找红鱼书，随书下...
Pytorch实现MNIST（附SGD、Adam、AdaBound不同优化器下的训练比较） adabound实现
kyle1314608的博客
07-25 570
 学习工具最快的方法就是在使用的过程中学习，也就是在工作中（解决实际问题中）学习。文章结尾处附完整代码。 一、数据准备  在Pytorch中提供了MNIST的数据，因此我们只需要使用Pytorch提供的数据即可。 from torchvision import datasets, transforms# batch_size 是指每次送入网络进行训练的数据量batch_size = ...
探索AdaBound：优化器的新星，平滑而高效
最新发布
gitblog_00061的博客
04-25 395
探索AdaBound：优化器的新星，平滑而高效 项目地址:https://gitcode.com/Luolc/AdaBound 在深度学习领域，优化器起着至关重要的作用，它们决定模型如何调整权重以达到更好的性能。一个新晋的优秀选手是AdaBound，它在GitHub上的项目链接是：https://gitcode.com/Luolc/AdaBound。本文将深入探讨AdaBound的特点、工作原理和...
Pytorch常用的函数(八)常见优化器SGD,Adagrad,RMSprop,Adam,AdamW总结
qq_44665283的博客
04-23 1638
Pytorch常用的函数(八)常见优化器SGD,Adagrad,RMSprop,Adam,AdamW总结
学习Pytorch+Python之MNIST手写字体识别
weixin_42744921的博客
09-02 262
学习Pytorch+python之MNIST手写字体识别 代码： import matplotlib.pyplot as plt import torch import torch.nn as nn import numpy as np import torchvision.utils from torchvision import datasets, transforms from torch.autograd import Variable import torch.utils.data #判断是否能
Python PyTorch4：MNIST案例
Amzmks的博客
08-10 677
MNIST数据集（Mixed National Institute of Standards and Technology database）是美国国家标准与技术研究院收集整理的大型手写数字数据库，包含60,000个示例的训练集以及10,000个示例的测试集。MNIST数据集包含了四个部分: Training set images (包含 60,000 个样本)、Training set labels (包含 60,000 个标签)、Test set images (包含 10,000 个样本)、 Test
基于pytorch的线性回归算法并比较了Adam与SGD的收敛速度
zzr
05-02 1063
from torch import nn from torch import optim as optimizer import torch from torch.autograd import Variable import matplotlib.pyplot as plt import numpy as np class Model(nn.Module): def __init__...
炼丹笔记（一）MNIST
LittleDragorse的博客
05-19 251
一、从SGDm到Adam MNIST是每个炼丹术士都要尝试的一颗丹药，众所周知，同一种丹药可能有着不同的数十乃至数百种丹方。在尝试了入门中的入门级丹方：三层FC夹BN并取得了98%纯度的好结果后，我开始尝试二级丹方：CNN。所用丹方为两层CNN接Pooling，后接两层FC，ReLU激活。 在料想之中，FC都已经98纯了，CNN一出，那不是手到擒来？于是我手持SGDm款炼丹铲，向Model中加入了其他所需原料。但没想到的是，甫一测试，结果却没有显著变好（十轮还是在98%左右），而且还有一个奇怪的陡坡——这个
使用 PyTorch 实现 MLP 并在 MNIST 数据集上验证方式
09-18
首先，定义优化器（如 SGD 或 Adam），然后遍历训练数据加载器。在每个训练循环中，先将输入数据送入网络进行前向传播得到预测输出，接着计算损失（一般使用交叉熵损失），再用优化器的 `.step()` 方法更新权重。...
Python-AdaBound一个北大提出的优化器训练速度和Adam一样快和SGD一样好
08-11
一种优化器，它可以像Adam一样快速地训练，也可以像sgd一样训练，用于在cv、nlp等领域的各种流行任务上开发最先进的深度学习模型。北大提出全新优化算法AdaBound。
Pytorch实现的手写数字mnist识别功能完整示例
09-18
在实际训练过程中，会使用优化器（optimizer，如Adam或SGD）来更新网络权重，损失函数（如交叉熵损失）来衡量预测与真实标签的差距，以及一个训练循环来迭代数据集并执行反向传播。在每个训练周期结束时，通常会评估...
pytorch 准备、训练和测试自己的图片数据的方法
09-18
接下来，定义损失函数（如交叉熵损失）和优化器（如SGD或Adam），然后开始训练过程： ```python criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9) ...
pytorch入门自学文档内附代码包下载地址
06-25
除了基本的环境配置和安装，学习 PyTorch 还需要理解其基本概念，比如动态计算图、张量操作、神经网络构建、优化器、损失函数等。PyTorch 的灵活性允许你在运行时定义和修改模型结构，这对于实验和调试非常有利。...
adabound详解优化器数学
kyle1314608的博客
03-22 2184
AdaBound：ADAPTIVE GRADIENT METHODS WITH DYNAMIC BOUND OF LEARNING RATE [github][discussion] (ICLR2019) （消息来源量子位-中国学霸本科生提出AI新算法：速度比肩Adam，性能媲美SGD，ICLR领域主席赞不绝口） 在本篇论文中，作者公布了一个名为AdaBound的神经网络优化算法，简...
AdaBound算法：像Adam一样快，又像SGD一样好的优化器
一路狂奔的猪的博客
02-28 6067
第一作者是北大大四学生，有点厉害啊！ 论文地址： https://openreview.net/pdf?id=Bkg3g2R9FX GitHub地址： https://github.com/Luolc/AdaBound 这篇文章对于SGD和Adam等优化算法的理解也有很大的帮助。 文章的Motivation是： SGD的缺点： SGD现在后期调优时还是经常使用到，但SGD的问题...
【MNIST】
weixin_39915444的博客
08-11 4957
1. Normal Neural Network： 首先我用的是两层（input layer 和 output layer）的feed-forward的神经网络结构来训练数据, y = wx + b, 在输出层用的是softmax求概率，算loss用的是交叉熵的办法，选用梯度下降法来最小化loss更新参数w和b，通过对比output和input对应的label，计算出准确率，因为此网络结构较简单...
交叉熵损失用于mnist分类、Dropout用于两层神经网络用于mnist分类、Adam、不断减小的学习率用于mnist分类
qq_34514046的博客
08-20 388
softmax+交叉熵损失用于mnist分类 # coding: utf-8 import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data #载入数据集 mnist = input_data.read_data_sets("./MNIST_data",one_hot=True) #每个批次的...
pytorch mnist数据集识别
06-28
### 回答1： PyTorch可以用来训练和测试MNIST数据集的模型，实现手写数字的识别。MNIST数据集包含了60000张训练图片和10000张测试图片，每张图片都是28x28的灰度图像。我们可以使用PyTorch提供的数据加载器来读取数据集，然后使用卷积神经网络（CNN）或全连接神经网络（FCN）来训练模型。训练完成后，我们可以使用测试集来评估模型的准确率。 ### 回答2： PyTorch 是一种基于 Python 的开源机器学习库，可以帮助我们构建神经网络模型来识别 MNIST 手写数字数据集。MNIST 是一个广泛使用的手写数字数据集，由于其简洁和易于使用的特点，在计算机视觉中被视为基准测试。 使用 PyTorch 来识别 MNIST 数据集涉及以下步骤： 1. 数据预处理：MNIST 中的图像为 28X28 像素，灰度格式。我们需要将其转换为张量并进行标准化以进行内部使用。 2. 构建网络模型：我们可以使用 PyTorch 来定义模型的架构。通常，我们会选择使用具有两个或三个隐藏层的全连接神经网络结构。我们可以在 PyTorch 中定义网络层、激活函数以及输出层。 3. 训练模型：随机初始化模型参数后，我们可以通过前向传递来计算损失函数的值并使用反向传播来更新参数。使用 PyTorch 来训练模型通常需要定义优化器、损失函数和学习率等超参数。 4. 模型评估：在训练好模型之后，我们将使用测试数据集进行评估。我们可以计算模型的精度，将其与其他算法进行比较以及可视化模型输出结果。 通过 PyTorch，我们可以轻松地创建和训练各种神经网络模型，并说服自己的模型有效地区分出手写数字数据集中的不同数字。 总而言之，PyTorch 是一个非常强大的机器学习库，可以让我们轻松构建和训练神经网络，从而识别 MNIST 数据集中的手写数字。与传统方法相比，这种方法的优点在于可以轻松地编写和修改代码以及可视化结果，以便更好地理解模型如何进行判断。 ### 回答3： PyTorch是一种Python深度学习框架，可以帮助我们更轻松地从事深度学习。使用PyTorch可以实现各种机器学习和深度学习模型，其中也包括识别MNIST数据集。 MNIST数据集是一个手写数字图像数据集，包含60,000个训练样本和10,000个测试样本。每张图像都是一个28×28像素的灰度图像，每个像素的值介于0~255之间。 下面是使用PyTorch识别MNIST数据集的步骤： 1. 导入必要的库 导入PyTorch和MNIST数据集并进行数据预处理。 ```python import torch import torchvision.datasets as datasets from torchvision.transforms import transforms # 转换MNIST数据集为Tensor类型 transform = transforms.Compose([ transforms.ToTensor(), # 将图像转换为Tensor类型 transforms.Normalize((0.1307,), (0.3081,)) # 做归一化 ]) # 加载并预处理训练集 train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True) # 加载并预处理测试集 test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True) ``` 2. 定义模型 定义一个简单的卷积神经网络(Convolutional Neural Network, CNN)，包含两个卷积层和两个全连接层。 ```python class Net(torch.nn.Module): def __init__(self): super(Net, self).__init__() # 定义卷积层和全连接层 self.conv1 = torch.nn.Conv2d(1, 32, kernel_size=5, padding=2) self.conv2 = torch.nn.Conv2d(32, 64, kernel_size=5, padding=2) self.fc1 = torch.nn.Linear(64*7*7, 1024) self.fc2 = torch.nn.Linear(1024, 10) self.dropout = torch.nn.Dropout(0.5) def forward(self, x): # 卷积层 x = self.conv1(x) x = torch.nn.functional.relu(x) x = torch.nn.functional.max_pool2d(x, 2) # 卷积层 x = self.conv2(x) x = torch.nn.functional.relu(x) x = torch.nn.functional.max_pool2d(x, 2) # 全连接层 x = x.view(-1, 64*7*7) x = self.fc1(x) x = torch.nn.functional.relu(x) x = self.dropout(x) # 全连接层 x = self.fc2(x) return torch.nn.functional.softmax(x, dim=1) ``` 3. 训练模型 定义损失函数和优化器来训练模型。 ```python # 定义损失函数和优化器 criterion = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.01) # 训练模型 for epoch in range(10): for i, (images, labels) in enumerate(train_loader): # 将数据加载到GPU上 images = images.to(device) labels = labels.to(device) # 正向传播 outputs = model(images) loss = criterion(outputs, labels) # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() print('Epoch [{}/{}], Loss: {:.4f}' .format(epoch+1, 10, loss.item())) ``` 4. 测试模型 对测试集进行评估。 ```python # 测试模型 with torch.no_grad(): correct = 0 total = 0 for images, labels in test_loader: # 将数据加载到GPU上 images = images.to(device) labels = labels.to(device) # 正向传播 outputs = model(images) # 获取预测结果 _, predicted = torch.max(outputs.data, 1) # 统计正确率 total += labels.size(0) correct += (predicted == labels).sum().item() print('Test Accuracy: {:.2f} %'.format(100 * correct / total)) ``` 通过以上步骤，我们便可以使用PyTorch实现MNIST数据集的识别任务。其中，我们需要对数据集进行预处理，定义CNN模型，训练模型并评估模型准确率。通过这些步骤，我们可以更好地理解深度学习框架在实际应用中的使用方法并且对深度学习有更深入的理解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值