基于Pytorch的mnist的分类

最新推荐文章于 2024-04-23 22:04:46 发布

pinn山里娃

最新推荐文章于 2024-04-23 22:04:46 发布

阅读量1k

点赞数 6

分类专栏：深度学习文章标签：神经网络

本文链接：https://blog.csdn.net/weixin_45521594/article/details/104314482

版权

深度学习专栏收录该内容

9 篇文章 1 订阅

订阅专栏

基于Pytorch的mnist的分类

训练集和测试集的划分非常重要。在机器学习模型设计时必须有一个单独的测试集（不用于训练而是用来评估这个模型的性能），才能更容易把模型推广到其他数据集上

mnist中图片包含28x28像素点，可以用一个数组来描述，这个数组可以张成一个向量，长度为784，保证每张照片以相同方式展开。从这个角度看，就是784维向量空间的点，然后可以进行比较。

借助Pytorch搭建网络

导入需要的库

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

定义参数

BATCH_SIZE = 523  	# batch_size即每批训练的样本数量
epochs = 20			# 循环次数
DEVICE=torch.device("cuda" if torch.cuda.is_available() else "cpu")    #判断是否能在GPU上进行运算

下载数据集

训练集

train_loader = torch.utils.data.DataLoader(                 # vision.utils : 用于把形似 (3 x H x W) 的张量保存到硬盘中，给一个mini-batch的图像可以产生一个图像格网。
        datasets.MNIST('data', train=True, download=True,
                       transform=transforms.Compose([
                           transforms.ToTensor(),       # 图像转化为Tensor
                           transforms.Normalize((0.1307,), (0.3081,))       # 标准化
                       ])),
        batch_size=BATCH_SIZE, shuffle=True)            # shuffle() 方法将序列的所有元素随机排序

torchvision.dataset作用是下载数据集，第一次调用时会自动从网上获取数据，

train来指定获取训练数据集或测试数据集
transforms.ToTensor()是将数据转化为tensor
transforms.Normalize((0.1307,), (0.3081,))是进行标准化
torch.utils.data.DataLoader（）利用下载的数据集来创建一个读取小批量数据样本的DataLoader实例
- batch_size是每批训练的样本数量
- shuffle() 方法将序列的所有元素随机排序
测试集

