1、拿到文本，分词，清晰数据（去掉停用词语）；
2、建立word2index、index2word表
3、准备好预训练好的word embedding
4、做好DataSet / Dataloader
5、建立模型
6、配置好参数
7、开始训练
8、测评
9、保存模型
一、Pytorch构建基础的模型
1. Pytorch构建模型常用API
在前一部分，我们自己实现了通过torch的相关方法完成反向传播和参数更新，在pytorch中预设了一些更加灵活简单的对象，让我们来构造模型、定义损失，优化损失等
那么接下来，我们一起来了解一下其中常用的API
1.1nn.Module
nn.Modul是torch.nn提供的一个类，是pytorch中我们自定义网络的一个基类，在这个类中定义了很多有用的方法，让我们在继承这个类定义网络的时候非常简单
当我们自定义网络的时候，有两个方法需要特别注意：
__init__需要调用super方法，继承父类的属性和方法，然后定义模型中的各个组件。farward方法必须实现，用来定义我们的网络的向前计算的过程。
用前面的y = wx+b的模型举例如下：
from torch import nnclass Lr(nn.Module):def __init__(self):super(Lr, self).__init__() #继承父类init的参数self.linear = nn.Linear(in_features=1, out_features=1) # 相当于 y = wx+bdef forward(self, x):out = self.linear(x)return out
注意：
nn.Linear为torch预定义好的线性模型，也被称为全链接层，传入的参数为输入的数量，输出的数量(in_features, out_features),是不算(batch_size的列数)nn.Module定义了__call__方法，实现的就是调用forward方法，即Lr的实例，能够直接被传入参数调用，实际上调用的是forward方法并传入参数
# 实例化模型model = Lr()# 传入数据，计算结果predict = model(x)
1.2 优化器类
优化器(optimizer)，可以理解为torch为我们封装的用来进行更新参数的方法，比如常见的随机梯度下降(stochastic gradient descent,SGD)
优化器类都是由torch.optim提供的，例如
torch.optim.SGD(参数，学习率)torch.optim.Adam(参数，学习率)
注意：
参数可以使用model.parameters()来获取，获取模型中所有requires_grad=True的参数优化类的使用方法 实例化所有参数的梯度，将其值置为0反向传播计算梯度更新参数值
示例如下：
optimizer = optim.SGD(model.parameters(), lr=1e-3) #1. 实例化optimizer.zero_grad() #2. 梯度置为0loss.backward() #3. 计算梯度optimizer.step() #4. 更新参数的值
1.3 损失函数
前面的例子是一个回归问题，torch中也预测了很多损失函数
均方误差:nn.MSELoss(),常用于回归问题交叉熵损失：nn.CrossEntropyLoss()，常用于分类问题使用带权损失计算交叉熵损失：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. 当前循环参数梯度置为0loss.backward() #6. 计算梯度optimizer.step() #7. 更新参数的值
1.4 准确率的计算
获取概率最大值的位置索引作为预测值预测值与真实值判断相等，结果取均值2、训练完整过程
2.1 训练过程
实例化模型：class MyModule(nn.Module)实例化损失函数：criterion = nn.MSELoss()实例化优化器：optimizer = optim.SGD(model.parameters(), lr=1e-3)进入训练循环 梯度置为0：optimizer.zero_grad()调用模型得到预测值：y_predict = model(x)调用loss = criterion(y_true,y_predict)计算函数，得到损失值进行梯度计算：loss.backward()更新梯度：optimizer.step()2.2 线性回归完整代码
import torchfrom torch import nnfrom torch import optimimport numpy as npfrom 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+bdef 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()
输出如下：
注意：
model.eval()表示设置模型为评估模式，即预测模式
model.train(mode=True)表示设置模型为训练模式
在当前的线性回归中，上述并无区别
但是在其他的一些模型中，训练的参数和预测的参数会不相同，到时候就需要具体告诉程序我们是在进行训练还是预测，比如模型中存在Dropout，BatchNorm的时候
二、在GPU上运行代码
当模型太大，或者参数太多的情况下，为了加快训练速度，经常会使用GPU来进行训练
此时我们的代码需要稍作调整：
判断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
把模型参数和input数据转化为cuda的支持类型
model.to(device)自定义tensor.to(device)
model.to(device)x_true.to(device)
在GPU上计算结果也为cuda的数据类型，需要转化为numpy或者torch的cpu的tensor类型
predict = predict.cpu().detach().numpy()
detach()的效果和data的相似，但是detach()是深拷贝，data是取值，是浅拷贝
修改之后的代码如下：
import torchfrom torch import nnfrom torch import optimimport numpy as npfrom matplotlib import pyplot as pltimport 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 NotImplementedErrordef __len__(self):raise NotImplementedErrordef __add__(self, other):return ConcatDataset([self, other])
可知：我们需要在自定义的数据集类中继承Dataset类，同时还需要实现两个方法：
__len__方法，能够实现通过全局的len()方法获取其中的元素个数__getitem__方法，通过初始化的参数获取数据。能够通过传入索引或数据路径的方式获取数据，例如通过dataset[i]获取其中的第i条数据
2.2 数据加载案例
下面通过一个例子来看看如何使用Dataset来加载数据
数据来源：http://archive.ics.uci.edu/ml/datasets/SMS+Spam+Collection
数据介绍：SMS Spam Collection是用于骚扰短信识别的经典数据集，完全来自真实短信内容，包括4831条正常短信和747条骚扰短信。正常短信和骚扰短信保存在一个文本文件中。 每行完整记录一条短信内容，每行开头通过ham和spam标识正常短信和骚扰短信
数据实例：
实现如下：
from torch.utils.data import Dataset,DataLoaderimport pandas as pddata_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"])#转化为dataFramedef __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 DataLoaderdataset = 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)
其中参数含义：
dataset：提前定义的dataset的实例batch_size:传入数据的batch的大小，常用128,256等等shuffle：bool类型，表示是否在每次获取数据的时候提前打乱数据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')
注意：
len(dataset) = 数据集的样本数len(dataloader) = math.ceil(样本数/batch_size) 即向上取整
4 pytorch自带的数据集
pytorch中自带的数据集由两个上层api提供，分别是torchvision和torchtext
其中：
torchvision提供了对图片数据处理相关的api和数据 数据位置：torchvision.datasets，例如：torchvision.datasets.MNIST(手写数字图片数据)torchtext提供了对文本数据处理相关的API和数据 数据位置：torchtext.datasets,例如：torchtext.datasets.IMDB（电影评论文本数据）
下面我们以Mnist手写数字为例，来看看pytorch如何加载其中自带的数据集
使用方法和之前一样：
准备好Dataset实例把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=)
root参数表示数据存放的位置train：bool类型，表示是使用训练集的数据还是测试集的数据download：bool类型，表示是否需要下载数据到root目录transform:实现的对图片的处理函数
4.2 MNIST数据集的介绍
数据集的原始地址：/exdb/mnist/
MNIST是由Yann LeCun等人提供的免费的图像识别的数据集，其中包括60000个训练样本和10000个测试样本，其中图拍了的尺寸已经进行的标准化的处理，都是黑白的图像，大小为28X28
执行代码，下载数据，观察数据类型：
import torchvisiondataset = torchvision.datasets.MNIST(root="./data",train=True,download=True,transform=None)print(dataset[0])
下载的数据如下：
代码输出结果如下：
Downloading /exdb/mnist/train-images-idx3-ubyte.gzDownloading /exdb/mnist/train-labels-idx1-ubyte.gzDownloading /exdb/mnist/t10k-images-idx3-ubyte.gzDownloading /exdb/mnist/t10k-labels-idx1-ubyte.gzProcessing...Done!(<PIL.Image.Image image mode=L size=28x28 at 0x18D303B9C18>, tensor(5))
可以其中数据集返回了两条数据，可以猜测为图片的数据和目标值
返回值的第0个为Image类型，可以调用show() 方法打开，发现为手写数字5
import torchvisiondataset = torchvision.datasets.MNIST(root="./data",train=True,download=True,transform=None)print(dataset[0])img = dataset[0][0]img.show() #打开图片
图片如下：
由上可知：返回值为(图片，目标值),这个结果也可以通过观察源码得到
四、使用Pytorch实现手写数字识别
1. 思路和流程分析
流程：
准备数据，这些需要准备DataLoader构建模型，这里可以使用torch构造一个深层的神经网络模型的训练模型的保存，保存模型，后续持续使用模型的评估，使用测试集，观察模型的好坏
2. 准备训练集和测试集
准备数据集的方法前面已经讲过，但是通过前面的内容可知，调用MNIST返回的结果中图形数据是一个Image对象,需要对其进行处理
为了进行数据的处理，接下来学习torchvision.transfroms的方法
2.1torchvision.transforms的图形数据处理方法
2.1.1torchvision.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 transformsimport numpy as npdata = np.random.randint(0, 255, size=12)img = data.reshape(2,2,3)print(img.shape)img_tensor = transforms.ToTensor()(img) # 转换成tensorprint(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.2torchvision.transforms.Normalize(mean, std)
给定均值：mean，shape和图片的通道数相同(指的是每个通道的均值)，方差：std，和图片的通道数相同(指的是每个通道的方差)，将会把Tensor规范化处理。
即：Normalized_image=(image-mean)/std。
例如：
from torchvision import transformsimport numpy as npimport torchvisiondata = np.random.randint(0, 255, size=12)img = data.reshape(2,2,3)img = transforms.ToTensor()(img) # 转换成tensorprint(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中并没有帮我们计算，所以我们需要手动计算
当mean为全部数据的均值，std为全部数据的std的时候，才是进行了标准化。
如果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.3pose(transforms)
将多个transform组合起来使用。
例如
pose([torchvision.transforms.ToTensor(), #先转化为Tensortorchvision.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=pose([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=pose([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，即矩阵的乘法，实现对前一层的数据的变换
模型的构建使用了一个三层的神经网络，其中包括两个全连接层和一个输出层，第一个全连接层会经过激活函数的处理，将处理后的结果交给下一个全连接层，进行变换后输出结果
那么在这个模型中有两个地方需要注意：
激活函数如何使用每一层数据的形状模型的损失函数
3.1 激活函数的使用
前面介绍了激活函数的作用，常用的激活函数为Relu激活函数，他的使用非常简单
Relu激活函数由import torch.nn.functional as F提供，F.relu(x)即可对x进行处理
例如：
In [30]: bOut[30]: tensor([-2, -1, 0, 1, 2])In [31]: import torch.nn.functional as FIn [32]: F.relu(b)Out[32]: tensor([0, 0, 0, 1, 2])
3.2 模型中数据的形状（【添加形状变化图形】）
原始输入数据为的形状:[batch_size,1,28,28]进行形状的修改：[batch_size,28*28],(全连接层是在进行矩阵的乘法操作)第一个全连接层的输出形状：[batch_size,28]，这里的28是个人设定的，你也可以设置为别的激活函数不会修改数据的形状第二个全连接层的输出形状：[batch_size,10],因为手写数字有10个类别构建模型的代码如下：
import torchfrom torch import nnimport torch.nn.functional as Fclass 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
例如下图：
假如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中有两种方法实现交叉熵损失
criterion = nn.CrossEntropyLoss()loss = criterion(input,target)
#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. 模型的训练
训练的流程：
实例化模型，设置模型为训练模式实例化优化器类，实例化损失函数获取，遍历dataloader梯度置为0进行向前计算计算损失反向传播更新参数
mnist_net = MnistNet()optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)def train(epoch):mode = Truemnist_net.train(mode=mode) #模型设置为训练模型train_dataloader = get_dataloader(train=mode) #获取训练数据集for idx,(data,target) in enumerate(train_dataloader):optimizer.zero_grad() #梯度置为0output = 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. 模型的评估
评估的过程和训练的过程相似，但是：
不需要计算梯度需要收集损失和准确率，用来计算平均损失和平均准确率损失的计算和训练时候损失的计算方法相同准确率的计算： 模型的输出为[batch_size,10]的形状其中最大值的位置就是其预测的目标值（预测值进行过sotfmax后为概率，sotfmax中分母都是相同的，分子越大，概率越大）最大值的位置获取的方法可以使用torch.max,返回最大值和最大值的位置返回最大值的位置后，和真实值（[batch_size]）进行对比，相同表示预测成功
def test():test_loss = 0correct = 0mnist_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 torchfrom torch import nnfrom torch import optimimport torch.nn.functional as Fimport torchvisionfrom tqdm import tqdmimport numpy as nptrain_batch_size = 64test_batch_size = 1000img_size = 28def get_dataloader(train=True):assert isinstance(train, bool), "train 必须是bool类型"transform = pose([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_sizedataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True) # 准备数据迭代器return dataloaderclass 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 xmnist_net = MnistNet()optimizer = optim.Adam(mnist_net.parameters(), lr=0.001)# criterion = nn.CrossEntropyLoss() # CrossEntropyLoss = softmax + log + NLLLosscriterion = nn.NLLLoss()train_loss_list = []train_count_list = []def train(epoch):mode = Truemnist_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 supportedloss.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 = 0correct = 0mnist_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) = 60000train---->len(train_dataloader) = 938Train 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) = 60000train---->len(train_dataloader) = 938Train 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) = 60000train---->len(train_dataloader) = 938Train 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) = 60000train---->len(train_dataloader) = 938Train 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) = 60000train---->len(train_dataloader) = 938Train 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
深度学习-Pytorch：项目标准流程【构建 保存 加载神经网络模型；数据集构建器Dataset 数据加载器DataLoader（线性回归案例 手写数字识别案例）】
如果觉得《深度学习-Pytorch：项目标准流程【构建 保存 加载神经网络模型；数据集构建器Datase》对你有帮助，请点赞、收藏，并留下你的观点哦！
