深度学习-Pytorch：项目标准流程【构建、保存、加载神经网络模型；数据集构建器Dataset、数据加载器DataLoader（线性回归案例、手写数字识别案例）】

逃离我推掉我的手 2023-10-05 17:51 16阅读 0赞

1、拿到文本，分词，清晰数据（去掉停用词语）；  
2、建立word2index、index2word表  
3、准备好预训练好的word embedding  
4、做好DataSet / Dataloader  
5、建立模型  
6、配置好参数  
7、开始训练  
8、测评  
9、保存模型

## 一、Pytorch构建基础的模型 ##

### 1. Pytorch构建模型常用API ###

在前一部分，我们自己实现了通过torch的相关方法完成反向传播和参数更新，在pytorch中预设了一些更加灵活简单的对象，让我们来构造模型、定义损失，优化损失等

那么接下来，我们一起来了解一下其中常用的API

#### 1.1 `nn.Module` ####

`nn.Modul` 是`torch.nn`提供的一个类，是pytorch中我们`自定义网络`的一个基类，在这个类中定义了很多有用的方法，让我们在继承这个类定义网络的时候非常简单

当我们自定义网络的时候，有两个方法需要特别注意：

1.  `__init__`需要调用`super`方法，继承父类的属性和方法，然后定义模型中的各个组件。
2.  `farward`方法必须实现，用来定义我们的网络的向前计算的过程。

用前面的`y = wx+b`的模型举例如下：

from torch import nn
    class Lr(nn.Module):
        def __init__(self):
            super(Lr, self).__init__()  #继承父类init的参数
            self.linear = nn.Linear(in_features=1, out_features=1)  # 相当于 y = wx+b
    
        def forward(self, x):
            out = self.linear(x)
            return out

注意：

1.  `nn.Linear`为torch预定义好的线性模型，也被称为**全链接层**，传入的参数为输入的数量，输出的数量(in\_features, out\_features),是不算(batch\_size的列数)
2.  `nn.Module`定义了`__call__`方法，实现的就是调用`forward`方法，即`Lr`的实例，能够直接被传入参数调用，实际上调用的是`forward`方法并传入参数

# 实例化模型
    model = Lr()
    # 传入数据，计算结果
    predict = model(x)

#### 1.2 优化器类 ####

优化器(`optimizer`)，可以理解为torch为我们封装的用来进行更新参数的方法，比如常见的随机梯度下降(`stochastic gradient descent,SGD`)

优化器类都是由`torch.optim`提供的，例如

1.  `torch.optim.SGD(参数，学习率)`
2.  `torch.optim.Adam(参数，学习率)`

注意：

1.  参数可以使用`model.parameters()`来获取，获取模型中所有`requires_grad=True`的参数
2.  优化类的使用方法
    
    1.  实例化
    2.  所有参数的梯度，将其值置为0
    3.  反向传播计算梯度
    4.  更新参数值

示例如下：

optimizer = optim.SGD(model.parameters(), lr=1e-3) #1. 实例化
    optimizer.zero_grad() #2. 梯度置为0
    loss.backward() #3. 计算梯度
    optimizer.step()  #4. 更新参数的值

#### 1.3 损失函数 ####

前面的例子是一个回归问题，torch中也预测了很多损失函数

1.  均方误差:`nn.MSELoss()`,常用于回归问题
2.  交叉熵损失：`nn.CrossEntropyLoss()`，常用于分类问题
3.  使用带权损失计算交叉熵损失：F.nll\_loss(predict\_y, target\_y) <==>  − ∑ Y l o g ( p ) -\\sum Ylog(p) −∑Ylog(p)

使用方法：

model = Lr() #1. 实例化模型
    criterion = nn.MSELoss() #2. 实例化损失函数
    optimizer = optim.SGD(model.parameters(), lr=1e-3) #3. 实例化优化器类
    for i in range(100):
        y_predict = model(x_true) #4. 向前计算预测值
        loss = criterion(y_true,y_predict) #5. 调用损失函数传入真实值和预测值，得到损失结果
        optimizer.zero_grad() #5. 当前循环参数梯度置为0
        loss.backward() #6. 计算梯度
        optimizer.step()  #7. 更新参数的值

#### 1.4 准确率的计算 ####

1.  获取概率最大值的位置索引作为预测值
2.  预测值与真实值判断相等，结果取均值

### 2、训练完整过程 ###

#### 2.1 训练过程 ####

1.  实例化模型：class MyModule(nn.Module)
2.  实例化损失函数：criterion = nn.MSELoss()
3.  实例化优化器：optimizer = optim.SGD(model.parameters(), lr=1e-3)
4.  进入训练循环
    
    1.  梯度置为0：optimizer.zero\_grad()
    2.  调用模型得到预测值：y\_predict = model(x)
    3.  调用loss = criterion(y\_true,y\_predict)计算函数，得到损失值
    4.  进行梯度计算：loss.backward()
    5.  更新梯度：optimizer.step()

