AI练手系列（三）—— RNN实现mnist手写数字识别

最新推荐文章于 2023-03-30 20:24:39 发布
最新推荐文章于 2023-03-30 20:24:39 发布
阅读量3.7k 收藏 51
点赞数 9
分类专栏： AI练手系列 文章标签： 深度学习 pytorch 机器学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rongsenmeng2835/article/details/107389038
版权

mnist数据集作为一个经典的数据集，不少机器学习深度学习的初学者都对其下过手，它干净的数据集、训练难度也不是很高，作为初学练手，很适合了。今天我也来拜会一下这位经典大哥，看看到底感觉如何。

本次训练使用RNN的网络模型，其实其他模型也可以，但是这两天不是正好温习RNN嘛，就刚好学以致用嘛。

请套路先生上场吧：

1.导包定参

当你新建完一个python文件不管是py文件还是ipynb文件，不管会不会，先把常用的包导入进来再说，常定义几个超参数也请上来：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.datasets as datasets
import torchvision.transforms as transforms
import matplotlib.pyplot as plt 
from torch.utils.data import DataLoader

 #定义超参数
EPOCH = 10
BATCH_SIZE = 64
LR = 0.001
TIME_STEP = 28
INPUT_SIZE = 28

2.数据加载

先把数据加载进来，虽然mnist数据集可以在线下载，但可能比较慢，我更喜欢先把数据下载到本地再加载进来，这一块的处理和cifar-10那篇就很像了。可以去回顾一下：

AI练手系列（一）—— 利用Pytorch训练CIFAR-10数据集

#数据加载
train_data = datasets.MNIST (root='./mnist',train=True,transform=transforms.ToTensor(),download=True )
test_data = datasets.MNIST(root='./mnist',train=False,
                              transform=transforms.ToTensor(),download=True )
                            
print(train_data)
print(test_data)

我们把数据的一些特征打印出来看一眼：

Dataset MNIST

Number of datapoints: 60000

Root location: ./mnist

Split: Train

StandardTransform

Transform: ToTensor()

Dataset MNIST

Number of datapoints: 10000

Root location: ./mnist

Split: Test

StandardTransform

Transform: ToTensor()

可以看到训练集60000个样本，测试集10000个，现在已经都被我们转为tensor格式了。

下面该干嘛了，数据预处理哈，归一化、分批啥的都可以搞起了。

3.数据预处理

图片数据可视化

数据是图像的话我比较喜欢先搞一张出来看看：

plt.imshow(train_data.train_data[0].numpy(),cmap='gray')
plt.show()

可以看到：

image-20200716124631808

这一下就直观多了，我们继续：

数据归一化

test_x = test_data.test_data.type(torch.FloatTensor)[:2000]/255#归一化
test_y = test_data.test_labels.numpy()[:2000]

数据分批

数据分批的套路和之前cifar-10的处理也基本一致：

#数据分批
train_loader = DataLoader(dataset=train_data,batch_size=BATCH_SIZE,shuffle=True)
test_loader = DataLoader(dataset=test_data,batch_size=BATCH_SIZE,shuffle=True)

#了解一下数据特征，图片是28*28个像素
#print(type(train_loader))
dataiter= iter(train_loader)
imgs,labs = next(dataiter)
print(imgs)#imgs.size()=torch.Size([64, 1, 28, 28])
print(labs)#图片的标签，就是类别，mnist一共有10个类别，故其取值分布在[0,9]之间

4.定义网络模型

#定义网络
class RNN(nn.Module):
    def __init__(self):
        super(RNN,self).__init__()
        #输入是两个月的数据input_size=2，输出是下一个月的数据output_size=1，中间隐藏层的层数任意指定，指定为4
        input_size,hidden_size,output_size = INPUT_SIZE,64,10
        num_layers = 1
        #self.rnn = nn.RNN(input_size,hidden_size,num_layers,batch_first=True)
        self.rnn = nn.LSTM(input_size,hidden_size,num_layers,batch_first=True)
        #self.rnn = nn.GRU(input_size,hidden_size,num_layers,batch_first=True)
        self.out = nn.Linear(hidden_size,output_size)
    def forward(self,x):
        r_out,_ = self.rnn(x)
        out = self.out(r_out[:,-1,:])
        #b,s,h = x.shape #batch,seq,hidden
       # x = x.view(b*s,h)#转化为线性层的输入
       # x = self.out(x)
        #x = x.view(b,s,-1)#(99, 1, 1)
        return out

