devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深度学习课程作业——手写数字识别（卷积神经网络）_随便从数据集中读入一张图片,并绘制出来。dataset支特下标索引,其中提取出:米的元

作者：小蓝xlanll | 2024-04-06 14:33:03

赞

踩

随便从数据集中读入一张图片,并绘制出来。dataset支特下标索引,其中提取出:米的元

本实验过程需要用到torchvision包，没有安装的小伙伴，windows用户可直接使用cmd命令，输入命令行pip install torchvision即可。【仍安装不了的，建议csdn直接查找安装教程】

一、加载数据集

1.1  导入实验可能用到的包、库等

  1. #导入所需要的包
  2. import torchvision.datasets as dsets
  3. import torchvision.transforms as transforms
  4. import torch 
  5. import torch.nn as nn
  6. import torch.optim as optim
  7. import torch.nn.functional as F
  8. import matplotlib.pyplot as plt
  9. import numpy as np
  10. import pandas as pd
  11. from torch.autograd import Variable
  12.  
  13. %matplotlib inline

1.2  加载数据集

使用pytorch自带的数据加载器，包括dataset(装载数据集)，sampler（采样数据集），以及dataloader（迭代循环数据集）

  1. #定义超参数
  2. image_size = 28   #图像的总尺寸28*28
  3. num_classes =10    #标签的种类数
  4. num_epochs = 20   #训练的总循环周期
  5. batch_size = 64  #一个撮批次的的等待小，64张图片
  6.  
  7.  
  8. #加载MNIST数据，如果没有下载过，就会在当前路径下新建、data目录，并把文件存放在其中
  9. #MNIST数据是属于torchvision包自带的数据，可以直接调用
  10.  
  11. #下载训练数据集
  12. train_dataset=dsets.MNIST(root='./data',   #文件存储路径
  13.                          train=True,     #提取训练集
  14.                          transform=transforms.ToTensor(),   #转为tensor类型，便于数据预处理
  15.                           download=True)       #找不到文件时，自动下载
  16.  
  17. #加载测试数据集
  18. test_dataset = dsets.MNIST(root='./data',train=False,
  19.                           transform=transforms.ToTensor())
  20.  
  21.  
  22. #训练数据集的加载器，DataLoader方法，可以自动将数据分（批）割成batch，顺序随机打乱
  23. train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
  24.                                          batch_size = batch_size,
  25.                                          shuffle=True)
  26.  
  27. '''我们希望将测试数据分成两部分，一部分作为验证（校验）数据，一部分作为测试数据。
  28. 验证数据用于检测模型是否过拟合，并调整参数，测试数据检验整个模型的工作'''
  29.  
  30. #首先，我们定义下标数组indices，它相对于所有test_dataset中数据的代码
  31. indices = range(len(test_dataset))
  32. indices_val = indices[:5000]     #取前5000份作为验证集数据的下标
  33. indices_test = indices[5000:]      #取后5000份作为测试集的下标
  34.  
  35.  
  36. #根据这些下标，构造两个数据集的SubsetRandomSampler采样器
  37. #校验集采样器的作用是：从数据集中indices_val，从indices_test抽取数据，它们会对下标进行采样
  38. sampler_val = torch.utils.data.sampler.SubsetRandomSampler(indices_val)
  39. sampler_test = torch.utils.data.sampler.SubsetRandomSampler(indices_test)
  40.  
  41. #根据两个采样器来定义加载器，注意将sampler_val和sampler_test分别赋值给validation_load和test_loadad
  42. #采样器和加载器连接到一起，就可以在加载数据的时候随机抽取
  43. validation_loader = torch.utils.data.DataLoader(dataset =test_dataset,
  44.                                                 batch_size =batch_size,
  45.                                                sampler = sampler_val)
  46.  
  47. test_loader = torch.utils.data.DataLoader(dataset =test_dataset,
  48.                                                 batch_size =batch_size,
  49.                                                sampler = sampler_test)

 这里提一个概念，在此作为笔记

下采样和上采样的区别：下采样就是缩小图像，在卷积神经网络中，池化层就是下采样，即对原图像进行减缩，使得原图像的某些信息被增强，丢弃多余的，冗余的信息