#### 2.2 线性回归完整代码 ####

import torch
    from torch import nn
    from torch import optim
    import numpy as np
    from matplotlib import pyplot as plt
    
    # 1. 定义数据
    x = torch.rand([50,1])
    y = x*3 + 0.8
    
    #2 .定义模型
    class Lr(nn.Module):
        def __init__(self):
            super(Lr,self).__init__()
            self.linear = nn.Linear(in_features=1, out_features=1)  # 相当于 y = wx+b
    		
        def forward(self, x):
            out = self.linear(x)
            return out
    
    # 2. 实例化模型，loss，和优化器
    model = Lr()
    criterion = nn.MSELoss()
    optimizer = optim.SGD(model.parameters(), lr=1e-3)
    #3. 训练模型
    for i in range(30000):
        out = model(x) #3.1 获取预测值
        loss = criterion(y,out) #3.2 计算损失
        optimizer.zero_grad()  #3.3 梯度归零
        loss.backward() #3.4 计算梯度
        optimizer.step()  # 3.5 更新梯度
        if (i+1) % 20 == 0:
            print('Epoch[{}/{}], loss: {:.6f}'.format(i,30000,loss.data))
    
    #4. 模型评估
    model.eval() #设置模型为评估模式，即预测模式
    predict = model(x)
    predict = predict.data.numpy()
    plt.scatter(x.data.numpy(),y.data.numpy(),c="r")
    plt.plot(x.data.numpy(),predict)
    plt.show()

输出如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center]

注意：

`model.eval()`表示设置模型为评估模式，即预测模式

`model.train(mode=True)` 表示设置模型为训练模式

在当前的线性回归中，上述并无区别

但是在其他的一些模型中，**训练的参数和预测的参数会不相同**，到时候就需要具体告诉程序我们是在进行训练还是预测，比如模型中存在**Dropout**，**BatchNorm**的时候

## 二、在GPU上运行代码 ##

当模型太大，或者参数太多的情况下，为了加快训练速度，经常会使用GPU来进行训练

此时我们的代码需要稍作调整：

1.  判断GPU是否可用`torch.cuda.is_available()`
    
        torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
        >>device(type='cuda', index=0)  #使用gpu
        >>device(type='cpu') #使用cpu
2.  把模型参数和input数据转化为cuda的支持类型

*  `model.to(device)`
 *  `自定义tensor.to(device)`
    
        model.to(device)
        x_true.to(device)

1.  在GPU上计算结果也为cuda的数据类型，需要转化为numpy或者torch的cpu的tensor类型
    
        predict = predict.cpu().detach().numpy()
    
    `detach()`的效果和data的相似，但是`detach()`是深拷贝，data是取值，是浅拷贝

修改之后的代码如下：

import torch
    from torch import nn
    from torch import optim
    import numpy as np
    from matplotlib import pyplot as plt
    import time
    
    # 1. 定义数据
    x = torch.rand([50,1])
    y = x*3 + 0.8
    
    #2 .定义模型
    class Lr(nn.Module):
        def __init__(self):
            super(Lr,self).__init__()
            self.linear = nn.Linear(1,1)
    
        def forward(self, x):
            out = self.linear(x)
            return out
    
    # 2. 实例化模型，loss，和优化器
    
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    x = x.to(device)
    y = y.to(device)	# 此步骤可以省略【y是由x计算得出，所以y的位置默认与x一致】
    
    model = Lr().to(device)
    criterion = nn.MSELoss()
    optimizer = optim.SGD(model.parameters(), lr=1e-3)
    
    #3. 训练模型
    for i in range(300):
        out = model(x)
        loss = criterion(y,out)
    
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if (i+1) % 20 == 0:
            print('Epoch[{}/{}], loss: {:.6f}'.format(i,30000,loss.data))
    
    #4. 模型评估
    model.eval() #
    predict = model(x)
    predict = predict.cpu().detach().numpy() #转化为numpy数组
    plt.scatter(x.cpu().data.numpy(),y.cpu().data.numpy(),c="r")
    plt.plot(x.cpu().data.numpy(),predict,)
    plt.show()

## 三、数据加载 ##

### 1. 模型中使用数据加载器的目的 ###

在前面的线性回归模型中，我们使用的数据很少，所以直接把全部数据放到模型中去使用。

但是在深度学习中，数据量通常是都非常多，非常大的，如此大量的数据，不可能一次性的在模型中进行向前的计算和反向传播，经常我们会对整个数据进行随机的打乱顺序，把数据处理成一个个的batch，同时还会对数据进行预处理。

所以，接下来我们来学习pytorch中的数据加载的方法

### 2. 数据集类 ###

#### 2.1 Dataset基类介绍 ####