5.设置使用GPU

#设置使用GPU
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

#使用定义好的RNN
model = RNN()
#模型和输入数据都需要to device
mode  = model.to(device)

6.定义损失函数及优化器

#定义损失函数,分类问题使用交叉信息熵
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),lr= LR)

7.模型训练与测试

模型训练一般包含几个步骤：

  1. 取出数据及标签并均送入GPU或CPU
  2. 前向传播
  3. 计算损失函数
  4. 清空上一轮梯度
  5. 反向传播
  6. 参数更新
  7. 周期打印loss值或tensorboard数据保存绘图
  8. 保存模型参数（非必要）
  9. 在训练的同时进行测试，得到准确率（可单独进行）
#开始训练
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter('cifar-10')
for epoch in range(EPOCH):
    #60000/BATCH_SIZE
    for step,data in enumerate(train_loader):
        #取出数据及标签
        inputs,labels = data
        inputs = inputs.view(-1,28,28)
        #数据及标签均送入GPU或CPU
        inputs,labels = inputs.to(device),labels.to(device)
        
        #前向传播
        outputs = model(inputs)
        #计算损失函数
        loss = criterion(outputs,labels)
        #清空上一轮的梯度
        optimizer.zero_grad()
        
        #反向传播
        loss.backward()
        #参数更新
        optimizer.step()
        #测试，计算准确率
        if  step%100 == 0:
            writer.add_scalar("Train/Loss", loss.item(), epoch*len(train_loader)+step)

            test_outputs = model(test_x.cuda())
            pred_y = torch.max(test_outputs,1)[1].data.cpu().numpy()
            accuracy = float((pred_y == test_y).astype(int).sum())/ float(test_y.size)
            print ('Epoch: {}, Step: {}, loss: {}, accuracy: {}'.format(epoch, step, loss.item(), accuracy))
            writer.add_scalar("Accuracy", 100.0*accuracy, epoch*len(train_loader)+step)
    #print('epoch{} loss:{:.4f}'.format(epoch+1,loss.item()))

我们EPOCH=10时，看一下开头和结尾的记录：

Epoch: 0, Step: 0, loss: 2.3028504848480225, accuracy: 0.092

Epoch: 0, Step: 100, loss: 1.3167051076889038, accuracy: 0.549

Epoch: 0, Step: 200, loss: 0.7903525829315186, accuracy: 0.743

Epoch: 0, Step: 300, loss: 0.6392905712127686, accuracy: 0.806

Epoch: 0, Step: 400, loss: 0.47715359926223755, accuracy: 0.8445

Epoch: 0, Step: 500, loss: 0.3677961826324463, accuracy: 0.827

Epoch: 0, Step: 600, loss: 0.4239515960216522, accuracy: 0.8695

Epoch: 0, Step: 700, loss: 0.10473807901144028, accuracy: 0.891

Epoch: 0, Step: 800, loss: 0.28696632385253906, accuracy: 0.9055

Epoch: 0, Step: 900, loss: 0.09985525161027908, accuracy: 0.904

可以发现第一轮训练模型的loss就收敛的很快了，准确率迅速上升；

再看最后一轮：

Epoch: 9, Step: 0, loss: 0.029277682304382324, accuracy: 0.9715

Epoch: 9, Step: 100, loss: 0.028733856976032257, accuracy: 0.9735

Epoch: 9, Step: 200, loss: 0.045807115733623505, accuracy: 0.9715

Epoch: 9, Step: 300, loss: 0.09034416824579239, accuracy: 0.973

Epoch: 9, Step: 400, loss: 0.022646501660346985, accuracy: 0.97

Epoch: 9, Step: 500, loss: 0.01956302672624588, accuracy: 0.968

Epoch: 9, Step: 600, loss: 0.19199049472808838, accuracy: 0.974

Epoch: 9, Step: 700, loss: 0.1159246563911438, accuracy: 0.97

Epoch: 9, Step: 800, loss: 0.03719437122344971, accuracy: 0.9655

Epoch: 9, Step: 900, loss: 0.05097261443734169, accuracy: 0.9715

最后会有一点反复了，我们使用了tensorboard，可以对训练过程进行可视化：

image-20200630191115988

image-20200630191149596

效果还行，但还可以优化。

8.模型验证

按上面的结果，我们可以找几个样本来验证一下：

# 从测试集选出30个，进行验证
test_x = test_x.cuda()
test_output = model(test_x[:30].view(-1, 28, 28))
pred_y = torch.max(test_output, 1)[1].data.cpu().numpy()
print('预测数字', pred_y)
print('实际数字', test_y[:30])

