02pytorch入门手写字体识别mnist

手写数字识别理论

1. 什么是机器识别手写数字

输入：数字图片–>处理：网络模型–>输出：识别结果

2. mnist数据集是什么

该数据集包含60000个用于训练的示例和10000个用于测试的示例

该数据集包含0到9共10类手写数字图片，每张图片都做了尺寸归一化，都是28X28大小的灰度图。

3. 手写字体的识别流程

• 定义超参数（自己定义的一些常量，比如你想这个循环跑几次，10次，这个就是超参数）
• 构建transforms，主要是对图像做变换
• 下载、加载数据集mnist
• 构建网络模型，定义优化器
• 定义训练方法
• 定义测试方法
• 开始训练模型，输出预测结果

手写数字识别实战

专业名词的解释

• 参数与超参数

参数：模型f（x，θ）中的θ称为模型的参数，可以通过优化算法进行学习

超参数：用来定义模型结构或者优化策略

• batch_size批处理

每次处理的数据数量

• epoch轮次

把每一个数据集，循环运行几轮

• transforms变换

主要将图片转化为tensor，旋转图片，以及正则化

• nomalize正则化

模型出现过拟合现象时，降低模型复杂度

• 卷积层

由卷积核构建，卷积核简称为卷积，也称为滤波器，卷积的大小可以在实际需要时自定义其长和宽

• 池化层

对图片进行压缩（降采样）的一种方法如max pooling 、average pooling等

• 激活层

激活函数的作用就是，在所有的隐藏层之间添加一个激活函数，这样的输出就是一个非线性函数了，因而神经网络的表达能力更加强大了。

• 损失函数

在深度学习中，损失反映模型最后预测结果与实际真值之间的差距，可以用来分析训练过程的好坏，模型是否收敛等，例如均方损失、交叉熵损失等。

代码部份

# 加载必要的库
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets,transforms

# 定义超参数
BATCH_SIZE = 64  # 每一批处理的数据
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
EPOCHS = 10  # 训练数据集的轮次
# 构建pipeline 对图像处理
pipeline = transforms.Compose([
    transforms.ToTensor(),# 将图片转换成tensor（张量）
    transforms.Normalize((0.1307,),(0.3081,))# 正则化：降低模型复杂度
])

# 下载、加载数据
from torch.utils.data import DataLoader

# 下载数据集
train_set = datasets.MNIST("data",train=True,download=True,transform=pipeline)
test_set = datasets.MNIST("data",train=False,download=True,transform=pipeline)
# 加载数据集
train_loader = DataLoader(train_set,batch_size=BATCH_SIZE,shuffle=True)
test_loader = DataLoader(test_set,batch_size=BATCH_SIZE,shuffle=True)

# 构建网络模型
class Digit(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1=nn.Conv2d(1,10,5)  # 1：灰度图片的通道 10：输出通道 5：kernel卷积核
        self.conv2 = nn.Conv2d(10, 20, 3)  #  10：输入通道 20：输出通道，500：输出通道
        self.fc1 = nn.Linear(20*10*10,500)  # 20*10*10:输入通道 ，500：输出通道
        self.fc2 = nn.Linear(500,10)  # 500:输入通道 ，10：输出通道

    def forward(self,x):
        input_size=x.size(0) # batch_size
        x=self.conv1(x) # 输入：batch*1*28*28，输出：batch*10*24*24（28-5+1）
        x=F.relu(x) #  保持shape不变，输出：batch*10*24*24
        x=F.max_pool2d(x,2,2)  # 输入：batch*10*24*24 输出：batch*10*12*12

        x= self.conv2(x)#输入：batch*10*12*12 输出：batch*20*10*10（12-3+1）
        x= F.relu(x)

        x=x.view(input_size,-1)# 拉平，-1自动计算维度20*10*10

        x=self.fc1(x)#输入：batch*2000 输出batch*500
        x= F.relu(x)#保持shape不变

        x = self.fc2(x)# 输入：batch*500 输 出batch*10

        output = F.log_softmax(x,dim=1)#计算分类后，每个数字的概率值
        return output

# 定义优化器
model = Digit().to(DEVICE)

optimizer = optim.Adam(model.parameters())

# 定义训练方法
def train_model(model,device,train_loader,optimizer,epoch):
    # 模型训练
    model.train()
    for batch_index, (data,target) in enumerate(train_loader):
        #部署到DEVICE
        data, target = data.to(device),target.to(device)
        # 梯度初始化为0
        optimizer.zero_grad()
        # 训练后的结果
        output = model(data)
        # 计算损失
        loss = F.cross_entropy(output,target)
        # 反向传播
        loss.backward()
        # 参数优化
        optimizer.step()
        if batch_index % 3000 == 0:
            print("Train Epoch :{} \t Loss : {:.6f}".format(epoch,loss.item()))

# 定义测试方法
def test_model(model,device,test_loader):
    # 模型验证
    model.eval()
    #正确率
    correct = 0.0
    # 测试损失
    test_loss = 0.0
    with torch.no_grad(): # 不会计算梯度，也不会进行反向传播
        for  data,target in test_loader:
            # 部署到DEVICE
            data, target = data.to(device),target.to(device)
            # 测试数据
            output = model(data)
            # 计算测试损失
            test_loss +=F.cross_entropy(output,target).item()
            # 找到概率值最大的下标
            pred = output.max(1,keepdim=True)[1]
            # 累计正确的值
            correct += pred.eq(target.view_as(pred)).sum().item()
        test_loss /= len(test_loader.dataset)
        print("Test --Average loss :{:.4f},Accuracy : {:.3f}\n".format(test_loss,100*correct/len(test_loader.dataset)))

for epoch in range(1,EPOCHS+1):
    train_model(model,DEVICE,train_loader,optimizer,epoch)
    test_model(model,DEVICE, test_loader)

结果

n(test_loader.dataset)))

for epoch in range(1,EPOCHS+1):
train_model(model,DEVICE,train_loader,optimizer,epoch)
test_model(model,DEVICE, test_loader)

## 结果

![在这里插入图片描述](https://img-blog.csdnimg.cn/4fb02a58a1a34397a61c71a6c94a6c12.png)