在torch中提供了数据集的基类`torch.utils.data.Dataset`，继承这个基类，我们能够非常快速的实现对数据的加载。

`torch.utils.data.Dataset`的源码如下：

class Dataset(object):
        """An abstract class representing a Dataset.
    
        All other datasets should subclass it. All subclasses should override
        ``__len__``, that provides the size of the dataset, and ``__getitem__``,
        supporting integer indexing in range from 0 to len(self) exclusive.
        """
    
        def __getitem__(self, index):
            raise NotImplementedError
    
        def __len__(self):
            raise NotImplementedError
    
        def __add__(self, other):
            return ConcatDataset([self, other])

可知：我们需要在自定义的数据集类中继承Dataset类，同时还需要实现两个方法：

1.  `__len__`方法，能够实现通过全局的`len()`方法获取其中的元素个数
2.  `__getitem__`方法，通过初始化的参数获取数据。能够通过传入索引或数据路径的方式获取数据，例如通过`dataset[i]`获取其中的第`i`条数据

#### 2.2 数据加载案例 ####

下面通过一个例子来看看如何使用Dataset来加载数据

数据来源：`http://archive.ics.uci.edu/ml/datasets/SMS+Spam+Collection`

数据介绍：SMS Spam Collection是用于骚扰短信识别的经典数据集，完全来自真实短信内容，包括4831条正常短信和747条骚扰短信。正常短信和骚扰短信保存在一个文本文件中。 每行完整记录一条短信内容，每行开头通过ham和spam标识正常短信和骚扰短信

数据实例：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70]

实现如下：

from torch.utils.data import Dataset,DataLoader
    import pandas as pd
    
    data_path = r"data\SMSSpamCollection"
    
    class CifarDataset(Dataset):
        def __init__(self):	# 初始化参数
            lines = open(data_path,"r")
            lines_array = [[line[:4].strip(),line[4:].strip()] for line in lines]	#对数据进行处理，前4个为label，后面的为短信内容
            self.df = pd.DataFrame(lines_array,columns=["label","sms"])	#转化为dataFrame
    
        def __getitem__(self, index):	# 通过初始化的参数获取数据
            single_item = self.df.iloc[index,:]	
            return single_item.values[0],single_item.values[1]
    
        def __len__(self):
            return self.df.shape[0]

之后对Dataset进行实例化，可以跌倒获取其中的数据

d = CifarDataset()
    for i in range(len(d)):
        print(i,d[i])

输出如下：

....
    5571 ('ham', 'Pity, * was in mood for that. So...any other suggestions?')
    5572 ('ham', "The guy did some bitching but I acted like i'd be interested in buying something else next week and he gave it to us for free")
    5573 ('ham', 'Rofl. Its true to its name')

### 3. 迭代数据集 ###

使用上述的方法能够进行数据的读取，但是其中还有很多内容没有实现：

*  批处理数据（Batching the data）
 *  打乱数据（Shuffling the data）
 *  使用多线程 `multiprocessing` 并行加载数据。
 *  如果最后一个batch的数据量不足设置的batch\_size，可以选择放弃最后一个batch的数据（drop\_last=True）

在pytorch中`torch.utils.data.DataLoader`提供了上述的所用方法

`DataLoader`的使用方法示例：

from torch.utils.data import DataLoader
    
    dataset = CifarDataset()
    data_loader = DataLoader(dataset=dataset,batch_size=10,shuffle=True,num_workers=2)
    
    #遍历，获取其中的每个batch的结果
    for index, (label, context) in enumerate(data_loader):
        print(index,label,context)
        print("*"*100)

其中参数含义：

1.  dataset：提前定义的dataset的实例
2.  batch\_size:传入数据的batch的大小，常用128,256等等
3.  shuffle：bool类型，表示是否在每次获取数据的时候提前打乱数据
4.  `num_workers`:加载数据的线程数

数据迭代器的返回结果如下：