看一下结果：

预测数字 [7 2 1 0 4 1 4 9 5 9 0 6 9 0 1 5 9 7 8 4 9 6 6 5 4 0 7 4 0 1]

实际数字 [7 2 1 0 4 1 4 9 5 9 0 6 9 0 1 5 9 7 3 4 9 6 6 5 4 0 7 4 0 1]

对比看一下，准确率还是挺高的。模型还可以继续优化，包括可以试一下RNN和GRU，包括调整一下超参，都是顺手一改的事，这里就不再赘述了。

小小总结

经典数据集的训练总能让人收益很多，首先它能让你对整个训练过程更加熟悉，而且由于网上有大量前人的笔记，这对初学者来说也是很友好的，拿这样的小作业练手，能让我们对框架使用、模型特性、原理技巧都会有更深的理解。

加油，跑起来，就有了风。

知了爱啃代码
关注
专栏目录
Keras 框架实现卷积神经网络mnist手写数字识别(Keras实现mnist手写数字识别)
程序员光剑
09-27 933
随着深度学习的火热，人们越来越多地选择使用CNN作为机器学习模型，在图像识别、自然语言处理、文本分析等领域取得了不错的效果。Keras是一个支持多种深度学习框架（TensorFlow、Theano、CNTK）的开源项目，它提供了简洁、可靠且高效的构建、训练和部署模型的能力。因此，熟悉Keras的结构及其组件特性对于掌握深度学习模型结构以及构建相关模型十分重要。本文通过结合Keras的实现过程，详细介绍了卷积神经网络MNIST手写数字识别的过程。
【NLP】RNN实现识别MNIST数据集（Pytorch）
nghhfgh的博客
05-08 687
根据《pytorch深度学习入门与实战》一书所写，完完整整的一次MNIST数据集识别。
torch07：RNN--MNIST识别和自己数据集
MachineLP的专栏
06-02 1758
MachineLP的Github（欢迎follow）：https://github.com/MachineLP本小节使用torch搭建CNN模型，训练和测试：（1）定义模型超参数：rnn的输入，rnn隐含单元，rnn层数，迭代次数、批量大小、学习率。（2）定义训练数据，加餐部分是使用自己的数据集：（可参考：https://blog.csdn.net/u014365862/article/detai...
循环神经网络RNN实现手写数字识别
01-20
import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data mnist=input_data.read_data_sets('mnist_data/',one_hot=True) #注意这里用了one_hot表示，标签的形状是(batch_size,num_batches)，类型是float，如果不用one_hot，那么标签的形状是(batch_size,)，类型是int num_classes=10 batch_size=64 hidden_dim1=32 hidden_dim2=64
深度学习练习-使用RNN实现MNIST手写数字识别（仅作自学记录使用）
ONGSEONGWU的博客
03-30 1824
python-通过使用RNN实现MNIST手写数字识别（仅作自学记录使用）
RNN的手写数字识别
qq_22613769的博客
06-23 1232
RNN和LSTM的原理可以看这篇文章 以下是RNN在手写数字识别上的简单应用 import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data from tensorflow.contrib import rnn #重置graph，不然会出错 tf.reset_default_graph() #...
TensorFlow1 ：RNN实现mnist手写体数字识别
pengchengIT的博客
01-30 878
RNN过程
RNN应用手写数字识别
wangxf666的博客
07-03 342
import numpy as np from keras.datasets import mnist from keras.utils import np_utils from keras.models import Sequential from keras.layers import Dense from keras.optimizers import Adam # SimpleRNN是最简单的，还有 LSTM, GRU from keras.layers.recurrent import Simpl
【PyTorch 深度学习实战】基于RNN实现 MNIST手写数字识别 (附源代码 详解)
05-02
主题是基于RNN循环神经网络实现MNIST手写数字识别，所用的框架为目前的主流框架PyTorch，所用编程语言为Python。这个项目我已经在博客中详细记录，包含每一步的结果和通俗的解释等，建议结合专栏【Python从入门到...
人工智能&深度学习必练案例-PyTorch基于RNN和LSTM进行MNIST手写数字识别（完整代码，含完整注释 + 数据集
05-02
这是一个完整的深度学习案例，适合正在学习深度学习和人工智能的朋友练手使用，该案例所用框架为PyTorch，所用编程语言为Python，所使用的模型，最后各自运用两种模型（一个是RNN，一个是LSTM）完成了该项目，已经在...
pytorch-基于RNN的MNIST手写数据集识别
04-23
代码是利用pytorch框架实现的，识别过程是利用循环神经网络RNN进行训练。
【AI实战】训练第一个AI模型：MNIST手写数字识别模型
雪饼的博客
05-18 2872
在上篇文章中，我们已经把AI的基础环境搭建好了（见文章：Ubuntu + conda + tensorflow + GPU + pycharm搭建AI基础环境），接下来将基于tensorflow训练第一个AI模型：MNIST手写数字识别模型。 MNIST是一个经典的手写数字数据集，来自美国国家标准与技术研究所，由不同人手写的0至9的数字构成，由60000个训练样本集和10000个测试样本集构成...
深度学习之Pytorch------RNN实现MNIST手写数字识别
qq_51938362的博客
07-06 1552
使用Pytorch实现RNN，完成对mnist数据集识别功能
RNN实现MNIST手写数据识别
weixin_42318554的博客
01-15 914
文章目录RNN实现MNIST手写数据识别一、代码二、实现效果 RNN实现MNIST手写数据识别 一、代码 import torch import torchvision.datasets from torch import nn import torch.utils.data as Data EPOCH=1 #训练多少次 BATCH_SIZE =64 #批训练数量 TIME_STEP=28 #nn时间步数/图片高度 INPUT_SIZE=28 #nn每步输入值/图片每行像素 LR=0.01 #学习率 D
RNN实现手写数字实识别
王尚权 qq:2515162716
12-04 918
import tensorflow as tf #加载数据集 from tensorflow.examples.tutorials.mnist import input_data tf.reset_default_graph() mnist=input_data.read_data_sets("./temp/data",one_hot=True) trainings,trainlabels,t...
基于RNN循环神经网络的手写体数字识别
WGS.
08-28 1556
import tensorflow as tf from tensorflow.contrib.layers import fully_connected from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets(r"G:\A_深度学习1\tensorflow\rnn\MNIST_data") # 参数 batch_size = 100 # mini-batch批大小 n_s
rnn-手写数字识别-网络结构-shape
weixin_30306905的博客
03-14 556
手写数字识别经典案例，目标是： 1. 掌握tf编写RNN的方法 2.剖析RNN网络结构 tensorflow编程 #coding:utf-8 import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data ### 注意 # init_state = ...
RNN原理及其解决MNIST手写数字识别
phthon1997的博客
01-17 1761
前面学习到了全连接神经网络和卷积神经网络，以及它们的训练和使用。他们都只能单独的取处理一个个的输入，前一个输入和后一个输入是完全没有关系的。但是，某些任务需要能够更好的处理序列的信息，即前面的输入和后面的输入是有关系的。比如，当我们在理解一句话意思时，孤立的理解这句话的每个词是不够的，我们需要处理这些词连接起来的整个序列；当我们处理视频的时候，我们也不能只单独的去分析每一帧，而要分析这些帧连接起来...
RNN 进行mnist手写数字识别
weixin_41521681的博客
02-26 354
#!/usr/bin/env python # coding: utf-8 # In[2]: import tensorflow as tf import input_data import numpy as np import matplotlib.pyplot as plt print ("Packages imported") mnist = input_data.read_dat...
人工智能手写数字识别的设计与实现
最新发布
05-26
人工智能手写数字识别是一种常见的机器学习问题，可以通过构建一个深度学习模型来实现。下面是一个基本的设计和实现步骤： 1. 数据集准备：收集大量手写数字图像作为训练数据集，同时准备一些用于测试和验证的数据集。可以使用公共数据集，如MNIST，也可以创建自己的数据集。 2. 数据预处理：对图像进行预处理，包括调整图像大小、归一化像素值、增强图像对比度等操作。 3. 模型设计：选择适当的深度学习模型来训练手写数字识别任务。常用的模型包括卷积神经网络（CNN）和循环神经网络（RNN）等。 4. 模型训练：使用训练数据集对模型进行训练。在训练过程中，需要定义损失函数（如交叉熵损失），并使用优化算法（如随机梯度下降）来最小化损失函数。 5. 模型评估：使用测试数据集对模型进行评估。评估指标包括准确率、精度、召回率等。 6. 模型部署：将训练好的模型部署到生产环境中，可以使用API接口或者SDK供其他应用程序调用。 总的来说，人工智能手写数字识别是一个较为基础的机器学习问题，但是在实际应用中却有着广泛的应用场景。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值