1.3  读取绘制手写数字图像

  1. #随便从数据集中读入一张图片，并绘制出来
  2. idx = 1001
  3.  
  4. #dataset支持下标索引，其中提取出来的每一个元素为features，target格式，即属性和标签
  5. #因此train_dataset[idx][0] 表示取该元素中的features,即取第idx批次的features中第0个图像
  6. muteimg = train_dataset[idx][0].numpy()
  7.  
  8. #由于一般的图像包含rgb三个通道，而MNIST数据集的图像都是灰度的，只有一个通道。
  9. #用imshow画图，会将灰度矩阵自动展现为彩色，不同灰度对应不同颜色，从黄到紫
  10.  
  11. plt.imshow(muteimg[0,...])  #取muteimg中的28*28像素点画图
  12. print('标签是：',train_dataset[idx][1])   #[idx][1]对应的是target
  13. print(muteimg.shape)  #（1,28,28）

二、基本的卷积神经网络

2.1  构建网络

我们将要调用PyTorch强大的nn.Module这个类来构建卷积神经网络，我们分成如下几个步骤：
1.首先，我们构造ConvNet类，它是对类nn.Module的继承
2.接着，复写init，以及forward两个函数，第一个为构造函数，每当类ConvNet被具体化一个实例时，会被调用，forward则是在运行神经网络正向的时候被自动调用
3.自定义自己的方法
ConvNet其实也是一个大容器，它里面有Conv2d，MaxPool2d等组件

