深度学习01 — PyTorch实现mnist手写数字识别

最新推荐文章于 2024-07-11 09:41:13 发布
最新推荐文章于 2024-07-11 09:41:13 发布
阅读量1.1k 收藏 19
点赞数 16
文章标签： 深度学习 pytorch 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64179839/article/details/136721571
版权

>- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客**
>- **🍖 原作者：[K同学啊 | 接辅导、项目定制](https://mtyjkh.blog.csdn.net/)**

🏡我的环境：

  • 语言环境：Python3.7
  • 编译器：pycharm
  • 深度学习环境：
    • torch==1.7.1+cu110
    • torchvision==0.8.2+cu110

一、 前期准备

1. 设置GPU

如果设备上支持GPU就使用GPU,否则使用CPU

2. 导入数据

使用dataset下载MNIST数据集，并划分好训练集与测试集

使用dataloader加载数据，并设置好基本的batch_size

⭐ torchvision.datasets.MNIST详解

torchvision.datasets是Pytorch自带的一个数据库，我们可以通过代码在线下载数据，这里使用的是torchvision.datasets中的MNIST数据集。

函数原型：

torchvision.datasets.MNIST(root, train=True, transform=None, target_transform=None, download=False)

参数说明：

  • root (string) ：数据地址
  • train (string) ：True-训练集，False-测试集
  • download (bool,optional) : 如果为True，从互联网上下载数据集，并把数据集放在root目录下。

3. 数据可视化

squeeze()函数的功能是从矩阵shape中，去掉维度为1的。例如一个矩阵是的shape是（5, 1），使用过这个函数后，结果为（5, ）。

  • transform (callable, optional )：这里的参数选择一个你想要的数据转化函数，直接完成数据转化 
  • target_transform (callable,optional) ：接受目标并对其进行转换的函数/转换。
  • torch.utils.data.DataLoader详解

  • torch.utils.data.DataLoader是Pytorch自带的一个数据加载器，结合了数据集和取样器，并且可以提供多个线程处理数据集。

    函数原型：

    torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None, generator=None, *, prefetch_factor=2, persistent_workers=False, pin_memory_device='')

    参数说明：

  • dataset (string) ：加载的数据集
  • batch_size (int,optional) ：每批加载的样本大小（默认值：1）
  • shuffle (bool,optional) : 如果为True，每个epoch重新排列数据。
  • sampler (Sampler or iterable, optional) ： 定义从数据集中抽取样本的策略。 可以是任何实现了 __len__ 的 Iterable。 如果指定，则不得指定 shuffle 。
  • batch_sampler (Sampler or iterable, optional) ： 类似于sampler，但一次返回一批索引。与 batch_size、shuffle、sampler 和 drop_last 互斥。
  • num_workers (int,optional) ： 用于数据加载的子进程数。 0 表示数据将在主进程中加载（默认值：0）。
  • pin_memory (bool,optional) : 如果为 True，数据加载器将在返回之前将张量复制到设备/CUDA 固定内存中。 如果数据元素是自定义类型，或者collate_fn返回一个自定义类型的批次。
  • drop_last (bool,optional) : 如果数据集大小不能被批次大小整除，则设置为 True 以删除最后一个不完整的批次。 如果 False 并且数据集的大小不能被批大小整除，则最后一批将保留。 （默认值：False）
  • timeout (numeric,optional) : 设置数据读取的超时时间 ， 超过这个时间还没读取到数据的话就会报错。（默认值：0）
  • worker_init_fn (callable,optional) ： 如果不是 None，这将在步长之后和数据加载之前在每个工作子进程上调用，并使用工作 id（[0，num_workers - 1] 中的一个 int）的顺序逐个导入。（默认：None）
  • train_dl 是一个 PyTorch 数据加载器（DataLoader），用于加载训练数据集。通常情况下，数据加载器会将数据集分成小批量（batches）进行处理。
  • iter(train_dl) 将数据加载器转换为一个迭代器（iterator），使得我们可以使用 Python 的 next() 函数来逐个访问数据加载器中的元素。
  • next() 函数用于获取迭代器中的下一个元素。在这里，它被用来获取 train_dl 中的下一个批量数据。
  • imgs, labels = ... 这行代码是 Python 的解构赋值语法。它将从 next() 函数返回的元素中提取出两个变量：imgs 和 labels。
  • imgs 变量将包含一个批量的图像数据，而 labels 变量将包含相应的标签数据。这些图像和标签是从训练数据集中提取的。

