搭建线性网络对MNIST数据集进行训练、测试，并且预测图片
目录
1. 介绍
2. 搭建网络（model）
3. 训练网络（train）
3.1 数据预处理
3.2 加载数据集
3.3 实例化网络 + 构建优化器
3.4 训练网络
3.5 保存网络参数
4. 预测图片（predict）
5. code
1. 介绍
这次要完成的任务是搭建一个线性的模型去对手写数字集MNIST进行训练，对我们的网络在测试集上进行测试防止过拟合，最后在网上随便找一张手写数字的图片进行预测
通过之前的学习，大概了解到，训练神经网络大概需要如下几个步骤
1. 准备数据集 Data sets
2. 搭建网络 Net + 优化器 optimizer
3. 训练网络 Train
4. 测试网络 Test
这次的流程也是类似，但是因为这次的数据集和网络都较大，所以采用模块化的方式去实现
准备工作如下所示，model 里面存放我们搭建的网络， train 里面存在训练过程 ，将训练后的网络保存到 Net.pth 中，最后将训练完成的网络在predict 中去预测图片 2.png
2. 搭建网络（model）
首先看搭建网络需要的库
其中nn是神经网络库，可以方便搭建神经网络
nn.functional 是函数库，例如relu 、 sigmoid 函数等等
网络的搭建部分较为简单， 因为MNIST数据集是图像数据，每个图像的大小是 28 * 28 的灰度图像
而我们搭建的网络是线性网络（非CNN网络），所以第一层的的维度是（784，512）
这里做下简单介绍：
例如我们将28 * 28 的图片压缩成一维的就是 784列 的行向量，因为输入是采用batch输入的，假设batch的size 是n。所以每次输入的维度是 n行，784列的一个(n,784)矩阵大小。而我们想要数据经过第一层网络后输出是512列（这里我们只改变单个图像的特征，而不是batch），所以输出就是（n，512）所以根据矩阵乘法（n，784）*（784，512）=（n，512）
这里只要满足矩阵乘法就行，例如y = w * x +b或者 y = x * wT + b都是为了满足矩阵乘法
然后根据同样的方法去构建第二层、第三层即可。因为最后要输出图片的数字（0-9），所以最后一层应该是10
前向传播就是按照信号流通的方法即可。首先需要将一副图片变成（1，784）的形式，然后经过第一层+激活函数（这里是relu）后流向第二层等等...
因为这是个多分类的问题，采用的是交叉熵函数，网络最后的输出应该经过softmax计算概率
但是因为pytorch里面的交叉熵损失函数已经包含softmax层了，所以最后之间将最后一层输出即可
3. 训练网络（train）
3.1 数据预处理
对数据进行预处理之前需要导入一些库
数据的预处理如图
ToTensor 的作用是改变图像的通道顺序，然后的图像的灰度值归一化的（0-1）之间
Normalize 的作用是使用平均值和标准偏差规范化张量图像，第一个括号为mean，第一个括号为std 。因为要处理的为灰度图像是单通道的，所以只需要设置一个数字
3.2 加载数据集
torchvision 提供了很多数据集，这里我们下载MNIST数据集
root 指定下载的路径，如果路径中包含就不需要下载，train = True 为导入训练集 ，download 设置为True ，会下载到root中，如果路径中有就会之间读取，transform 数据预处理
Dataloader 是一个可以迭代的对象，它能将dataset返回的每一个数据样本拼接成一个batch，并且提供了多线程加速（num_workers）和打乱（shuffle）的功能
这里依次读入train 和 test 集 ，设置batch_size 为64
3.3 实例化网络 + 构建优化器
这部分较为简单，因为这个网络已经很大了，所以建议SGD梯度下降的时候加个momentum
3.4 训练网络
我们让epoch 训练五次
enumerate 会返回每一批的data 和 index ，所以我们定义的变量data里面包含两个value，i 是第i组数据
将第一个value 赋值给inputs（每一个样本的28*28） ，第二个value 赋值给 labels（0-9之间）
然后就是梯度清零->网络前向传播->计算损失->反向传播->梯度更新
接下来就是打印loss，我们设置成每300次打印一次。因为每次batch会拿出64，这样6w张训练数据 / （64 * 300）= 3.125 ，所以一个epoch只会打印三次
我们再在每次训练的时候计算网络的accuracy。
因为计算正确率的时候，不需要反向传播，所以这里不需要计算梯度with torch.no_grad():代表里面的代码不会计算梯度。
然后从testloader里面取出数据，经过网络计算网络的预测值。通过max函数计算输出的最大值
torch.max 函数会返回两个值（value，index），我们对网络的输出最大值不感兴趣，或者说我们对网络哪一个位置输出最大值感兴趣，因为网络输出的10维度正好对应我们的（0-9）。而网络流通的维度为(n,784)->(784,512)->(512,256)->(256,128)->(128,64)->(64,10),所以n个图像784（28*28）经过网络输出成了维度为10的特征，而10是列，所以dim设置成1，要横着取最大值
然后总共的数量是一次拿的batch_size （本章代码是64），当预测和label一致的时候正确率+1，最后打印就行了
3.5 保存网络参数
将网络的参数保存到Net.pth文件中
4. 预测图片（predict）
这里在网上找了一个手写数字的图片，用来测试我们的网络
在对网络预测前有许多准备工作，比如灰度化、调整大小等等，
这里图像灰度化可以用opencv简单操作就行了，调整大小的话可以用transforms里面的Resize函数
然后加载网络训练好的参数，将图像预处理后就可以丢到网络中了
这里也可以像train里面写成下面这样，但是因为我们已经知道了max会返回value和index，之间用下标[1]取第二个值就行了
_, predicted = torch.max(outputs, dim=1) # 取出每一行最大值,返回值为（值，索引）反思：
网络存在的问题还有很多，比如明明test 上面的精度已经90多了，然后从网上随便找张图确很容易出错
虽然net的test精度很高，但是不能排除过拟合的问题，可能图片不是同分布的等等....
5. code
1. model 模块
import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module): # 定义网络
def __init__(self):
super(Net,self).__init__() # 继承父类
self.linear1 = nn.Linear(784,512)
self.linear2 = nn.Linear(512,256)
self.linear3 = nn.Linear(256,128)
self.linear4 = nn.Linear(128,64)
self.linear5 = nn.Linear(64,10)
def forward(self,x):
x = x.view(-1,784)
x = F.relu(self.linear1(x))
x = F.relu(self.linear2(x))
x = F.relu(self.linear3(x))
x = F.relu(self.linear4(x))
x = self.linear5(x)
return x
2. train 模块
import torch
import torchvision as tv # 提供数据集
import torchvision.transforms as transforms # 图像处理包
import torch.nn as nn
import torch.nn.functional as F
from torch import optim # 优化器包
from model import Net # 导入建立的网络
transform = transforms.Compose([transforms.ToTensor(), # 改变通道顺序、归一化
transforms.Normalize((0.5,),(0.5,))]) # 归一化
batch_size = 64
# 训练集 6W张图片
trainset =tv.datasets.MNIST(root= './dataset/mnist',train=True,download=True,transform=transform)
trainloader = torch.utils.data.DataLoader(trainset,shuffle = True,batch_size = batch_size)
# 测试集 1W张图片
testset =tv.datasets.MNIST(root= './dataset/mnist',train=False,download=True,transform=transform)
testloader = torch.utils.data.DataLoader(testset,shuffle = False,batch_size = batch_size)
net = Net() # 实例化网络
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(),lr = 0.01,momentum=0.5)
for epoch in range(5):
running_loss = 0.0
for i,data in enumerate(trainloader,0):
inputs,labels =data # 取出对应的数据
optimizer.zero_grad() # 梯度清零
outputs = net(inputs) # 计算预测值
loss = criterion(outputs,labels) # 计算损失值
loss.backward() # 反向传播
optimizer.step() # 梯度更新
running_loss += loss.item() # 取出loss值
if i % 300 ==299:
correct = 0
total = 0
with torch.no_grad(): # 不会计算梯度
for data in testloader: # 从测试集里面取出数据
images, labels = data
outputs = net(images) # 计算预测值
_, predicted = torch.max(outputs, dim=1) # 取出每一行最大值,返回值为（值，索引）
total += labels.size(0) # batch_size
correct += (predicted == labels).sum().item()
print('[%d,%5d] train_loss: %.3f test_accuracy:%.3f'
% (epoch+1,i +1,running_loss/300,correct / total))
running_loss = 0.0
print('Finished Training....')
save_path = './Net.pth'
torch.save(net.state_dict(),save_path)
打印结果为：
3. predict 模块
import torch
import torchvision.transforms as transforms
from PIL import Image
from model import Net
transforms = transforms.Compose([transforms.Resize((28,28)), # 预处理
transforms.ToTensor(),
transforms.Normalize((0.5,),(0.5,))])
net = Net()
net.load_state_dict(torch.load('Net.pth')) # 读取网络参数
im = Image.open('./2.png')
im = transforms(im)
with torch.no_grad():
outputs = net(im)
predict = torch.max(outputs,dim = 1)[1] # 取最大值的index
print(predict)输出为：