（按我自己理解就是，先构造定义卷积神经网络中的各种模块、函数，然后再拼接调用、实现真正的运算）

  1. #定义卷积神经网络;4和8为人为指定的两个卷积层的厚度（feature map 的数量）
  2. depth =[4,8]
  3. class ConvNet(nn.Module):
  4.     def __init__(self):
  5.         #该函数在创建一个ConvNet对象的时候，即调用该语句：net=ConvNet()时，就会被调用
  6.         #首先调用父类相应的构造函数
  7.         super(ConvNet,self).__init__()
  8.         
  9.         #其次构造ConvNet需要用到的各个神经模块
  10.         """注意，定义组件并没有真正搭建这些组件，只是把基本建筑砖块先找好"""
  11.         self.conv1 = nn.Conv2d(1,4,5,padding=2)  #定义一个卷积层，输入通道为1，输出通道为4，窗口为5*5，填充为2
  12.         self.pool = nn.MaxPool2d(2,2)  #定义一个Pooling层，一个窗口为2*2的pooling运算
  13.         self.conv2 = nn.Conv2d(depth[0],depth[1],5,padding=2)  #第二层卷积，输入通道为depth[0]=4
  14.         #输出通道为depth[1]=8,窗口为5*5，填充为2
  15.         
  16.         #一个线性连接层，输入尺寸为最后一层立方体
  17.         self.fc1 = nn.Linear(image_size//4*image_size//4*depth[1], 512)
  18.         
  19.         #最后一层线性分类单元，输入为512，输出为要做分类的类别
  20.         self.fc2 = nn.Linear(512,num_classes) 
  21.     
  22.     def forward(self,x):
  23.         #该函数完成神经网络真正的前向运算，我们会在这里把各个组件进行实际的拼装
  24.         #x的尺寸：（batch_size,num_filters,image_width,image_height）
  25.         x = F.relu(self.conv1(x)) #第一层卷积，激活函数用Relu，为了防止过拟合
  26.         #x的尺寸：（batch_size,num_filters,image_width,image_height）
  27.         x = self.pool(x)
  28.         
  29.         #x的尺寸：（batch_size,depth[0],image_width,image_height)
  30.         x = F.relu(self.conv2(x))  #第三层又是卷积，窗口为5，输入输出通道分别是depth[0]=4,depth[1]=8
  31.         #x的尺寸：（batch_size,depth[1],image_width/2,image_height/2）
  32.         x = self.pool(x)  #第四层poolings，将图片缩小到原大小的1/4
  33.         
  34.         
  35.         #将立体的特征图Tensor压成一个一维向量
  36.         #view用于tensor的指定重新排列
  37.         #让x按照batch_size*(image_size//4)^2 * depth[1]的方式来排布向量
  38.         x = x.view(-1,image_size//4*image_size//4*depth[1]) 
  39.         #x尺寸：（batch_size,depth[1]*image_size//4*image_size//4）
  40.         
  41.         x = F.relu(self.fc1(x))  #第五层为全链接，Relu激活函数
  42.         #x的尺寸：（batch_size,num_classes）
  43.         
  44.         x = F.dropout(x,training=self.training)  #以默认为0.5的概率为对这一层进行dropout操作
  45.         x = self.fc2(x)  #全链接
  46.         
  47.         x = F.log_softmax(x,dim=1)  #输出层为log_softmax，即概率对数值log(p(x))
  48.         return x
  49.     
  50.     def retrieve_features(self,x):
  51.         #用于提取卷积神经网络的特征图，返回feature_map1,feature_map2为前两层卷积层的特征图
  52.         feature_map1 = F.relu(self.conv1(x))  #完成第一层卷积
  53.         x = self.pool(feature_map1)   #完成第一层pooling
  54.         feature_map2 = F.relu(self.conv2(x))   #第二层卷积，两层特征图都存储到了feature_map1,feature_map2中
  55.         return (feature_map1,feature_map2)
  56. def rightness(predictions,labels):
  57.     '''计算预测错误率的函数，其中predictions是模型给出的一组预测结果，batch_size、num_classes列的矩阵'''
  58.     pred = torch.max(predictions.data,1)[1]  #对任意一行（一个样本）的输出值的第一个维度，求最大 
  59.     rights = pred.eq(labels.data.view_as(pred)).sum() #将下标与labels中包含的类别进行比较，并累计得到总值
  60.     return rights,len(labels)  #返回正确的数量和这一次一共比较了多少元素

（之前记混或看不懂的地方）解释说明：

1.激活函数需作用于第五层全连接层，即fc1，而fc2不需被激活函数作用 。

2.经过两层的polling（池化），原图像变为原来的1/4，故有image_size//4

各函数作用：ConvNet定义卷积神经网络；forward完成前馈神经网络运算；retrieve_features存储特征图

2.2  运行模型

  1. net=ConvNet()  #此时会调用__init__()函数
  2. criterion=nn.CrossEntropyLoss()   #交叉熵损失函数
  3. optimizer=optim.SGD(net.parameters(),lr=0.001,momentum=0.9)
  4. record=[]   #记录准确率等数值
  5. weights=[]   #每若干步就记录一次卷积核
  6. for epoch in range(num_epochs):   #循环周期设定为20次
  7.     train_rights=[]     #记录训练集准确率
  8.     '''下面的enumerate是构造一个枚举器的作用。就是我们在对train_loader做循环迭代的时候，
  9.     enumerate会这个数字就被记录在了batch_idx之中，它就等于0，1，2，……
  10.     train_loader每迭代一次，就会吐出来一对数据data和target，分别对应着一个batch中的手写数字'''
  11.     for batch_idx,(data,target) in enumerate(train_loader):
  12.         #Tensor转化为Variable，data为一批图像，target为一批标签
  13.         data,target=Variable(data),Variable(target)
  14.         net.train()       #打开dropout，防止过拟合
  15.         
  16.         output = net(data)  #神经网络完成一次前馈的计算过程，得到预测输出output
  17.         
  18.         #将output与target比较，计算误差，如标签是数字7，而通过net预测输出的output却是5，7与5之间存在误差
  19.         loss=criterion(output,target)  
  20.         optimizer.zero_grad() #清空梯度，因为Variable中requires_grad=True会默认累加梯度
  21.         loss.backward()   #反向传播
  22.         optimizer.step()    #一步随机梯度下降算法
  23.         right=rightness(output,target)
  24.         train_rights.append(right)
  25.         
  26.         if batch_idx %100 == 0:
  27.             net.eval()
  28.             val_rights=[]
  29.             '''开始在校验数据集上做循环，计算校验集上面的准确度'''
  30.  
  31.             for (data,target)in validation_loader:
  32.                 data,target=data.clone().requires_grad_(),target.clone().detach()
  33.                 output=net(data)
  34.                 right=rightness(output,target)
  35.                 val_rights.append(right)
  36.             #train_r[0]/trai_r[1]是训练集的分类准确度，另一个是校验集的
  37.             train_r=(sum([tup[0] for tup in train_rights]),sum([tup[1] for tup in train_rights]))
  38.             val_r=(sum([tup[0] for tup in val_rights]),sum([tup[1] for tup in val_rights]))
  39.             print(val_r)
  40.             print('训练周期:{}[{}/{}({:.0f}%)]\tLoss:{:.6f}\t训练正确率:{:.2f}%\t校验正确率:{:.2f}%'.format(
  41.                   epoch,batch_idx * batch_size,len(train_loader.dataset),
  42.                   100.*batch_idx/len(t。rain_loader),
  43.                   loss.data,
  44.                   100.*train_r[0].numpy()/train_r[1],
  45.                   100.*val_r[0].numpy()/val_r[1]))
  46.             #将准确率和权重等数值加载到容器中，方便后续处理
  47.             record.append((100-100.*train_r[0]/train_r[1],100-100.*val_r[0]/val_r[1]))
  48.             #weight记录了训练周期中所有卷积核的演化过程，net.conv1.weight提出了第一层卷积和的权重
  49.             #clone备份weight.data中得到数据，否则weight.data变化时，列表中的每一项数据也会联动
  50.             #所以这里使用clone函数十分重要
  51.             weights.append([net.conv1.weight.data.clone(),net.conv1.bias.data.clone(),
  52.                             net.conv2.weight.data.clone(),net.conv2.bias.data.clone()])

以下是部分训练结果截图：

 

 绘制训练过程中的误差曲线

  1. #绘制训练过程的误差曲线，校验集和测试集上的错误率
  2. plt.figure(figsize=(10,7))
  3. plt.plot(record)   #record记录了每一个打印周期记录的训练和校验数据集上的准确度
  4. plt.xlabel('Steps')
  5. plt.ylabel('Error rate')

结果如图：

2.3  在测试集上进行分类

  1. #在测试集上分批运行，并计算总的正确率
  2. net.eval()   #关闭dropout，标志模型当前为运行阶段
  3. vals = [] #记录准确率
  4.  
  5. #对测试数据集进行循环
  6. for data,target in test_loader:
  7.     data.target = data.clone().detach().requires_grad_(True),target.clone().detach()
  8.     output =net(data)  #将特征数据喂入网络，得到分类的输出
  9.     val = rightness(output,target)   #获得正确样本数以及总样本数
  10.     vals.append(val)   #记录结果
  11.  
  12. #计算准确率
  13. rights = (sum([tup[0] for tup in vals]),sum([tup[1] for tup in vals]))
  14. right_rate = 100.*rights[0].numpy() / rights[1]
  15. print(right_rate)
  16.  
  17. #随便从测试集中读取一张图片，检验模型的分类结果，并绘制出来
  18. idx = 2000
  19. muteimg = test_dataset[idx][0].numpy()  
  20. plt.imshow(muteimg[0,...])   #test_dataset的每一个数据由data和target组成，其中data为像素点矩阵，target为该图像标签数字
  21. print('标签是：',test_dataset[idx][1])
  22. print(test_dataset[idx])
  23.  
  24. #提取第一层卷积层的卷积核
  25. plt.figure(figsize=(10,7))
  26. for i in range(4):
  27.     plt.subplot(1,4,i+1)
  28.     plt.axis('off')    #关闭坐标轴
  29.     plt.imshow(net.conv1.weight.data.numpy()[i,0,...]) 
  30.     #第0个的第一行的所有数据为一个特征图，第1个的第一行的所有数据为第二个特征图，以此类推
  31.  
  32.  
  33. #上面的卷积核我们不能够很好地解读，因此将其对应的特征图输出，便于理解
  34. #先定义读入的图片，其中unsqueeze作用是在最前面添加一维
  35. #目的是让input_x的tensor为四维，才能输入给net，添加的维是batch那一维
  36. input_x = test_dataset[idx][0].unsqueeze(0)
  37. #features是有两个元素的列表，分别表示第一层和第二层的所有特征图
  38. feature_maps = net.retrieve_features(Variable(input_x))
  39. plt.figure(figsize=(10,7))
  40.  
  41. #打印出4个特征图
  42. for i in range(4):
  43.     plt.subplot(1,4,i+1)
  44.     plt.imshow(feature_maps[0][0,i,...].data.numpy())

2.4  滤波器（卷积核）的演化过程

  1. #将记录在容器中的卷积核权重历史演化数据打印出来
  2. i = 0
  3. #tup是tuple元组的意思
  4. for tup in weights:
  5.     if i % 10 ==0:
  6.         layer1 = tup[0]
  7.         fig = plt.figure(figsize=(10,7))
  8.         for j in range(4):
  9.             plt.subplot(1,4,j+1)
  10.             plt.axis('off')
  11.             plt.imshow(layer1.numpy()[j,0,...])
  12.     i +=1

部分结果如图所示：

        由上图，我们可以看到，卷积核的演化过程共有4列，即以第一行的四个特征图为首，
依次不断地往下演化，即每一列对应一个卷积核 。

 

   【绘制第二层卷积核】

  1. #绘制第二次的卷积核，每一列对应一个卷积核，一共8个卷积核（人为设定的4,8两个层的卷积厚度）
  2. plt.figure(figsize=(15,10))
  3. for i in range(4):
  4.     for j in range(8):
  5.         plt.subplot(4,8,i*8+j+1)
  6.         plt.axis('off')
  7.         plt.imshow(net.conv2.weight.data.numpy()[j,i,...])
  8.  
  9. #绘制第二层的特征图，一共八个
  10. plt.figure(figsize=(10,7))
  11. for i in range(8):
  12.     plt.subplot(2,4,i+1)
  13.     plt.axis('off')
  14.     plt.imshow(feature_maps[1][0,i,...].data.numpy())

 

结论：从上述图像看出，图像的抽象程度变得更高了。由于池化的作用，即对图像进行模糊处理，  
一些多余的图像信息被丢弃了，这也证明了卷积网络的抽象提取能力 

2.5  卷积神经网络的健壮性

所谓健壮性，就是模型消除局部相关性的能力。即数字在图像平移后，模型是否仍能很好地正确预测出该数字

  1. #随机挑选一张图片，把它往左平移w个单位，然后考察分类结果是否有变化
  2.  
  3. #提取test_dataset中第idx个批次第0个图像第0个通道对应的图像，定义为c
  4. #原图像即为28*28， 因为这个是单通道图像
  5. '''test_data[idx][0]的维度是（1,28,28）,即1个28行28列的矩阵，当我们
  6.    取第1个时，即test_dataset[idx][0][0],可得到28行28列的二维张量'''
  7. c = test_dataset[idx][0][0]   #shape为28*28
  8.  
  9. d = torch.zeros(c.size())  #全0的28×28的矩阵
  10. w = 3  #平移的长度为3个像素
  11.  
  12.  
  13.  
  14. #对于d中的任意像素i，j  ，等于c中的i，j+w位置的像素（即d为c向左平移后的位置）
  15. for i in range(c.size()[0]):
  16.     for j in range(0,c.size()[1]-w):
  17.         d[i,j] = c[i,j+w]
  18.  
  19. feature_maps = net.retrieve_features(Variable(c.unsqueeze(0).unsqueeze(0)))  #
  20. plt.figure(figsize=(10,7))
  21.  
  22. #打印出4个特征图
  23. for i in range(4):
  24.     plt.subplot(1,4,i+1)
  25.     plt.imshow(feature_maps[0][0,i,...].data.numpy())
  26.  
  27.  
  28. #将d输入神经网络，得到分类结果pred，并打印
  29. prediction = net(d.unsqueeze(0).unsqueeze(0))
  30.  
  31. ''' torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)
  32.     按维度dim 返回最大值，并且返回索引'''
  33. pred = torch.max(prediction.data,1)[1]  #[1]即返回最大值对应的索引
  34. print(pred)
  35.  
  36. #提取d对应的features特征图结果
  37. feature_maps = net.retrieve_features(Variable(d.unsqueeze(0).unsqueeze(0)))  
  38.  
  39. plt.figure(figsize=(10,7))
  40. #打印出4个特征图
  41. for i in range(4):
  42.     plt.subplot(1,4,i+1)
  43.     plt.imshow(feature_maps[0][0,i,...].data.numpy())
  44.     
  45. plt.figure(figsize=(10,7))
  46. for i in range(8):
  47.     plt.subplot(2,4,i+1)
  48.     plt.imshow(feature_maps[1][0,i,...].data.numpy())
  49.  
  50.

结论：平移数字输入后得到第二层特征图 。首先，网络打印出来的结果是6，说明我们的模型训练得能正确得预测出输入的数字，  并且对3个像素点的平移具有很好干抗干扰性，体现出卷积神经网络很强的健壮性。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/372509
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号