pytorch中自带数据集的 写出手写数字的识别模型

pytorch中自带数据集的 写出手写数字的识别模型

 一：介绍下pytorch自带数据集

pyto,rch自带数据集：

torchvision:图像

torchvision.datasetstorchtext：文本

torchtext.datastes

举例说明：

mnist手写数字的加载实例

import torch
import torchvision
from torchvision.datasets import MNIST
minst=MNIST(root="./data",train=True,download=True)
print(minst[0])
minst[2][0].show()#元组类型的数据

二：使用pytorch实现手写数字的识别

步骤：

准备数据模型的构建训练模型的保存模型的评估

MNist数据处理的api

torchvision.transfroms.ToTensor()

把image的（h,w,c）转换为(c,w,h)torchvision.transfroms.Normalize(mean,std)

均值和标准差与通道数的数量是相通的#灰白图片的通道数为1torchvision.transfroms.Compose(transfroms)

传入list,数据经过list中的每一个方法进行处理

一、准备数据：

import torchvision
from torch.utils.data import DataLoader

#准备数据集
def get_load():
    transform_fn=torchvision.transforms.Compose([torchvision.transforms.ToTensor(),
                                                torchvision.transforms.Normalize(mean=(0.1307),std=(0.3081))
                                                ])
    dataset=torchvision.datasets.MNIST(root="./data",train=True,transform=transform_fn)
    data_load=DataLoader(dataset,batch_size=2,shuffle=True
                         )
    return data_load

二、模型构建：

当矩阵相乘时1、第一个矩阵的列数等于第二个矩阵的行数 2、得到的矩阵是第一个矩阵的行数和第二个矩阵的列数

原始数据的输入形状为[bath_size,1,28,28]进行形状的修改[bath_size,28*28]第一个全连接层的输出形状是[bath_size,28]#这个28是自己定激活函数不会修改形状第二个全连接层的输出是[bath_size,10]#10自己定一般最后都是10

class MNIST_Net(nn.Module):
    def __init__(self):
        super(MNIST_Net, self).__init__()
        self.fc1 = nn.Linear(1 * 28 * 28, 28)
        self.fc2 = nn.Linear(28, 10)

    def forward(self, input):
        x = input.view(-1, 28 * 28 * 1)  # 修改形状
        x = self.fc1(x)  # 进行全连接的 *** 作
        x = F.relu(x)  # 进行激活函数的 *** 作
        out = self.fc2(x)  # 输出层
        return F.log_softmax(out)

损失函数：

三、训练:

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

def train():
    model1 = MNIST_Net()  # 实例化模型
    optimizer = Adam(model1.parameters(), lr=0.01)  # 实例化优化器
    data_load = get_load()
    for idx, (input, target) in enumerate(data_load):
        optimizer.zero_grad()
        output = model1(input)
        loss = F.nll_loss(output, target)
        loss.backward()  # 反向传播
        optimizer.step()  # 梯度更新
        print(idx,loss.item())

四、模型的保存和加载：

保存：torch.save(model/optimizer.state_dict(),"path")加载：model/optimizer.load_state_dict(torch.load("path"))

model1 = MNIST_Net()  # 实例化模型
optimizer = Adam(model1.parameters(), lr=0.001)  # 实例化优化器
if os.path.exists("./model/model.pkl"):#路径存在
    model1.load_state_dict(torch.load("./model/model.pkl"))
    optimizer.load_state_dict(torch.load("./model/optimizer.pkl"))

def train():
    data_load = get_load()
    for idx, (input, target) in enumerate(data_load):
        optimizer.zero_grad()
        output = model1(input)
        loss = F.nll_loss(output, target)
        loss.backward()  # 反向传播
        optimizer.step()  # 梯度更新
        if idx%100 ==0:#保存的
            torch.save(model1.state_dict(),"./model/model.pkl")
            torch.save(optimizer.state_dict(),"./model/optimizer.pkl")

train()

五、模型的评估：

完整代码：

import torchvision
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam
import os
import torch

# 准备数据集
def get_load():
    transform_fn = torchvision.transforms.Compose([torchvision.transforms.ToTensor(),
                                                   torchvision.transforms.Normalize(mean=(0.1307,), std=(0.3081,))
                                                   ])
    dataset = torchvision.datasets.MNIST(root="./data", train=True, transform=transform_fn)
    data_load = DataLoader(dataset, batch_size=128, shuffle=True
                           )  # batch_size是一个输入的维度
    return data_load


# 构建模型
class MNIST_Net(nn.Module):
    def __init__(self):
        super(MNIST_Net, self).__init__()
        self.fc1 = nn.Linear(1 * 28 * 28, 28)
        self.fc2 = nn.Linear(28, 10)

    def forward(self, input):
        x = input.view(-1, 28 * 28 * 1)  # 修改形状
        x = self.fc1(x)  # 进行全连接的 *** 作
        x = F.relu(x)  # 进行激活函数的 *** 作
        out = self.fc2(x)  # 输出层
        return F.log_softmax(out)

model1 = MNIST_Net()  # 实例化模型
optimizer = Adam(model1.parameters(), lr=0.001)  # 实例化优化器
if os.path.exists("./model/model.pkl"):
    model1.load_state_dict(torch.load("./model/model.pkl"))
    optimizer.load_state_dict(torch.load("./model/optimizer.pkl"))

def train():
    data_load = get_load()
    for idx, (input, target) in enumerate(data_load):
        optimizer.zero_grad()
        output = model1(input)
        loss = F.nll_loss(output, target)
        loss.backward()  # 反向传播
        optimizer.step()  # 梯度更新
        print(loss.item())
        if idx%100 ==0:
            torch.save(model1.state_dict(),"./model/model.pkl")
            torch.save(optimizer.state_dict(),"./model/optimizer.pkl")

train()