555 ('spam', 'ham', 'spam', 'ham', 'ham', 'ham', 'ham', 'spam', 'ham', 'ham') ('URGENT! We are trying to contact U. Todays draw shows that you have won a £800 prize GUARANTEED. Call 09050003091 from....", 'swhrt how u dey,hope ur ok, tot about u 2day.love n miss.take care.')
    ***********************************************************************************
    556 ('ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'spam') ('He telling not to tell any one. If so treat for me hi hi hi', 'Did u got that persons story', "Don kn....1000 cash prize or a prize worth £5000')

注意：

1.  `len(dataset) = 数据集的样本数`
2.  `len(dataloader) = math.ceil(样本数/batch_size) 即向上取整`

### 4 pytorch自带的数据集 ###

pytorch中自带的数据集由两个上层api提供，分别是`torchvision`和`torchtext`

其中：

1.  `torchvision`提供了对图片数据处理相关的api和数据
    
     *  数据位置：`torchvision.datasets`，例如：`torchvision.datasets.MNIST`(手写数字图片数据)
2.  `torchtext`提供了对文本数据处理相关的API和数据
    
     *  数据位置：`torchtext.datasets`,例如：`torchtext.datasets.IMDB（电影`评论文本数据）

下面我们以Mnist手写数字为例，来看看pytorch如何加载其中自带的数据集

使用方法和之前一样：

1.  准备好Dataset实例
2.  把dataset交给dataloder 打乱顺序，组成batch

#### 4.1 torchversion.datasets ####

`torchversoin.datasets`中的数据集类（比如`torchvision.datasets.MNIST`）,都是继承自`Dataset`

意味着：直接对`torchvision.datasets.MNIST`进行实例化就可以得到`Dataset`的实例

但是MNIST API中的参数需要注意一下：

`torchvision.datasets.MNIST(root='/files/', train=True, download=True, transform=)`

1.  `root`参数表示数据存放的位置
2.  `train：`bool类型，表示是使用训练集的数据还是测试集的数据
3.  `download：`bool类型，表示是否需要下载数据到root目录
4.  `transform:`实现的对图片的处理函数

#### 4.2 MNIST数据集的介绍 ####

数据集的原始地址：`http://yann.lecun.com/exdb/mnist/`

MNIST是由`Yann LeCun`等人提供的免费的图像识别的数据集，其中包括60000个训练样本和10000个测试样本，其中图拍了的尺寸已经进行的标准化的处理，都是黑白的图像，大小为`28X28`

执行代码，下载数据，观察数据类型：

import torchvision
    
    dataset = torchvision.datasets.MNIST(root="./data",train=True,download=True,transform=None)
    
    print(dataset[0])

下载的数据如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70 1]

代码输出结果如下：

Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
    Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
    Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
    Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
    Processing...
    Done!
    (<PIL.Image.Image image mode=L size=28x28 at 0x18D303B9C18>, tensor(5))

可以其中数据集返回了两条数据，可以猜测为图片的数据和目标值

返回值的第0个为Image类型，可以调用show() 方法打开，发现为手写数字5

import torchvision
    
    dataset = torchvision.datasets.MNIST(root="./data",train=True,download=True,transform=None)
    
    print(dataset[0])
    
    img = dataset[0][0]
    img.show() #打开图片

图片如下：

![在这里插入图片描述][20210313220602842.png]

由上可知：返回值为`(图片，目标值)`,这个结果也可以通过观察源码得到

## 四、使用Pytorch实现手写数字识别 ##

### 1. 思路和流程分析 ###

流程：

1.  准备数据，这些需要准备DataLoader
2.  构建模型，这里可以使用torch构造一个深层的神经网络
3.  模型的训练
4.  模型的保存，保存模型，后续持续使用
5.  模型的评估，使用测试集，观察模型的好坏

### 2. 准备训练集和测试集 ###

准备数据集的方法前面已经讲过，但是通过前面的内容可知，调用MNIST返回的结果中图形数据是一个Image对象,需要对其进行处理

为了进行数据的处理，接下来学习`torchvision.transfroms`的方法

#### 2.1 `torchvision.transforms`的图形数据处理方法 ####

##### 2.1.1 `torchvision.transforms.ToTensor` #####

把一个取值范围是`[0,255]`的`PIL.Image`或者`shape`为`(H,W,C)`的`numpy.ndarray`，转换成形状为`[C,H,W]`

其中`(H,W,C)`意思为`(高，宽，通道数)`，黑白图片的通道数只有1，其中每个像素点的取值为\[0,255\],彩色图片的通道数为(R,G,B),每个通道的每个像素点的取值为\[0,255\]，三个通道的颜色相互叠加，形成了各种颜色

示例如下：

from torchvision import transforms
    import numpy as np
    
    data = np.random.randint(0, 255, size=12)
    img = data.reshape(2,2,3)
    print(img.shape)
    img_tensor = transforms.ToTensor()(img) # 转换成tensor
    print(img_tensor)
    print(img_tensor.shape)

输出如下：

shape:(2, 2, 3)
    img_tensor:tensor([[[215, 171],
                     [ 34,  12]],
    
                    [[229,  87],
                     [ 15, 237]],
    
                    [[ 10,  55],
                     [ 72, 204]]], dtype=torch.int32)
    new shape:torch.Size([3, 2, 2])

注意：

`transforms.ToTensor`对象中有`__call__`方法，所以可以对其示例能够传入数据获取结果

##### 2.1.2 `torchvision.transforms.Normalize(mean, std)` #####

给定均值：mean，shape和图片的通道数相同(指的是每个通道的均值)，方差：std，和图片的通道数相同(指的是每个通道的方差)，将会把`Tensor`规范化处理。

即：`Normalized_image=(image-mean)/std`。

例如：