test_loader = torch.utils.data.DataLoader(
        datasets.MNIST('data', train=False, transform=transforms.Compose([
                           transforms.ToTensor(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=BATCH_SIZE, shuffle=True)            # shuffle() 方法将序列的所有元素随机排序

定义网络

网络的定义是最重要的部分，如何设置内部网络结构，往往就决定了你设置模型优劣
这里网络设置的是三个个卷积层，以及两个全连接层，在卷积层以及全连接层之间分别设置了激活函数，池化函数分别试验他们各自作用
下面解析各自层之间参数传递关系
- conv1(1,12,5)由于该图片为黑白图输入通道为1，卷积核为5x5，输出通道为12，输出维度28-5+1=24，输出维度12x24x24
- 经过池化层维度减半为12，输出shape为12x12x12
- conv2（12,20,3）输入通道与上一层输出通道对应，卷积核为3，输出维度为12-3+1=10，输出shape为20x10x10
- - conv2（20,40,3）输入通道与上一层输出通道对应，卷积核为3，输出维度为10-3+1=8，输出shape为40x8x8
- Linear需要接收的是展平后的多维的卷积成的特征图，需要使用view()函数，-1是根据输入数据自动设定
- nn.Linear(4088, 500)，输出为50
- nn.Linear(500, 10)，输出为10,进行10分类

class Net(nn.Module): # 继承model
    def __init__(self):
        super().__init__()
        # 28x28
        self.conv1=nn.Conv2d(1,12,5)         # 12, 24x24
        self.conv2=nn.Conv2d(12, 20,3)       #20, 10x10
        self.conv3=nn.Conv2d(20, 40,3)       #20, 10x10
        self.batchnorm2d = nn.BatchNorm2d(40)
        self.fc1=nn.Linear(40*8*8, 500)
        self.fc2=nn.Linear(500, 10)
    def forward(self, x):      #网络传播结构
        in_size=x.size(0)# in_size 为 batch_size（一个batch中的Sample数）
        # 卷积层 -> relu -> 最大池化
        out = self.conv1(x)     # 24
        out = F.relu(out)
        out = F.max_pool2d(out, 2, 2)  # 12
        out = self.conv2(out)  # 10
        out = F.relu(out)
        out = self.conv3(out)
        out = F.relu(out)
        out =  self.batchnorm2d(out)
        out = out.view(in_size, -1)    # view()函数作用是将一个多行的Tensor,拼接成行。
        # 输出前的预处理
        out = self.fc1(out)
        out = F.relu(out)
        out = self.fc2(out)
        # softmax
        out = F.log_softmax(out, dim=1)
        # 返回值 out
        return out

网络实例化与优化器

model = Net().to(DEVICE)
optimizer = optim.Adam(model.parameters())

定义训练函数

将训练的所有操作封装到函数Train中，这样在最后直接调用函数就显得非常简洁
采用的损失函数是torch.functional.nll_loss，后面讨论环节也会分析不同loss函数的结果差异
with torch.no_grad()表示不反向求导。训练过程需要反向求导（去更新优化模型参数），测试过程不需要反向求导。
print(‘Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}’.format(
epoch_i, batch_idx * len(data), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.item()))采用了比较简洁方式将结果输出

def train(model, device, train_loader, optimizer, epoch):
    model.eval()
    for  epoch_i in range(epoch+1):
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = data, target      # CPU转GPU
            optimizer.zero_grad()               # 优化器清零
            output = model(data)                # 由model，计算输出值
            loss = F.nll_loss(output, target)   # 计算损失函数loss
            loss.backward()                     # loss反向传播
            optimizer.step()                    # 优化器优化
            if(batch_idx+1)%30 == 0:            # 输出结果
                print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                    epoch_i, batch_idx * len(data), len(train_loader.dataset),
                    100. * batch_idx / len(train_loader), loss.item()))

def test(model, device, test_loader):
    test_loss = 0                           # 损失函数初始化为0
    correct = 0                             # correct 计数分类正确的数目
    with torch.no_grad():           
        for data, target in test_loader:    # 遍历所有的data和target
            data, target = data.to(device), target.to(device)   # CPU -> GPU
            output = model(data)            # output为预测值，由model计算出
            test_loss += F.nll_loss(output, target, reduction='sum').item()     ### 将一批的损失相加
            pred = output.max(1, keepdim=True)[1]       ### 找到概率最大的下标
            correct += pred.eq(target.view_as(pred)).sum().item()

    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)))

函数调用

train(model, DEVICE, train_loader, optimizer, epoch)
test(model, DEVICE, test_loader)

结果分析

构建不同卷积层对输出结果分析

在将循环次数设置为20下，然后取平均值
- 两层卷积网，在测试集上平均损失为 0.0363，
- 三层卷积网，在测试集上平均损失为0.0296
- 对结果进行分析，对于精度略有提升，还可以进行更多层的对比
两层卷积层、

class Net(nn.Module): # 继承model
    def __init__(self):
        super().__init__()
        # 28x28
        self.conv1=nn.Conv2d(1,12,5)         
        self.conv2=nn.Conv2d(12, 20,3)       
        self.fc1=nn.Linear(20*10*10, 500)
        self.fc2=nn.Linear(500, 10)
    def forward(self, x):      #网络传播结构
        # 卷积层 -> relu -> 最大池化
        out = self.conv1(x)     # 24
        out = F.relu(out)
        out = F.max_pool2d(out, 2, 2)  # 12
        out = self.conv2(out)  # 10
        out = F.relu(out)
        out = out.view(in_size=x.size(0), -1)    # view()函数作用是将一个多行的Tensor,拼接成行。
        # 输出前的预处理结束，提取完特征信息
        out = self.fc1(out)
        out = F.relu(out)
        out = self.fc2(out)
        # softmax
        out = F.log_softmax(out, dim=1)
        # 返回值 out
        return out

Test set: Average loss: 0.0363, Accuracy: 9889/10000 (99%)

三层卷积层

class Net(nn.Module): # 继承model
    def __init__(self):
        super().__init__()
        # 28x28
        self.conv1=nn.Conv2d(1,12,5)         # 12, 24x24
        self.conv2=nn.Conv2d(12, 20,3)       #20, 10x10
        self.conv3=nn.Conv2d(20, 40,3)       #20, 10x10
        self.batchnorm2d = nn.BatchNorm2d(40)
        self.fc1=nn.Linear(40*8*8, 500)
        self.fc2=nn.Linear(500, 10)
    def forward(self, x):      #网络传播结构
        in_size=x.size(0)# in_size 为 batch_size（一个batch中的Sample数）
        # 卷积层 -> relu -> 最大池化
        out = self.conv1(x)     # 24
        out = F.relu(out)
        out = F.max_pool2d(out, 2, 2)  # 12
        out = self.conv2(out)  # 10
        out = F.relu(out)
        out = self.conv3(out)
        out = F.relu(out)
        out =  self.batchnorm2d(out)
        out = out.view(in_size, -1)    # view()函数作用是将一个多行的Tensor,拼接成行。
        # 输出前的预处理
        out = self.fc1(out)
        out = F.relu(out)
        out = self.fc2(out)
        # softmax
        out = F.log_softmax(out, dim=1)
        # 返回值 out
        return out

