神经网络中的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)
    
    
    '''
    
页面下部广告