Press "Enter" to skip to content

神经网络中的Heloo,World,基于MINST数据集的LeNet

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

前言

 

最近刚开始接触机器学习,记录下目前的一些理解,以及看到的一些好文章mark一下

 

1.MINST数据集

 

MNIST 数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据.

 

MINST手写字体识别,大概相当于机器学习领域的”Hello World”的存在

 

1.1数据集的下载即载入

 

1.2可以去官网下载 MNIST handwritten digit database, Yann LeCun, Corinna Cortes and Chris Burges

 

 

2.1.通过pytorch的dataloader直接下载

 

# 设置训练数据集
data_train = torchvision.datasets.MNIST(
    root='./data',
    train=True,
    transform=torchvision.transforms.ToTensor(),
    download=True)
#将训练数据集载入DataLoader
train_loader = torch.utils.data.DataLoader(data_train, batch_size=100, shuffle=True)

 

2.2.1torchvision.datasets

 

torchvision.datasets是pytorch中集成的可以加载多个数据集的工具,包含图片分类,语义分割,视频等数据集,详情见

 

[Datasets — Torchvision 0.12 documentation (pytorch.org)]( https://pytorch.org/vision/stable/datasets.html?highlight=utils data dataloader)进入该页面我们找到MINST就可以查看到使用MINST所需要的参数

 

 

也可以在pycharm中定位到这个代码,按Ctrl+P查看需要的参数,我们重点关注这几个

 

 

1.root指定数据集的路径,2.train设置该数据是否用来训练,3.download参数用来设置是否下载该数据集默认False

 

4.transform在pytorch封装了许多图像处理的方法,如填充(Pad),Resize,CenterCrop(中心裁剪),Grayscale(灰度图),更多方法见: Illustration of transforms — Torchvision 0.12 documentation (pytorch.org)

 

而这里的ToTensor是常用的步骤,可以实现将PIL格式或者numpy.ndarray格式的输入转化为tensor数据类型

 

2.3data.DataLoader

 

DataLoader的意义就是做数据打包,参数含义重点关注这几个

 

 

首先的1. dataset用来指定传入的数据集,2. batch_size用来指定多少个数据为一组(如=64代表一次传入64张图片),太大可能爆显存,3. shuffle用来设置是否随机采样(可以理解为图片顺序打乱?),4. num_workers代表任务数量(理解为线程数),5. drop_last设置是否丢弃最后的图片(当最后几张图片不满一个batch_size时丢弃)

 

3.MINST的内容的展示

 

(22条消息) MNIST数据集转为图片形式输出_zzZ_CMing的博客-CSDN博客_mnist图片 这篇博客有写怎幺将MINST的数据保存到本地

 

显示几个数据

 

#enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标
examples = enumerate(train_loader)
#next() 返回迭代器的下一个项目。
batch_idx, (example_data, example_targets) = next(examples)
# 绘制查看数据集内容
fig = plt.figure()
for i in range(16):
  plt.subplot(4,4,i+1)  #设置图像显示为2行3列
  plt.tight_layout()  #tight_layout会自动调整子图参数,使之填充整个图像区域。
  plt.imshow(example_data[i][0], cmap='gray')
  plt.title("Truth Number: {}".format(example_targets[i]))
  plt.xticks([])    #不显示横纵坐标
  plt.yticks([])
plt.show()

 

 

debug一下,发现图像的尺寸为[1000,1,28,28],分别代表batch_size为1000,chanel(通道)数为1(灰度图),图像尺寸为28×28

 

 

2. MINST的训练和测试方法

 

2.1定义训练方法

 

def train(net, epoch=1):
    net.train()#设置training mode
    run_loss = 0#损失
    for num_epoch in range(epoch):#设置训练的轮数为epoch轮
        print(f'epoch {num_epoch}')
        for i, data in enumerate(train_loader):#i为索引,data为数据
#            x, y = data[0], data[1]#也可以这幺写
            x,y = data#x,y分别代表数据和标注
            outputs = net(x) #将数据放入神经网络中
            loss = criterion(outputs, y) #计算损失
            optimizer.zero_grad()#梯度清零
            loss.backward()#反向传播
            optimizer.step() #优化器更新参数
            run_loss += loss.item()
            if i % 100 == 99:#每训练100轮打印一次
                print(f'[{(i + 1) * 100} / 60000] loss={run_loss / 100}')
                run_loss = 0
                test(net)

 

这段代码初学者肯定比较懵逼,比如说我,下面简单说几个

 

net.train()的作用如下

 

可以看到,其实设不设置影响都不大,仅当你的模型中有使用Dropout()层或BatchNorm层时会有影响

 

 

为什幺要梯度清零

 

由于pytorch的动态计算图,当我们使用loss.backward()和opimizer.step()进行梯度下降更新参数的时候,梯度并不会自动清零。并且这两个操作是独立操作。如果梯度不清零,pytorch中会将上次计算的梯度和本次计算的梯度累加。

 

有兴趣可以看这里 (60 封私信 / 84 条消息) PyTorch中在反向传播前为什幺要手动将梯度清零? – 知乎 (zhihu.com)

 

损失函数

 

损失函数使用主要是在模型的训练阶段,每个批次的训练数据送入模型后,通过前向传播输出预测值,然后损失函数会计算出预测值和真实值之间的差异值,也就是损失值。得到损失值之后,模型通过反向传播去更新各个参数,来降低真实值与预测值之间的损失,使得模型生成的预测值往真实值方向靠拢,从而达到学习的目的。我们接下来使用的是nn.CrossEntropyLoss()

 

优化器

 

优化器或者优化算法,是通过训练优化参数,来最小化(最大化)损失函数。为了使模型输出逼近或达到最优值,我们需要用各种优化策略和算法,来更新和计算影响模型训练和模型输出的网络参数。接下来的我们使用的是Adam(自适应学习率优化算法)。关于各种优化器的对比详情见 深度学习之——优化器 – 简书 (jianshu.com)

 

这几天看别人代码,感觉还是SGD(随机梯度下降)用的比较多

 

 

2.2定义测试方法

 

def test(net):
    net.eval()#和上面的net.train()一样
    test_loader = torch.utils.data.DataLoader(data_train, batch_size=10000, shuffle=False)
    test_data = next(iter(test_loader))
    with torch.no_grad():
#        x, y = test_data[0], test_data[1]
    x,y = data
        outputs = net(x)
        pred = torch.max(outputs, 1)[1]
        print(f'test acc: {sum(pred == y) / outputs.shape[0]}')#计算出损失(每个之和除以数量)

 

3.定义神经网络

 

3.1 神经网络

 

什幺是卷积神经网络(CNN),具体可以看这篇文章: 一文看懂卷积神经网络-CNN(基本原理+独特价值+实际应用)- 产品经理的人工智能学习库 (easyai.tech)

 

人工神经网络(Artificial Neural Networks,ANN)是一种模拟生物神经系统的结构和行为,进行分布式并行信息处理的算法数学模型。ANN通过调整内部神经元与神经元之间的权重关系,从而达到处理信息的目的。而卷积神经网络(Convolutional Neural Network,CNN)是一种前馈神经网络,它由若干卷积层和池化层组成,尤其在图像处理方面CNN的表现十分出色。

 

 

一般的卷积神经网络结果如下

 

 

3.1.1. 卷积层

 

在pytorch中卷积被封装在nn.Conv2d()中,参数如下,后几个我没用过

 

 

关于卷积的输出尺寸怎幺计算官网也有给出

 

 

光看这个直接给人看傻了,我们看点直观的例子,如下左图所示,下方灰色的3x3kernel是我们定义的卷积核,下方是我们输入的图像,四周白色的方框代表我们的填充(padding=1),卷积核不断在输入图像上移动并计算,最终得到上方绿色的输出图像

 

再举个例子来求图像的输出尺寸,如下有一个28×28的输入,我们假设padding=2,步长为1,卷积核为5×5

 

 

则输出的图像尺寸就应该为(28 – 2 * 2 – 1 * (5-1)-1/1)+1 = 28,所有输出的尺寸也应该为28×28,即不变

 

3.1.2. 池化层

 

池化层分最大池化层和平均池化层,对应代码中的MaxPool2d,和AvgPool2d,池化层能很好的压缩图片信息,而且保留一部分特征

 

最大池化层的作用过程如下,输入图像为5×5,我们用一个3×3的核对它做最大池化,每次都求出3×3中的最大值来得到结果,ceil_model为False是用来设定把不满足3×3的结果都丢弃掉(类似之前谈的drop_last)

 

平均池化也同理,只不过不是求出最大的而是求一个平均

 

3.1.3. 激励层

 

激活函数的作用

 

神经网络中使用激活函数来加入非线性因素,提高模型的表达能力。

 

如果不用激励函数(其实相当于激励函数是f(x) = x),在这种情况下你每一层节点的输入都是上层输出的线性函数,很容易验证,无论你神经网络有多少层,输出都是输入的线性组合,与没有隐藏层效果相当,这种情况就是最原始的感知机(Perceptron)了,那幺网络的逼近能力就相当有限。正因为上面的原因,需要引入非线性函数作为激励函数,这样深层神经网络表达能力就更加强大(不再是输入的线性组合,而是几乎可以逼近任意函数)。

 

常用的非线性激活函数有nn.ReLu()和nn.Sigmoid()他们的图像如下,可以看到ReLu在大于0时为x,小于0时为0

 

 

3.2 LeNet

 

关于LeNet的几个版本介绍 LeNet:第一个卷积神经网络 (ruanx.net)

 

LeNet 是几种神经网络的统称,它们是 Yann LeCun 等人在 1990 年代开发的。一般认为,它们是最早的 卷积神经网络 (Convolutional Neural Networks, CNNs)。模型接收灰度图像,并输出其中包含的手写数字。LeNet 包含了以下三个模型:

LeNet-1:5 层模型,一个简单的 CNN。
LeNet-4:6 层模型,是 LeNet-1 的改进版本。
LeNet-5:7 层模型,最着名的版本。

这里我们使用LeNet5这个经典的神经网络,网络模型如下总共有7层

 

 

可以发现输入图像是32×32的,但MINST数据集的图像尺寸为28×28,可以得出padding=2,第一个卷积层输入chanel=1,输出chanel=6,第一个池化层从28×28到14×14,推断出kernel为2×2,按上图模型编写代码

 

class LeNet5(nn.Module):
    def __init__(self):
        super().__init__()
        #这个注释的比较详细
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2)
        # self.pool1 = nn.AvgPool2d(2) #本来LeNet使用的平均池化不如最大池化
        self.pool1 = nn.MaxPool2d(kernel_size=2)
        self.pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # self.pool2 = nn.AvgPool2d(2)
        self.pool2 = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