from torchvision import transforms
    import numpy as np
    import torchvision
    
    data = np.random.randint(0, 255, size=12)
    img = data.reshape(2,2,3)
    img = transforms.ToTensor()(img) # 转换成tensor
    print(img)
    print("*"*100)
    
    norm_img = transforms.Normalize((10,10,10), (1,1,1))(img) #进行规范化处理
    
    print(norm_img)

输出如下：

tensor([[[177, 223],
             [ 71, 182]],
    
            [[153, 120],
             [173,  33]],
    
            [[162, 233],
             [194,  73]]], dtype=torch.int32)
    ***************************************************************************************
    tensor([[[167, 213],
             [ 61, 172]],
    
            [[143, 110],
             [163,  23]],
    
            [[152, 223],
             [184,  63]]], dtype=torch.int32)

注意：在sklearn中，默认上式中的std和mean为数据每列的std和mean，sklearn会在标准化之前算出每一列的std和mean。

但是在api：Normalize中并没有帮我们计算，所以我们需要手动计算

1.  当mean为全部数据的均值，std为全部数据的std的时候，才是进行了标准化。
2.  如果mean(x)不是全部数据的mean的时候，std(y)也不是的时候，Normalize后的数据分布满足下面的关系  
     n e w \_ m e a n = m e a n − x y ， m e a n 为 原 数 据 的 均 值 ， x 为 传 入 的 均 值 x n e w \_ s t d = s t d y ， y 为 传 入 的 标 准 差 y \\begin\{aligned\} &new\\\_mean = \\frac\{mean-x\}\{y\}&， mean为原数据的均值，x为传入的均值x \\\\ &new\\\_std = \\frac\{std\}\{y\} &，y为传入的标准差y\\\\ \\end\{aligned\} new\_mean=ymean−xnew\_std=ystd，mean为原数据的均值，x为传入的均值x，y为传入的标准差y

##### 2.1.3 `torchvision.transforms.Compose(transforms)` #####

将多个`transform`组合起来使用。

例如

transforms.Compose([
         torchvision.transforms.ToTensor(), #先转化为Tensor
         torchvision.transforms.Normalize(mean,std) #在进行正则化
     ])

#### 2.2 准备MNIST数据集的Dataset和DataLoader ####

准备训练集

import torchvision
    
    #准备数据集，其中0.1307，0.3081为MNIST数据的均值和标准差，这样操作能够对其进行标准化
    #因为MNIST只有一个通道（黑白图片）,所以元组中只有一个值
    dataset = torchvision.datasets.MNIST('/data', train=True, download=True,
                                 transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),
                                   torchvision.transforms.Normalize(
                                     (0.1307,), (0.3081,))
                                 ]))
    #准备数据迭代器                          
    train_dataloader = torch.utils.data.DataLoader(dataset,batch_size=64,shuffle=True)

准备测试集

import torchvision
    
    #准备数据集，其中0.1307，0.3081为MNIST数据的均值和标准差，这样操作能够对其进行标准化
    #因为MNIST只有一个通道（黑白图片）,所以元组中只有一个值
    dataset = torchvision.datasets.MNIST('/data', train=False, download=True,
                                 transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),
                                   torchvision.transforms.Normalize(
                                     (0.1307,), (0.3081,))
                                 ]))
    #准备数据迭代器                          
    train_dataloader = torch.utils.data.DataLoader(dataset,batch_size=64,shuffle=True)

### 3. 构建模型 ###

补充：**全连接层**：当前一层的神经元和前一层的神经元相互链接，其核心操作就是 y = w x y = wx y=wx，即矩阵的乘法，实现对前一层的数据的变换

模型的构建使用了一个三层的神经网络，其中包括两个全连接层和一个输出层，第一个全连接层会经过激活函数的处理，将处理后的结果交给下一个全连接层，进行变换后输出结果

那么在这个模型中有两个地方需要注意：

1.  激活函数如何使用
2.  每一层数据的形状
3.  模型的损失函数

#### 3.1 激活函数的使用 ####

前面介绍了激活函数的作用，常用的激活函数为Relu激活函数，他的使用非常简单

Relu激活函数由`import torch.nn.functional as F`提供，`F.relu(x)`即可对x进行处理

例如：

In [30]: b
    Out[30]: tensor([-2, -1,  0,  1,  2])
    
    In [31]: import torch.nn.functional as F
    
    In [32]: F.relu(b)
    Out[32]: tensor([0, 0, 0, 1, 2])

#### 3.2 模型中数据的形状（【添加形状变化图形】） ####

1.  原始输入数据为的形状:`[batch_size,1,28,28]`
2.  进行形状的修改：`[batch_size,28*28]` ,(全连接层是在进行矩阵的乘法操作)
3.  第一个全连接层的输出形状：`[batch_size,28]`，这里的28是个人设定的，你也可以设置为别的
4.  激活函数不会修改数据的形状
5.  第二个全连接层的输出形状：`[batch_size,10]`,因为手写数字有10个类别

