PyTorch使用神经网络进行手写数字识别实战（附源码，包括损失图像和准确率图像）

淩亂°似流年 2023-09-30 16:38 40阅读 0赞

> **全部源码请点赞关注收藏后评论区留言即可~~~**

下面使用torchvision.datasets.MNIST构建手写数字数据集。

## 1：数据预处理 ##

PyTorch提供了torchvision.transforms用于处理数据及数据增强，它可以将数据从\[0,255\]映射到\[0,1\]

## 2：读取训练数据 ##

准备好处理数据的流程后，就可以读取用于训练的数据了，torch.util.data.DataLoader提供了迭代数据，随机抽取数据，批量化数据等等功能 读取效果如下

![f8aafbabfe7748a4a75e5cf99afa9c05.png][]

预处理过后的数据如下

![d3f9efc4e6ec42d297fb705da519cbc5.png][]

## 3：构建神经网络模型 ##

下面构建用于识别手写数字的神经网络模型

class MLP(nn.Module):
        def __init__(self):
            super(MLP,self).__init__()
    
            self.inputlayer=nn.Sequential(nn.Linear(28*28,256),nn.ReLU(),nn.Dropout(0.2))
    
            self.hiddenlayer=nn.Sequential(nn.Linear(256,256),nn.ReLU(),nn.Dropout(0.2))
            self.outputlayer=nn.Sequential(nn.Linear(256,10))
    
        def forward(self,x):
            x=x.view(x.size(0),-1)
            x=self.inputlayer(x)
            x=self.hiddenlayer(x)
            x=self.outputlayer(x)
            return x

可以直接通过打印nn.Module的对象看到其网络结构

![25eec641de23460991953fac95d0998e.png][]

## 4：模型评估 ##

在准备好数据和模型后，就可以训练模型了，下面分别定义了数据处理和加载流程，模型，优化器，损失函数以及用准确率评估模型能力。

得到的结果如下

训练一次 可以看出比较混乱 没有说明规律可言

![2317aad5038649bc905b242272283747.png][]

训练五次的损失函数如下 可见随着训练次数的增加是逐渐收敛的，规律也非常明显

![300bfb1e5151431f9329cadd4ac81af4.png][]

准确率图像如下

![491d8dea18164570a5bdad7258e7d643.png][]

最后 部分源码如下

import torch
    import torchvision
    
    import  torch.nn as nn
    from torch import  optim
    from tqdm import  tqdm
    import torch.utils.data.dataset
    
    mnist=torchvision.datasets.MNIST(root='~',train=True,download=True)
    for i,j in enumerate(np.random.randint(0,len(mnist),(10,))):
        data,label=mnist[j]
        plt.subplot(2,5,i+1)
        plt.show()
    trans=transforms.Compose(
        [
            transforms.ToTensor(),
            transforms.Normalize((0.1307,),(0.3081,))
        ]
    )
    normalized=trans(mnist[0][0])
    from torchvision import  transforms
    mnist=torchvision.datasets.MNIST(root='~',train=True,download=True,transform=trans)
    def imshow(img):
        img=img*0.3081+0.1307
        npimg=img.numpy()
        plt.imshow(np.transpose(npimg,(1,2,0)))
    dataloader=DataLoader(mnist,batch_size=4,shuffle=True,num_workers=0)
    images,labels=next(iter(dataloader))
    imshow(torchvision.utils.make_grid(images))
    
    class MLP(nn.Module):
        def __init__(self):
            super(MLP,self).__init__()
    
            self.inputlayer=nn.Sequential(nn.Linear(28*28,256),nn.ReLU(),nn.Dropout(0.2))
    
            self.hiddenlayer=nn.Sequential(nn.Linear(256,256),nn.ReLU(),nn.Dropout(0.2))
            self.outputlayer=nn.Sequential(nn.Linear(256,10))
    
        def forward(self,x):
            x=x.view(x.size(0),-1)
            x=self.inputlayer(x)
            x=self.hiddenlayer(x)
            x=self.outputlayer(x)
            return x
    print(MLP())
    trans=transforms.Compose(
        [
            transforms.ToTensor(),
            transforms.Normalize((0.1307,),(0.3081,))
        ]
    )
    al=torchvision.datasets.MNIST(root='~',train=False,download=True,transform=trans)
    trainloader=DataLoader(mnist_train,batch_size=16,shuffle=True,num_workers=0)
    valloader=DataLoader(mnist_val,batch_size=16,shuffle=True,num_workers=0)
    
    #模型
    model=MLP()
    #优化器
    optimizer=oD(model.parameters(),lr=0.01,momentum=0.9)
    
    #损失函数
    celoss=nn.ssEntropyLoss()
    best_acc=0
    
    #计算准确率
    def accuracy(pred,target):
        pred_label=torch.amax(pred,1)
        correct=sum(pred_label==target).to(torch.float)
        return correct,len(pred)
    acc={'train':[],"val}
    loss_all={'train':[],"val":[]}
    for epoch in tqdm(range(5)):
    
        model.eval()
        numer_val,denumer_val,loss_tr=0.,0.,0.
        with torch.no_grad():
            for data,target in valloader:
                output=model(data)
                loss=celoss(output,target)
                loss_tr+=loss.data
    
                num,denum=accuracy(output,target)
                numer_val+=num
                denumer_val+=denum
    
        #设置为训练模式
        model.train()
        numer_tr,denumer_tr,loss_val=0.,0.,0.
        for data,target in trainloader:
            optizer.zero_grad()
            output=model(data)
            loss=celoss(output,target)
            loss_val+=loss.data
            loss.backward()
            optimer.step()
            num,denum=accuracy(output,target)
            numer_tr+=num
            denumer_tr+=denum
        loss_all['train'].append(loss_tr/len(trainloader))
        loss_all['val'].aend(lss_val/len(valloader))
        acc['train'].pend(numer_tr/denumer_tr)
        acc['val'].append(numer_val/denumer_val)
    
    """
    plt.plot(loss_all['train'])
    plt.plot(loss_all['val'])
    """
    
    plt.plot(acc['train'])
    plt.plot(acc['val'])
    
    plt.show()

**创作不易 觉得有帮助请点赞关注收藏~~~**

[f8aafbabfe7748a4a75e5cf99afa9c05.png]: https://img-blog.csdnimg.cn/f8aafbabfe7748a4a75e5cf99afa9c05.png
[d3f9efc4e6ec42d297fb705da519cbc5.png]: https://img-blog.csdnimg.cn/d3f9efc4e6ec42d297fb705da519cbc5.png
[25eec641de23460991953fac95d0998e.png]: https://img-blog.csdnimg.cn/25eec641de23460991953fac95d0998e.png
[2317aad5038649bc905b242272283747.png]: https://img-blog.csdnimg.cn/2317aad5038649bc905b242272283747.png
[300bfb1e5151431f9329cadd4ac81af4.png]: https://img-blog.csdnimg.cn/300bfb1e5151431f9329cadd4ac81af4.png
[491d8dea18164570a5bdad7258e7d643.png]: https://img-blog.csdnimg.cn/491d8dea18164570a5bdad7258e7d643.png