#前向传播
    def forward(self, x):
        # x = torch.tanh(self.conv1(x)) #tanh在这里不如relu
        x = torch.relu(self.conv1(x))
        x = self.pool1(x)
        # x = torch.tanh(self.conv2(x))
        x = torch.relu(self.conv2(x))
        x = self.pool2(x)
        x = x.view(-1, 16 * 5 * 5)#改变矩阵维度
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        return x

 

在LeNet上训练20轮后的acc最高可以达到99.86%可以说相当可以了,

 

 

在测试一下,在MINST数据集下的正确率确实很高了

 

 

但我自己手写了几个,发现正确率不怎幺样,原因还不清楚是为什幺,难道是我字太丑了?。。。还是说这个模型过拟合了?。。。

 

还有个坑说一下,一定要转灰度图单通道,不然会莫名其妙报很多错

 

4.完整代码

 

是cpu版本的就用cpu训练,有gpu版本的就用gpu训练,要快很多,但是要注意,你用的什幺设备训练出来的模型保存再加载的时候要指明设备。意思就是你不能用cpu训练了一个模型,然后你再加载的时候又用cuda来加速

 

import torch
import torchvision
import torch.nn as nn
import torchvision.transforms as transforms
from torch.nn import ReLU
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
from torch.optim import optimizer
from PIL import Image
# 用来记录最佳的acc
best_acc = 0
trans_to_tensor = transforms.Compose([
    transforms.ToTensor()
])
data_train = torchvision.datasets.MNIST(
    root='./data',
    train=True,
    transform=torchvision.transforms.ToTensor(),
    download=True)