构建模型的代码如下：

import torch
    from torch import nn
    import torch.nn.functional as F
    
    class MnistNet(nn.Module):
        def __init__(self):
            super(MnistNet,self).__init__()
            self.fc1 = nn.Linear(28*28*1,28)  #定义Linear的输入和输出的形状
            self.fc2 = nn.Linear(28,10)  #定义Linear的输入和输出的形状
    
        def forward(self,x):
            x = x.view(-1,28*28*1)  #对数据形状变形，-1表示该位置根据后面的形状自动调整
            x = self.fc1(x) #[batch_size,28]
            x = F.relu(x)  #[batch_size,28]
            x = self.fc2(x) #[batch_size,10]

可以发现：pytorch在构建模型的时候`形状上`并不会考虑`batch_size`

#### 3.3 模型的损失函数 ####

首先，我们需要明确，当前我们手写字体识别的问题是一个多分类的问题，所谓多分类对比的是之前学习的2分类

回顾之前的课程，我们在逻辑回归中，我们使用sigmoid进行计算对数似然损失，来定义我们的2分类的损失。

*  在2分类中我们有正类和负类，正类的概率为 P ( x ) = 1 1 + e − x = e x 1 + e x P(x) = \\frac\{1\}\{1+e^\{-x\}\} = \\frac\{e^x\}\{1+e^x\} P(x)=1\+e−x1=1\+exex,那么负类的概率为 1 − P ( x ) 1-P(x) 1−P(x)
 *  将这个结果进行计算对数似然损失 − ∑ y l o g ( P ( x ) ) -\\sum y log(P(x)) −∑ylog(P(x))就可以得到最终的损失

那么在多分类的过程中我们应该怎么做呢？

*  多分类和2分类中唯一的区别是我们不能够再使用sigmoid函数来计算当前样本属于某个类别的概率，而应该使用softmax函数。
 *  softmax和sigmoid的区别在于我们需要去计算样本属于每个类别的概率，需要计算多次，而sigmoid只需要计算一次

softmax的公式如下：  
 σ ( z ) j = e z j ∑ k = 1 K e z K , j = 1 ⋯ k \\sigma(z)\_j = \\frac\{e^\{z\_j\}\}\{\\sum^K\_\{k=1\}e^\{z\_K\}\} ,j=1 \\cdots k σ(z)j=∑k=1KezKezj,j=1⋯k

例如下图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 1]

假如softmax之前的输出结果是`2.3, 4.1, 5.6`,那么经过softmax之后的结果是多少呢？  
 Y 1 = e 2.3 e 2.3 + e 4.1 + e 5.6 Y 2 = e 4.1 e 2.3 + e 4.1 + e 5.6 Y 3 = e 5.6 e 2.3 + e 4.1 + e 5.6 Y1 = \\frac\{e^\{2.3\}\}\{e^\{2.3\}+e^\{4.1\}+e^\{5.6\}\} \\\\ Y2 = \\frac\{e^\{4.1\}\}\{e^\{2.3\}+e^\{4.1\}+e^\{5.6\}\} \\\\ Y3 = \\frac\{e^\{5.6\}\}\{e^\{2.3\}+e^\{4.1\}+e^\{5.6\}\} \\\\ Y1=e2.3\+e4.1\+e5.6e2.3Y2=e2.3\+e4.1\+e5.6e4.1Y3=e2.3\+e4.1\+e5.6e5.6

对于这个softmax输出的结果，是在\[0,1\]区间，我们可以把它当做概率

和前面2分类的损失一样，多分类的损失只需要再把这个结果进行对数似然损失的计算即可

即：  
 J = − ∑ Y l o g ( P ) , 其 中 P = e z j ∑ k = 1 K e z K , Y 表 示 真 实 值 \\begin\{aligned\} & J = -\\sum Y log(P) &, 其中 P = \\frac\{e^\{z\_j\}\}\{\\sum^K\_\{k=1\}e^\{z\_K\}\} ,Y表示真实值 \\end\{aligned\} J=−∑Ylog(P),其中P=∑k=1KezKezj,Y表示真实值  
最后，会计算每个样本的损失，即上式的平均值

我们把softmax概率传入对数似然损失得到的损失函数称为**交叉熵损失**

在pytorch中有两种方法实现交叉熵损失

1.      criterion = nn.CrossEntropyLoss()
        loss = criterion(input,target)
2.      #1. 对输出值计算softmax和取对数
        output = F.log_softmax(x,dim=-1)
        #2. 使用torch中带权损失
        loss = F.nll_loss(output,target)

带权损失定义为： l n = − ∑ w i x i l\_n = -\\sum w\_\{i\} x\_\{i\} ln=−∑wixi，其实就是把 l o g ( P ) log(P) log(P)作为 x i x\_i xi,把真实值Y作为权重

### 4. 模型的训练 ###

训练的流程：