二、构建简单的CNN网络

对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。

  • nn.Conv2d为卷积层，用于提取图片的特征，传入参数为输入channel，输出channel，池化核大小
  • nn.MaxPool2d为池化层，进行下采样，用更高层的抽象表示图像特征，传入参数为池化核大小
  • nn.ReLU为激活函数，使模型可以拟合非线性数据
  • nn.Linear为全连接层，可以起到特征提取器的作用，最后一层的全连接层也可以认为是输出层，传入参数为输入特征数和输出特征数（输入特征数由特征提取网络计算得到，如果不会计算可以直接运行网络，报错中会提示输入特征数的大小，下方网络中第一个全连接层的输入特征数为1600）
  • nn.Sequential可以按构造顺序连接网络，在初始化阶段就设定好网络结构，不需要在前向传播中重新写一遍
  • 加载并打印模型

  • 三、训练模型

  • 1.设置超参数


  • 2. 编写训练函数

    1. optimizer.zero_grad()

    函数会遍历模型的所有参数，通过内置方法截断反向传播的梯度流，再将每个参数的梯度值设为0，即上一次的梯度记录被清空。

    2. loss.backward()

    PyTorch的反向传播(即tensor.backward())是通过autograd包来实现的，autograd包会根据tensor进行过的数学运算来自动计算其对应的梯度。

    具体来说，torch.tensor是autograd包的基础类，如果你设置tensor的requires_grads为True，就会开始跟踪这个tensor上面的所有运算，如果你做完运算后使用tensor.backward()，所有的梯度就会自动运算，tensor的梯度将会累加到它的.grad属性里面去。

    更具体地说，损失函数loss是由模型的所有权重w经过一系列运算得到的，若某个w的requires_grads为True，则w的所有上层参数（后面层的权重w）的.grad_fn属性中就保存了对应的运算，然后在使用loss.backward()后，会一层层的反向传播计算每个w的梯度值，并保存到该w的.grad属性中。

    如果没有进行tensor.backward()的话，梯度值将会是None，因此loss.backward()要写在optimizer.step()之前。

    3. optimizer.step()

    step()函数的作用是执行一次优化步骤，通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的，所以在执行optimizer.step()函数前应先执行loss.backward()函数来计算梯度。

    注意：optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是tensor.backward()方法产生的。

  • pred.argmax(1) 返回数组 pred 在第一个轴（即行）上最大值所在的索引。这通常用于多类分类问题中，其中 pred 是一个包含预测概率的二维数组，每行表示一个样本的预测概率分布。
  • (pred.argmax(1) == y)是一个布尔值，其中等号是否成立代表对应样本的预测是否正确（True 表示正确，False 表示错误）。
  • .type(torch.float)是将布尔数组的数据类型转换为浮点数类型，即将 True 转换为 1.0，将 False 转换为 0.0。
  • .sum()是对数组中的元素求和，计算出预测正确的样本数量。
  • .item()将求和结果转换为标量值，以便在 Python 中使用或打印。

  • (pred.argmax(1) == y).type(torch.float).sum().item()表示计算预测正确的样本数量，并将其作为一个标量值返回。这通常用于评估分类模型的准确率或计算分类问题的正确预测数量。

    3. 编写测试函数

    测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器

  •  
  •  
    4. 正式训练
     
     
    1. model.train()
     
    model.train()的作用是启用 Batch Normalization 和 Dropout。
     
     
    如果模型中有BN层(Batch Normalization）和Dropout，需要在训练时添加model.train()。model.train()是保证BN层能够用到每一批数据的均值和方差。对于Dropout，model.train()是随机取一部分网络连接来训练更新参数。
     
     
    2. model.eval()
     
    model.eval()的作用是不启用 Batch Normalization 和 Dropout。
     
     
    如果模型中有BN层(Batch Normalization）和Dropout，在测试时添加model.eval()。model.eval()是保证BN层能够用全部训练数据的均值和方差，即测试过程中要保证BN层的均值和方差不变。对于Dropout，model.eval()是利用到了所有网络连接，即不进行随机舍弃神经元。
     
     
    训练完train样本后，生成的模型model要用来测试样本。在model(test)之前，需要加上model.eval()，否则的话，有输入数据，即使不训练，它也会改变权值。这是model中含有BN层和Dropout所带来的的性质。
     
  •  
    
运行结果为


     
  •  
    四、 结果可视化
     
  •  
    五、总结
     
  • 学习了构建CNN网络，在运行过程中解决了很多问题，例如，将程序分成不同的python文件去运行，在每段程序的开头都要导入包，在训练模型的时候，遇到了cuda和pytorch版本不匹配问题，重新下载了匹配的torch。

                

        

        

    




    

      

        

            

              
                
                  weixin_64179839
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    16
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    19
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  2
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
深度学习第2周：用PyTorch进行Mnist手写数字识别

				
			

			

				

					BingxxXXxx的博客
				

				

					03-30
					
					400
					
				

			

		

		

			
				
定义了一个名为ConvNet的卷积神经网络模型，包含两个卷积层、一个最大池化层和一个全连接层。nn.Module 是 PyTorch 中的一个类，用于定义神经网络模型。所有的神经网络模型都应该继承自 nn.Module 类，并实现init和 forward 方法。init方法用于初始化模型的各个层，而 forward 方法定义了模型的前向传播过程。通过继承 nn.Module 类，我们可以方便地使用 PyTorch 提供的各种层和函数来构建自己的神经网络模型。

			
		

	



                

              
                



	

		

			

				
					
pytorch 实现MNIST手写数字识别

				
			

			

				

					llqzx的博客
				

				

					11-24
					
					852
					
				

			

		

		

			
				
在之前的文章中，我们使用pytorch下载并转换了MNIST的数据集，今天我们实现LeNet-5网络，使用下载的训练集对网络进行训练，然后使用测试集测试最终的效果。
MNIST数据集详解及可视化处理（pytorch）
首先，我们先看一下LeNet-5，LeNet-5是由“深度学习三巨头”之一、图灵奖得主Yann LeCun在一篇名为"Gradient-Based Learning Applied to Document Recognition"的paper（paper下载地址：https://www.res

			
		

	



                


  
              

                


	

		

			

				
					
学习pytorch（三）简单卷积神经网络训练MNIST（利用GPU计算）

				
			

			

				

					ld_long的博客
				

				

					02-08
					
					983
					
				

			

		

		

			
				
简单卷积神经网络训练MNIST（利用GPU计算）
本篇不分享神经网络的知识，只分享pytorch下如何构建简单的卷积神经网络模型并让模型学习MNIST手写数字识别。学习和预测过程利用GPU计算减轻cpu的负担。在pytorch中，把计算工作交给GPU的操作很简单，操作都用python ‘’’ ‘’’ 注释标出
import torch
from torchvision import datasets #这个包包含了多个数据集，这些数据集都是torch.nn.datasets类的子类。可以供DataLoade

			
		

	





	

		

			

				
					
基于Python实现的手写数字识别系统源码+使用教程（毕业设计）.zip

				
			

			

				

					11-17
				

			

		

		

			
				
基于Python实现的手写数字识别系统源码+使用教程（毕业设计）.zip文件夹结构功能
1.文件夹
data：mnist手写数字数据集，包含训练、测试数据
parameters：神经网络训练结果保存路径
figure：该文档中的图片
2.文件
activate.py：激活函数层，包含Sigmoid，SoftMax
bp.py：BP神经网络层，全连接层
BPmain.py：BP神经网络测试文件
CNNmain.py：卷积神经网络测试文件
conv.py：卷积层
load_mnist.py：mnist数据加载
module.py：网络层、结构接口定义
pool.py：池化层
saveandread.py：神经网络参数保存加载
项目运行
1.BP神经网络测试
1.1测试目标
使用BP神经网络对数据进行分类
1.2测试方式
运行BPmain.py文件
1.3测试结果
1.训练完成后输出如下
开始训练: 2023-02-18 20:16:09.905283
训练已完成练100%
结束训练: 2023-02-18 20:16:56.179266
2.测试结果如下图所示，可以看到，神经网络可以将

			
		

	



		

			
		



	

		

			

				
					
【深度学习入门篇 ④ 】Pytorch实现手写数字识别

					
最新发布

				
			

			

				

					小森的博客
				

				

					07-11
					
					1293
					
				

			

		

		

			
				
通过前面的学习，我们已经掌握了PyTorch API的基本使用，今天我们使用PyTorch实现手写数字识别案例！通过前面的内容可知，调用MNIST返回的结果中图形数据是一个Image对象,需要对其进行处理，为了进行数据的处理，接下来学习的方法~是PyTorch中用于图像预处理和增强的一个重要模块，它提供了多种对的方法，如裁剪、旋转、缩放、归一化等。这些方法可以单独使用，也可以通过类组合起来，形成复杂的预处理流程。

			
		

	





	

		

			

				
					
Python 手写数字识别的实现(pytorch框架) 超详细版本-jupyter notebook

					
热门推荐

				
			

			

				

					weixin_43718786的博客
				

				

					03-28
					
					2万+
					
				

			

		

		

			
				
本文详细介绍了如何构建LeNet-5神经网络用于手写数字识别。
文中大量的代码解释包含在代码行后的注释中，请注意查看。


下面的代码在谷歌云盘的colab上运行，也可以在jupyter notebook上运行

			
		

	





	

		

			

				
					
Python人工智能--实现手写数字识别

				
			

			

				

					我是一只程序⚪的技术交流平台
				

				

					03-23
					
					2万+
					
				

			

		

		

			
				
在做此项目之前，首先要明白何为KNN算法。
一 、 K-近邻算法（KNN）概述
最简单最初级的分类器是将全部的训练数据所对应的类别都记录下来，当测试对象的属性和某个训练对象的属性完全匹配时，便可以对其进行分类。但是怎么可能所有测试对象都会找到与之完全匹配的训练对象呢，其次就是存在一个测试对象同时与多个训练对象匹配，导致一个训练对象被分到了多个类的问题，基于这些问题呢，就产生了KNN。
 KNN是通...

			
		

	





	

		

			

				
					
Python实现手写数字的识别

				
			

			

				

					janestan的博客
				

				

					09-29
					
					9511
					
				

			

		

		

			
				
输入层(input layer)是由训练集的实例特征向量传入，经过连接结点的权重(weight)传入下一层，一层的输出是下一层的输入，隐藏层的个数可以是任意的，输入层有一层，输出层有一层，每个单元(unit)也可以被称作神经结点,根据生物学来源定义，一层中加权的求和，然后根据非线性方程转化输出。多层向前神经网络由以下部分组成：输入层(input layer),隐藏层(hidden layers),输入层(output layers)，每层由单元(units)组成。（1）通过迭代性的来处理训练集中的实例。

			
		

	





	

		

			

				
					
NLP笔记（5）——Pytorch实现手写数字识别

				
			

			

				

					小嘤熊的博客
				

				

					07-14
					
					2205
					
				

			

		

		

			
				
文末附完整代码！！！

			
		

	





	

		

			

				
					
PyTorch实现MNIST手写数字识别完整源代码

				
			

			

				

					06-06
				

			

		

		

			
				
 def __init__(self): ... self.conv1 = nn.Conv2d(1, 10, kernel_size=5)  self.conv2 = nn.Conv2d(10, 20, kernel_size=5)  self.conv2_drop = nn.Dropout2d()  self.fc1 = nn.Linear(320, 50)  self.fc2 = nn.Linear...

			
		

	





	

		

			

				
					
用PyTorch实现MNIST手写数字识别对应源码文件

				
			

			

				

					06-17
				

			

		

		

			
				
标题"用PyTorch实现MNIST手写数字识别对应源码文件"表明这是一个关于使用PyTorch深度学习框架进行手写数字识别的项目。MNIST（Modified National Institute of Standards and Technology）是计算机视觉领域的一个...

			
		

	





	

		

			

				
					
基于python+MNIST数据集的手写数字识别源码+全部数据.zip

				
			

			

				

					11-26
				

			

		

		

			
				
基于python+MNIST数据集的手写数字识别源码+全部数据.zip 主要针对计算机相关专业的正在做课程设计和期末大作业的学生和需要项目实战练习的学习者。包含全部项目源码、该项目可以直接使用、项目都经过严格调试，下载即用确保可以运行！

基于python+MNIST数据集的手写数字识别源码+全部数据.zip 主要针对计算机相关专业的正在做课程设计和期末大作业的学生和需要项目实战练习的学习者。包含全部项目源码、该项目可以直接使用、项目都经过严格调试，下载即用确保可以运行！基于python+MNIST数据集的手写数字识别源码+全部数据.zip 主要针对计算机相关专业的正在做课程设计和期末大作业的学生和需要项目实战练习的学习者。包含全部项目源码、该项目可以直接使用、项目都经过严格调试，下载即用确保可以运行！基于python+MNIST数据集的手写数字识别源码+全部数据.zip 主要针对计算机相关专业的正在做课程设计和期末大作业的学生和需要项目实战练习的学习者。包含全部项目源码、该项目可以直接使用、项目都经过严格调试，下载即用确保可以运行！基于python+MNIST数据集的手写数字识别源码

			
		

	





	

		

			

				
					
使用PyTorch实现MNIST手写数字识别对应源码文件

				
			

			

				

					07-26
				

			

		

		

			
				
使用PyTorch实现MNIST手写数字识别对应源码文件。 参考图书《python深度学习 pytorch版》 详细代码及注释。

			
		

	





	

		

			

				
					
pytorch实现MNIST手写体识别

				
			

			

				

					09-17
				

			

		

		

			
				
在本教程中，我们将探讨如何使用PyTorch框架实现MNIST手写体识别。MNIST是一个广泛用于机器学习和深度学习研究的基准数据集，它包含60,000个训练样本和10,000个测试样本，每个样本都是28x28像素的手写数字图像。我们...

			
		

	





	

		

			

				
					
基于深度学习的手写数字识别算法Python实现

				
			

			

				

					
				

				

					01-16
					
					1万+
					
				

			

		

		

			
				
基于深度学习的手写数字识别算法Python实现

			
		

	





	

		

			

				
					
python手写汉字识别_用python实现手写数字识别

				
			

			

				

					weixin_39592137的博客
				

				

					11-20
					
					1402
					
				

			

		

		

			
				
前言在之前的学习中，已经对神经网络的算法具体进行了学习和了解。现在，我们可以用python通过两种方法来实现手写数字的识别。这两种方法分别是多元逻辑回归和神经网络方法。用多元逻辑回归手写数字识别训练样本简介首先，可以用逻辑回归实现手写数字识别的多元分类，在ex3data.mat文件中保存着一个包含5000个培训考试训练数据集的手写数字，.mat格式表示这些训练数据集以矩阵格式保存，而不是文本格式。...

			
		

	





	

		

			

				
					
Pytorch实现手写数字识别【基于全连接神经网络】

				
			

			

				

					Consult_
				

				

					07-18
					
					9690
					
				

			

		

		

			
				
构建全连接神经网络模型，使用pytroch实现手写数字识别

			
		

	





	

		

			

				
					
【python】机器学习算法(KNN)入门——手写数字识别

				
			

			

				

					python56123的博客
				

				

					11-07
					
					3798
					
				

			

		

		

			
				
嗨喽~大家好呀，这里是魔王呐!最近邻 (k Nearest Neighbors, KNN)算法是一种分类算法1968年由Cover和Hart提出，应用场景有宁符识别、文本分类、 图像识别等领域。手写数字识别是一个经典的机器学习问题，通过识别手写体图片来判断数字因为数字类别是0——9，所以是十分类问题那今天博主就来教大家探索手写数字的识别。

			
		

	





	

		

			

				
					
pytorch（一）：实现mnist手写数字识别

				
			

			

				

					ali1174的专栏
				

				

					04-21
					
					5832
					
				

			

		

		

			
				
Pytorch的入门训练--CNN手写mnist识别

			
		

	





	

		

			

				
					
pytorch实现mnist手写数字识别

				
			

			

				

					06-28
				

			

		

		

			
				
### 回答1：
PyTorch是一种深度学习框架，可以用来实现MNIST手写数字识别。MNIST是一个常用的数据集，包含了大量手写数字的图像和对应的标签。我们可以使用PyTorch来构建一个卷积神经网络模型，对这些图像进行分类，从而实现手写数字识别的功能。具体实现过程可以参考PyTorch官方文档或相关教程。   

### 回答2：
MNIST是一个经典的手写数字识别问题，其数据集包括60,000个训练样本和10,000个测试样本。PyTorch作为深度学习领域的热门工具，也可以用来实现MNIST手写数字识别。

第一步是加载MNIST数据集，可以使用PyTorch的torchvision.datasets模块实现。需要注意的是，MNIST数据集是灰度图像，需要将其转换为标准的三通道RGB图像。

```python
import torch
import torchvision
import torchvision.transforms as transforms

# 加载数据集
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, 
                                transform=transforms.Compose([transforms.ToTensor(), 
                                transforms.Normalize((0.1307,), (0.3081,))]), download=True)

test_dataset = torchvision.datasets.MNIST(root='./data', train=False, 
                                transform=transforms.Compose([transforms.ToTensor(), 
                                transforms.Normalize((0.1307,), (0.3081,))]), download=True)

train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
```

第二步是构建模型。在MNIST手写数字识别问题中，可以选择使用卷积神经网络（CNN），其可以捕获图像中的局部特征，这对于手写数字识别非常有用。

```python
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
        self.dropout1 = nn.Dropout2d(0.25)
        self.dropout2 = nn.Dropout2d(0.5)
        self.fc1 = nn.Linear(64*12*12, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x, kernel_size=2)
        x = self.dropout1(x)
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.dropout2(x)
        x = self.fc2(x)
        output = F.log_softmax(x, dim=1)
        return output

model = Net()
```

第三步是定义优化器和损失函数，并进行训练和测试。在PyTorch中，可以选择使用交叉熵损失函数和随机梯度下降（SGD）优化器进行训练。

```python
import torch.optim as optim

# 定义优化器和损失函数
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

# 训练模型
for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 100 == 99:    
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

# 测试模型
correct = 0
total = 0
with torch.no_grad():
    for data in test_loader:
        images, labels = data
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))
```

最后，可以输出测试集上的准确率。对于这个模型，可以得到大约98%的准确率，具有很好的性能。   

### 回答3：
PyTorch是一个常用的深度学习框架，通过PyTorch可以方便地实现mnist手写数字识别。mnist手写数字数据集是机器学习领域的一个经典数据集，用于训练和测试数字识别算法模型。以下是PyTorch实现mnist手写数字识别的步骤：

1. 获取mnist数据集：可以通过PyTorch提供的工具包torchvision来获取mnist数据集。

2. 数据预处理：将数据集中的手写数字图片转换为张量，然后进行标准化处理，使得每个像素值都在0到1之间。

3. 构建模型：可以使用PyTorch提供的nn模块构建模型，常用的模型包括卷积神经网络(CNN)和全连接神经网络(FNN)。例如，可以使用nn.Sequential()函数将多个层逐一堆叠起来，形成一个模型。

4. 训练模型：通过定义损失函数和优化器，使用训练数据集对模型进行训练。常用的损失函数包括交叉熵损失函数和均方误差损失函数，常用的优化器包括随机梯度下降(SGD)和Adam。

5. 测试模型：通过测试数据集对模型进行测试，可以用测试准确率来评估模型的性能。

以下是一个简单的PyTorch实现mnist手写数字识别的代码：

``` python
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms

# 获取数据集
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transforms.ToTensor())

# 数据加载器
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=100, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=100, shuffle=False)

# 构建模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=5)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=5)
        self.fc1 = nn.Linear(1024, 256)
        self.fc2 = nn.Linear(256, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2)
        x = x.view(-1, 1024)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)

model = Net()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        # 转换为模型所需格式
        images = images.float()
        labels = labels.long()
        # 前向传播和计算损失
        outputs = model(images)
        loss = criterion(outputs, labels)
        # 反向传播和更新参数
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 每100个批次输出一次日志
        if (i+1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, i+1, len(train_dataset)//100, loss.item()))

# 测试模型
correct = 0
total = 0
with torch.no_grad(): # 不需要计算梯度
    for images, labels in test_loader:
        # 转换为模型所需格式
        images = images.float()
        labels = labels.long()
        # 前向传播
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        # 统计预测正确数和总数
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Test Accuracy: {:.2f}%'.format(100 * correct / total))
```

以上就是一个基于PyTorch的mnist手写数字识别的简单实现方法。需要注意的是，模型的设计和训练过程可能会受到多种因素的影响，例如网络结构、参数初始化、优化器等，需要根据实际情况进行调整和优化，才能达到更好的性能。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 2

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值