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

简介: PyTorch使用神经网络进行手写数字识别实战(附源码,包括损失图像和准确率图像)

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

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

1:数据预处理

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

2:读取训练数据

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

预处理过后的数据如下

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的对象看到其网络结构

4:模型评估

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

得到的结果如下

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

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

 

准确率图像如下

最后 部分源码如下

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()

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

相关文章
|
4月前
|
机器学习/深度学习 PyTorch 算法框架/工具
PyTorch 中的动态计算图:实现灵活的神经网络架构
【8月更文第27天】PyTorch 是一款流行的深度学习框架,它以其灵活性和易用性而闻名。与 TensorFlow 等其他框架相比,PyTorch 最大的特点之一是支持动态计算图。这意味着开发者可以在运行时定义网络结构,这为构建复杂的模型提供了极大的便利。本文将深入探讨 PyTorch 中动态计算图的工作原理,并通过一些示例代码展示如何利用这一特性来构建灵活的神经网络架构。
339 1
|
4天前
|
机器学习/深度学习 算法 PyTorch
基于Pytorch Gemotric在昇腾上实现GraphSage图神经网络
本文详细介绍了如何在昇腾平台上使用PyTorch实现GraphSage算法,在CiteSeer数据集上进行图神经网络的分类训练。内容涵盖GraphSage的创新点、算法原理、网络架构及实战代码分析,通过采样和聚合方法高效处理大规模图数据。实验结果显示,模型在CiteSeer数据集上的分类准确率达到66.5%。
|
4月前
|
机器学习/深度学习 人工智能 PyTorch
【深度学习】使用PyTorch构建神经网络:深度学习实战指南
PyTorch是一个开源的Python机器学习库,特别专注于深度学习领域。它由Facebook的AI研究团队开发并维护,因其灵活的架构、动态计算图以及在科研和工业界的广泛支持而受到青睐。PyTorch提供了强大的GPU加速能力,使得在处理大规模数据集和复杂模型时效率极高。
204 59
|
3月前
|
机器学习/深度学习
小土堆-pytorch-神经网络-损失函数与反向传播_笔记
在使用损失函数时,关键在于匹配输入和输出形状。例如,在L1Loss中,输入形状中的N代表批量大小。以下是具体示例:对于相同形状的输入和目标张量,L1Loss默认计算差值并求平均;此外,均方误差(MSE)也是常用损失函数。实战中,损失函数用于计算模型输出与真实标签间的差距,并通过反向传播更新模型参数。
|
4月前
|
机器学习/深度学习 PyTorch 算法框架/工具
PyTorch代码实现神经网络
这段代码示例展示了如何在PyTorch中构建一个基础的卷积神经网络(CNN)。该网络包括两个卷积层,分别用于提取图像特征,每个卷积层后跟一个池化层以降低空间维度;之后是三个全连接层,用于分类输出。此结构适用于图像识别任务,并可根据具体应用调整参数与层数。
|
4月前
|
机器学习/深度学习 PyTorch TensorFlow
【PyTorch】PyTorch深度学习框架实战(一):实现你的第一个DNN网络
【PyTorch】PyTorch深度学习框架实战(一):实现你的第一个DNN网络
191 1
|
4月前
|
机器学习/深度学习 人工智能 PyTorch
AI智能体研发之路-模型篇(五):pytorch vs tensorflow框架DNN网络结构源码级对比
AI智能体研发之路-模型篇(五):pytorch vs tensorflow框架DNN网络结构源码级对比
83 1
|
4月前
|
机器学习/深度学习 PyTorch 测试技术
深度学习入门:使用 PyTorch 构建和训练你的第一个神经网络
【8月更文第29天】深度学习是机器学习的一个分支,它利用多层非线性处理单元(即神经网络)来解决复杂的模式识别问题。PyTorch 是一个强大的深度学习框架,它提供了灵活的 API 和动态计算图,非常适合初学者和研究者使用。
57 0
|
6月前
|
机器学习/深度学习 PyTorch 算法框架/工具
【从零开始学习深度学习】26.卷积神经网络之AlexNet模型介绍及其Pytorch实现【含完整代码】
【从零开始学习深度学习】26.卷积神经网络之AlexNet模型介绍及其Pytorch实现【含完整代码】
|
6月前
|
机器学习/深度学习 PyTorch 算法框架/工具
【从零开始学习深度学习】28.卷积神经网络之NiN模型介绍及其Pytorch实现【含完整代码】
【从零开始学习深度学习】28.卷积神经网络之NiN模型介绍及其Pytorch实现【含完整代码】
下一篇
DataWorks