1.  实例化模型，设置模型为训练模式
2.  实例化优化器类，实例化损失函数
3.  获取，遍历dataloader
4.  梯度置为0
5.  进行向前计算
6.  计算损失
7.  反向传播
8.  更新参数

mnist_net = MnistNet()
    optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)
    def train(epoch):
        mode = True
        mnist_net.train(mode=mode) #模型设置为训练模型
        
        train_dataloader = get_dataloader(train=mode) #获取训练数据集
        for idx,(data,target) in enumerate(train_dataloader):
            optimizer.zero_grad() #梯度置为0
            output = mnist_net(data) #进行向前计算
            loss = F.nll_loss(output,target) #带权损失
            loss.backward()  #进行反向传播，计算梯度
            optimizer.step() #参数更新
            if idx % 10 == 0:
                print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                    epoch, idx * len(data), len(train_dataloader.dataset),
                           100. * idx / len(train_dataloader), loss.item()))

### 5. 模型的保存和加载 ###

#### 5.1 模型的保存 ####

保存模型的后缀（.pt）随便写，便于识别即可

torch.save(mnist_net.state_dict(),"model/mnist_net.pt") #保存模型参数
    torch.save(optimizer.state_dict(), 'results/mnist_optimizer.pt') #保存优化器参数

#### 5.2 模型的加载 ####

mnist_net.load_state_dict(torch.load("model/mnist_net.pt"))
    optimizer.load_state_dict(torch.load("results/mnist_optimizer.pt"))

### 6. 模型的评估 ###

评估的过程和训练的过程相似，但是：

1.  不需要计算梯度
2.  需要收集损失和准确率，用来计算平均损失和平均准确率
3.  损失的计算和训练时候损失的计算方法相同
4.  准确率的计算：
    
     *  模型的输出为\[batch\_size,10\]的形状
     *  其中最大值的位置就是其预测的目标值（预测值进行过sotfmax后为概率，sotfmax中分母都是相同的，分子越大，概率越大）
     *  最大值的位置获取的方法可以使用`torch.max`,返回最大值和最大值的位置
     *  返回最大值的位置后，和真实值（`[batch_size]`）进行对比，相同表示预测成功

def test():
        test_loss = 0
        correct = 0
        mnist_net.eval()  #设置模型为评估模式
        test_dataloader = get_dataloader(train=False) #获取评估数据集
        with torch.no_grad(): #不计算其梯度
            for data, target in test_dataloader:
                output = mnist_net(data)
                test_loss += F.nll_loss(output, target, reduction='sum').item()
                pred = output.data.max(1, keepdim=True)[1] #获取最大值的位置,[batch_size,1]
                correct += pred.eq(target.data.view_as(pred)).sum()  #预测准备样本数累加
        test_loss /= len(test_dataloader.dataset) #计算平均损失
        print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
            test_loss, correct, len(test_dataloader.dataset),
            100. * correct / len(test_dataloader.dataset)))

### 7. 手写数字识别（完整代码）： ###

