MNIST手写数字识别实战演练

Tqdm 是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)。

可以在命令行使用pip命令安装，也可以在pycharm中安装，按图中步骤，点一下cuda库，然后在搜索框 搜索tqdm直接点击install即可。

安装好之后测试一下：

import time
from tqdm import tqdm#导入tqdm
a = 10
b = range(a)#从0到10
c = tqdm(b, total=a)#使用tqdm产生一个进度条，并且会实时的推算剩余时间
for i in c:
    time.sleep(1)#使用for循环迭代,把进度条打印出来了，

运行结果：
  0%|          | 0/10 [00:00 
2.计算数据标准化参数 
使用官方提供的：均值mean = 0.1307,标准差std = 0.3081
 
3.模型保存与优化器保存 
torch.save(model.state_ldict(),path)#模型保存
torch.save(optimizer.state_dict(), path)#优化器保存

#模型加载
model.loade_state_dict(torch.load(path))
optimizer.load_state_dict(torch.load(path))
 
4.深度学习torch三件套 
(1)梯度置0:optimizer.zero_grad() 

 #传播：前向传播，把原来的图像通过transfroms翻译之后作为参数传入，给我们返回一个模型计算出来的值，然后通过这个值与标签进行比对，继而得到损失值
 #然后使用损失进行反向传播，再进行单次优化  
 

 (2)反向传播:loss.backward() 

 #梯度置0就是把loss关于weigh的导数置为0，都不需要与其他的mini_batch混合起来计算 
 当网络参数进行反馈的时候，梯度是一个累加的过程，而不是可替代的；但是在处理每一个batch_size的时候都是累加的，但是我们并不希望他是累加的，我们希望每一次都是独立的。如果累加的话酒瓯相当于增加了batch_size的尺寸了，这是我们不需要的，所以在进行每一次训练而不是每一轮都需要进行梯度置0.
 
(3)单次优化：optimizer.step 
#梯度置0:optimizer.zero_grad()

#反向传播:loss.backward()

#单次优化：optimizer.step
 
二、训练 
1.MNIST手写数字识别训练流程： 
 
 2.交叉熵损失: 
 
 
http://zhuanlan.zhihu.com/p/35709485
 
 
3.代码： 
（1）数据源标注与图像预处理 
from torchvision.datasets import MNIST
from torchvision import transforms

#图像处理
my_transforms = transforms.Compose(
    [transforms.PILToTensor(),
     transforms.Normalize(mean=(0.1307,), std=(0.3081,))#图像标准化处理

     ]
)
#获取数据源
mnist_train = MNIST(root="../MNIST_data", train=True, download=True, transform=my_transforms)
 
（2）数据加载 
#数据加载
from torch.utils.data import DataLoader#导入数据加载器
dataloader = DataLoader(mnist_train, batch_size=8, shuffle=True)
for (images, labels) in dataloader:
    pass
 
（3）模型选择 
from torch import nn

class MnistModel(nn.Module):
    def __init__(self):#继承__init__方法
        super(MnistModel, self).__init__()
        self.fc1 = nn.Linear(1*28*28, 10)#最初传入的图片的像素点是1*28*28的，最后我们要收敛成10个结果

    def forward(self, image):#继承前向传播的方法
        image_viwed = image.view(-1, 1*28*28)#此处需要拍平
        out = self.fc1(image_viwed)
        return out


#实例化模型
model =  MnistModel()
 
（4）优化器选择：Adam 
from  torch import optim#导入优化器

optim.Adam(model.parameters(), lr=1e-4)
 
（5）损失函数 
#损失函数
loss_functon = nn.CrossEntropyLoss()
 
（6）在dataloader上面套一个tqdm 
dataloader = tqdm(dataloader, total=len(dataloader))
 
（7）做一个循环 
#循环可迭代对象
for (images, labels) in dataloader:
 
（8）深度学习torch三件套 
 #梯度置零
    optimizer.zero_grad()
    #前向传播
    output = model(images)
    #计算损失
    loss = loss_functon(output, labels)
    #反向传播
    loss.backward()
    #优化器更新
    optimizer.step()
 
（9）模型与优化器的保存 
#保存模型
save(model.state_dict(), 'models/model.pkl')
save(optimizer.state_dict(), 'models/optimizer.pkl')
#save中第二个参数是保存路径'models/model.pkl'
 
（10）运行代码完成第一轮epoch 
运行结果：

  0%|          | 0/7500 [00:00 
（11）运行完成后，在当前保存路径下可以看到保存好的模型和优化器 
 
 三、测试观察训练效果 
1.手写数字识别分类测试 
from torchvision.datasets import MNIST
from torchvision import transforms
from torch.utils.data import DataLoader
from torch import nn
from tqdm import tqdm
# from MNIST_train import test
import os#判断路径是否存在的模块
# import numpy as np
import torch



class MnistModel(nn.Module):
    def __init__(self):#继承__init__方法
        super(MnistModel, self).__init__()
        self.fc1 = nn.Linear(1*28*28, 10)#最初传入的图片的像素点是1*28*28的，最后我们要收敛成10个结果

    def forward(self, image):#继承前向传播的方法
        image_viwed = image.view(-1, 1*28*28)#此处需要拍平
        out = self.fc1(image_viwed)
        return out
#实例化模型
model = MnistModel()
if os.path.exists('models/model.pkl'):
    model.load_state_dict(torch.load('models/model.pkl'))

#损失函数
loss_functon = nn.CrossEntropyLoss()

#图像处理
my_transforms = transforms.Compose(
    [transforms.ToTensor(),
     #transforms.PILToTensor(),
     transforms.Normalize(mean=(0.1307,), std=(0.3081,))#图像标准化处理

     ]
)
#获取数据源
mnist_train = MNIST(root="../MNIST_data", train=False, download=True, transform=my_transforms)

#数据加载
# from torch.utils.data import DataLoader#导入数据加载器
dataloader = DataLoader(mnist_train, batch_size=8, shuffle=True)
dataloader = tqdm(dataloader, total=len(dataloader))

model.eval()
with torch.no_grad():
    for images, labels in dataloader:

     #获取结果
        output = model(images)
        print(output)
        exit()
    #计算损失
        loss = loss_functon(output, labels)



运行结果：
  0%|          | 0/1250 [00:00 
2.获取每个分类中可能性最大的 
model.eval()
with torch.no_grad():
    for images, labels in dataloader:

     #获取结果
        output = model(images)
        result = output.max(dim=1)#在dim=1的维度上面比较每一个列表里的十个数
        print(result)
        exit()


运行结果：
  0%|          | 0/1250 [00:00 
3.获取最大可能的索引 
   for images, labels in dataloader:

     #获取结果
        output = model(images)
        result = output.max(dim=1).indices#获取索引
        print(result)#打印训练结果
        print(labels)#打印标签
        exit()
    #计算损失
        loss = loss_functon(output, labels)


#运行结果：
  0%|          | 0/1250 [00:00 
4.比较结果与标签 
print(result.eq(labels))#比较result与labels是否相等
 
运行结果：

  0%|          | 0/1250 [00:00 
5.求准确率，即均值 
布尔类型不能直接求均值，需要使用强制类型转化吧布尔值转换为浮点类型
 
print(result.eq(labels).float().mean())#先转换成浮点类型再求均值


运行结果：
  0%|          | 0/1250 [00:00 
6.item将元素取出来 
 print(result.eq(labels).float().mean().item())#把识别准确率取出来

运行结果：
1.0
  0%|          | 0/1250 [00:00 
7.append方法把识别准确率保存下来 
# from torchvision.datasets import MNIST
# from torchvision import transforms
# from torch.utils.data import DataLoader
# from torch import nn
# from torch import optim#导入优化器
# from tqdm import tqdm#导入tqdm
# from torch import save

# from torch import save, load
from torchvision.datasets import MNIST
from torchvision import transforms
from torch.utils.data import DataLoader
from torch import nn
from tqdm import tqdm
# from MNIST_train import test
import os#判断路径是否存在的模块
import numpy as np
import torch



class MnistModel(nn.Module):
    def __init__(self):#继承__init__方法
        super(MnistModel, self).__init__()
        self.fc1 = nn.Linear(1*28*28, 10)#最初传入的图片的像素点是1*28*28的，最后我们要收敛成10个结果

    def forward(self, image):#继承前向传播的方法
        image_viwed = image.view(-1, 1*28*28)#此处需要拍平
        out = self.fc1(image_viwed)
        return out
#实例化模型
model = MnistModel()
if os.path.exists('models/model.pkl'):
    model.load_state_dict(torch.load('models/model.pkl'))

#损失函数
loss_functon = nn.CrossEntropyLoss()

#图像处理
my_transforms = transforms.Compose(
    [transforms.ToTensor(),
     #transforms.PILToTensor(),
     transforms.Normalize(mean=(0.1307,), std=(0.3081,))#图像标准化处理

     ]
)
#获取数据源
mnist_train = MNIST(root="../MNIST_data", train=False, download=True, transform=my_transforms)

#数据加载
# from torch.utils.data import DataLoader#导入数据加载器
dataloader = DataLoader(mnist_train, batch_size=8, shuffle=True)
dataloader = tqdm(dataloader, total=len(dataloader))
succeed = []#保存准确率的列表
model.eval()
with torch.no_grad():
    for images, labels in dataloader:

     #获取结果
        output = model(images)
        result = output.max(dim=1).indices#获取索引
        # print(result)#打印训练结果
        # print(labels)#打印标签
        # print(result.eq(labels))#比较result与labels是否相等
        # print(result.eq(labels).float().mean())
        # print(result.eq(labels).float().mean().item())#把识别准确率取出来
        succeed.append(result.eq(labels).float().mean().item())
        # exit()
    #计算损失
        loss = loss_functon(output, labels)

print('一轮的成功率', np.mean(succeed))




运行结果：
  0%|          | 0/1250 [00:00 
上述便是对手写数字识别的训练，那么如何进行多轮训练呢？