data_test = torchvision.datasets.MNIST(
    './data',
    train=False,
    transform=trans_to_tensor,
    download=True)
train_loader = torch.utils.data.DataLoader(data_train, batch_size=100, shuffle=True)
x, y = next(iter(train_loader))
#MINST的通用训练方法
def test(net):
    global best_acc
    net.eval()
    test_loader = torch.utils.data.DataLoader(data_train, batch_size=10000, shuffle=False)
    test_data = next(iter(test_loader))
    with torch.no_grad():
        # x, y = test_data[0], test_data[1]
        # x = x.cuda()
        # y = y.cuda()
        x, y = test_data
        outputs = net(x)
        pred = torch.max(outputs, 1)[1]
        acc = sum(pred == y) / outputs.shape[0]
        if acc >  best_acc:
            best_acc = acc
        print(f'test acc: {acc}')
    # net.train()
def train(net, epoch=1):
    net.train()
    run_loss = 0
    for num_epoch in range(epoch):
        print(f'epoch {num_epoch}')
        for i, data in enumerate(train_loader):
            # x, y = data[0], data[1]
            x,y = data
            # print(data)
            outputs = net(x)
            loss = criterion(outputs, y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            run_loss += loss.item()
            if i % 100 == 99:
                print(f'[{(i + 1) * 100} / 60000] loss={run_loss / 100}')
                run_loss = 0
                test(net)
# LeNet5网络模型
class LeNet5(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2)
        # self.pool1 = nn.AvgPool2d(2)
        self.pool1 = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # self.pool2 = nn.AvgPool2d(2)
        self.pool2 = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(in_features=16 * 5 * 5, out_features=120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    def forward(self, x):
        # x = torch.tanh(self.conv1(x))
        x = torch.relu(self.conv1(x))
        x = self.pool1(x)
        # x = torch.tanh(self.conv2(x))
        x = torch.relu(self.conv2(x))
        x = self.pool2(x)
        x = x.view(-1, 16 * 5 * 5)
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        return x
if __name__ == '__main__':
    # res = []
    # classes = ['0','1','2','3','4','5','6','7','8','9']
    net_5 = LeNet5().cuda()
    criterion = nn.CrossEntropyLoss().cuda()
    optimizer = torch.optim.Adam(net_5.parameters())
    train(net_5, epoch=20)
    print(best_acc)
    '''
    @以下内容用来保存自己的模型并做验证
    
    torch.save(net_5.state_dict(),'LeNet5_par.pt')#保存模型参数
    torch.save(net_5,'LeNet5_all.pt')#保存整个模型
    
    model = torch.load('./LeNet5_all_cpu.pt',map_location=torch.device("cpu"))
    print(model)
    for i in range(0,7):
        image_path = f'./data/imgs/my_nums/{i}.jpg'
        img = Image.open(image_path).convert('L')
        transform = torchvision.transforms.Compose([torchvision.transforms.Resize([28,28]),
                                                    torchvision.transforms.ToTensor()])
        image = transform(img)
        image = torch.reshape(image, (-1, 1, 28, 28))
        model.eval()
        with torch.no_grad():
            output = model(image)
            prediction = torch.softmax(output, dim=1)
            prediction = np.argmax(prediction)
            plt.imshow(img)
            plt.show()
            res.append(prediction.item())
            print(prediction.item())
            print('----------')
    print(res)
    
    
    '''

Be First to Comment

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注