import torch
    from torch import nn
    from torch import optim
    import torch.nn.functional as F
    import torchvision
    from tqdm import tqdm
    import numpy as np
    
    train_batch_size = 64
    test_batch_size = 1000
    img_size = 28
    
    
    def get_dataloader(train=True):
        assert isinstance(train, bool), "train 必须是bool类型"
        transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor(), torchvision.transforms.Normalize((0.1307,), (0.3081,)), ])  # 其中0.1307，0.3081为MNIST数据的均值和标准差，这样操作能够对其进行标准化【因为MNIST只有一个通道（黑白图片）,所以元组中只有一个值】
        dataset = torchvision.datasets.MNIST('./data', train=train, download=True, transform=transform)  # 准备数据集
        batch_size = train_batch_size if train else test_batch_size
        dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)  # 准备数据迭代器
        return dataloader
    
    
    class MnistNet(nn.Module):
        def __init__(self):
            super(MnistNet, self).__init__()
            self.fc1 = nn.Linear(in_features=28 * 28 * 1, out_features=28)
            self.fc2 = nn.Linear(in_features=28, out_features=10)
    
        def forward(self, x):
            x = x.view(-1, 28 * 28 * 1)
            x = self.fc1(x)  # [batch_size,28 * 28 * 1] >>> [batch_size,28]
            x = F.relu(x)  # [batch_size,28] >>> [batch_size,28]
            x = self.fc2(x)  # [batch_size,28] >>> [batch_size,10]
            out = F.log_softmax(x, dim=-1)
            return out  # return x
    
    
    mnist_net = MnistNet()
    optimizer = optim.Adam(mnist_net.parameters(), lr=0.001)
    # criterion = nn.CrossEntropyLoss() # CrossEntropyLoss = softmax + log + NLLLoss
    criterion = nn.NLLLoss()
    train_loss_list = []
    train_count_list = []
    
    
    def train(epoch):
        mode = True
        mnist_net.train(mode=mode)
        train_dataloader = get_dataloader(train=mode)
        bar = tqdm(enumerate(train_dataloader), total=len(train_dataloader))
        print("\ntrain---->len(train_dataloader.dataset) = {0}".format(len(train_dataloader.dataset)))
        print("train---->len(train_dataloader) = {0}".format(len(train_dataloader)))
        total_loss = []
        for idx, (data, target) in bar:
            # target_one_hot = F.one_hot(target)  # One-Hot编码，共有10类  [batch_size] => [batch_size,10]
            optimizer.zero_grad()  # 每次循环都归零（因为默认每个参数的grad每次计算后是进行累加的）
            output = mnist_net(data)    # torch.Size([64, 10])
            loss = criterion(output, target)  # 似然损失  NLLLoss()：1D target tensor expected, multi-target not supported
            loss.backward()
            total_loss.append(loss.item())
            optimizer.step()
            if idx % 10 == 0:
                # print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(epoch, idx * len(data), len(train_dataloader.dataset), 100. * idx / len(train_dataloader), loss.item()))
                bar.set_description('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(epoch, idx * len(data), len(train_dataloader.dataset), 100. * idx / len(train_dataloader), np.mean(total_loss)))
                train_loss_list.append(loss.item())
                train_count_list.append(idx * train_batch_size + (epoch - 1) * len(train_dataloader))
                torch.save(mnist_net.state_dict(), "./model/mnist_net.pkl")
                torch.save(optimizer.state_dict(), './results/mnist_optimizer.pkl')
    
    
    def test(epoch):
        test_loss = 0
        correct = 0
        mnist_net.eval()
        test_dataloader = get_dataloader(train=False)
        with torch.no_grad():
            for data, target in test_dataloader:
                output = mnist_net(data)
                test_loss += F.nll_loss(output, target, reduction='sum').item()
                pred = output.data.max(1, keepdim=True)[1]  # 获取最大值的位置,[batch_size,1]
                correct += pred.eq(target.data.view_as(pred)).sum()
        test_loss /= len(test_dataloader.dataset)
        print('\nTest Epoch: {}: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(epoch, test_loss, correct, len(test_dataloader.dataset), 100. * correct / len(test_dataloader.dataset)))
    
    
    if __name__ == '__main__':
        for i in range(5):  # 模型训练5轮
            train(i)
            test(i)

打印结果：

train---->len(train_dataloader.dataset) = 60000
    train---->len(train_dataloader) = 938
    Train Epoch: 0 [59520/60000 (99%)]	Loss: 0.371781: 100%|██████████| 938/938 [00:08<00:00, 105.64it/s]
    
    Test Epoch: 0: Avg. loss: 0.2308, Accuracy: 9330/10000 (93.30%)
    
    Train Epoch: 1 [0/60000 (0%)]	Loss: 0.269116:   0%|          | 0/938 [00:00<?, ?it/s]
    train---->len(train_dataloader.dataset) = 60000
    train---->len(train_dataloader) = 938
    Train Epoch: 1 [59520/60000 (99%)]	Loss: 0.209807: 100%|██████████| 938/938 [00:09<00:00, 97.48it/s] 
    
    Test Epoch: 1: Avg. loss: 0.1888, Accuracy: 9438/10000 (94.38%)
    
    Train Epoch: 2 [0/60000 (0%)]	Loss: 0.164207:   0%|          | 0/938 [00:00<?, ?it/s]
    train---->len(train_dataloader.dataset) = 60000
    train---->len(train_dataloader) = 938
    Train Epoch: 2 [59520/60000 (99%)]	Loss: 0.169802: 100%|██████████| 938/938 [00:09<00:00, 103.80it/s]
    
    Test Epoch: 2: Avg. loss: 0.1676, Accuracy: 9491/10000 (94.91%)
    
    
    train---->len(train_dataloader.dataset) = 60000
    train---->len(train_dataloader) = 938
    Train Epoch: 3 [59520/60000 (99%)]	Loss: 0.147357: 100%|██████████| 938/938 [00:09<00:00, 98.43it/s] 
    
    Test Epoch: 3: Avg. loss: 0.1546, Accuracy: 9563/10000 (95.63%)
    
    
    train---->len(train_dataloader.dataset) = 60000
    train---->len(train_dataloader) = 938
    Train Epoch: 4 [59520/60000 (99%)]	Loss: 0.131380: 100%|██████████| 938/938 [00:09<00:00, 98.10it/s] 
    
    Test Epoch: 4: Avg. loss: 0.1401, Accuracy: 9594/10000 (95.94%)
    
    
    Process finished with exit code 0

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20210313215328726.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210313220519559.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210313220544308.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70
[20210313220602842.png]: https://img-blog.csdnimg.cn/20210313220602842.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20210313220845284.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center