Test set: Average loss: 0.0296, Accuracy: 9898/10000 (99%)

卷积层之间的通道数设置

卷积层之间的通道数设置为超参，如何设置，影响着结果，以两层网络为例，改变第一层卷积网络输出通道，看测试集上的结果，循环次数设置为20
- 输出通道为10,11,12,13,14,测试集上平均损失为
  - 0.0315，0.0313，0.03630，0386，0.0284
  - 在经调试，第一层通道设置为14较好

        self.conv1=nn.Conv2d(1,10,5)         # 改变输出通道10,11,12,13，14
        self.conv2=nn.Conv2d(10, 20,3)       #对应上一层输出通道
        self.fc1=nn.Linear(20*10*10, 500)
        self.fc2=nn.Linear(500, 10)

卷积层间的relu以及pooling

在卷积层后将sigmoid()都改成使用F.relu（和nn.relu产不多），AlexNet相对于LeNet有一改变就是使用了relu函数，使用了relu克服sigmoid在反向求导时，导数不可算的情况
池化层作用：池化层能够克服过拟合。池化层的存在，会不断提取一定范围内最强烈的特征，并且缩小张量的大小，使得大范围内的特征组合也能够捕捉到，pooling的结果是使得特征减少，参数减少，但pooling的目的并不仅在于此。pooling目的是为了保持某种不变性（旋转、平移、伸缩等），常用的有mean-pooling，max-pooling和Stochastic-pooling三种，该文建立的网络中采取的是最大池化
- 特征提取的误差主要来自两个方面：
  - 邻域大小受限造成的估计值方差增大；
  - 卷积层参数误差造成估计均值的偏移
- 一般来说，mean-pooling能减小第一种误差，更多的保留图像的背景信息；
- max-pooling能减小第二种误差，更多的保留纹理信息；
- Stochastic-pooling则介于两者之间，通过对像素点按照数值大小赋予概率，再按照概率进行亚采样，在平均意义上，与mean-pooling近似，在局部意义上，则服从max-pooling的准则。
在设置了最大池化与不进行池化，测试集上平均损失进行对比，循环次数设置为20

损失函数

损失函数有许多，在模型中选择了不同的loss函数对于结果也通样是有影响的，在该文中选择的是torch.functional.null_loss,
- 用于多分类的负对数似然损失函数（Negative Log Likelihood）
  $loss(x,label)=-X_{label}$
  事实上，nn.CrossEntropyLoss 也是调用这个函数。注意这里的和交叉熵损失里的不一样,nll是经过 logSoftMax运算后的数值

小结

对于不同的问题设计结构，再进行调参，进行有目标的，设计，得到的效果也会更好，在此文中仅仅只是对模型中部分进行了对比测试，具体的参数也只是进行小范围，以测试集上的效果为目标进行调参

总结与感悟

在学习了Pytorch相关资料后，实现了mnist分类任务，从开始的一点不会，通过查资料，慢慢读懂一部分程序，这个过程还是学到了不少，但是由于里面内容是很丰富，还有许多问题理解得不够深入仅仅是会用，在下一步学习中，多思考，多查资料，多记笔记，也要提升自己的编程能力。
参考
https://blog.csdn.net/qq_41683065/article/details/91374189

pinn山里娃

关注

6
点赞
踩
20

收藏

觉得还不错? 一键收藏
打赏
0
评论
基于Pytorch的mnist的分类

基于Pytorch的mnist的分类训练集和测试集的划分非常重要。在机器学习模型设计时必须有一个单独的测试集（不用于训练而是用来评估这个模型的性能），才能更容易把模型推广到其他数据集上mnist中图片包含28x28像素点，可以用一个数组来描述，这个数组可以张成一个向量，长度为784，保证每张照片以相同方式展开。从这个角度看，就是784维向量空间的点，然后可以进行比较。借助Pytorc...
复制链接

扫一扫