【pytorch】手写数字识别

https://blog.csdn.net/qq_45588019/article/details/120935828 基本均参考该博客
《深度学习原理Pytorch实战》

初步处理

导包

import torch
import numpy as np
from matplotlib import pyplot as plt
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import torch.nn.functional as F

定义超参数

learning_rate = 0.01
momentum = 0.5  # 动量
EPOCH = 10   #训练总的循环周期
batch_size = 64   # 一个批次的大小，64张图片

加载MNIST数据集

#加载MNIST数据，如果没有下载过，系统就会在当前路径下新建/data子目录
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform,download=True)  # 本地没有就加上download=True
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform,download=True)  # train=True训练集，=False测试集# 训练集的加载器，自动将数据切分成批，顺序随机打乱
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

  加载器（dataloader)主要负责在程序中对数据集的使用。例如，我们在训练神经网络的过程中需要逐批加载训练数据，加载器就会自动帮我们逐批输出数据。使用加载器比直接使用张量手动加载数据更好，因为当数据集超大的时候，我们无法将所有数据全部装载到内存中，必须从硬盘上加载数据，而加载器可以让这一过程自动化。
  采样器(sampler)为加载器提供了一个每一批抽取数据集中样本的方法。我们可以按照顺序将数据集中的数据逐个抽取到加载器中，也可以完全随机地抽取，甚至可以依某种概率分布抽取。
  总之，数据集、加载器和采样器可以让数据的处理过程更加便捷和标准。

打印查看加载的数据

fig = plt.figure()
for i in range(12):plt.subplot(3, 4, i+1)plt.tight_layout()plt.imshow(train_dataset.train_data[i], cmap='gray', interpolation='none')plt.title("Labels: {}".format(train_dataset.train_labels[i]))plt.xticks([])plt.yticks([])
plt.show()

在这里插入图片描述

构建网络

构造ConvNet类，它是对nn.Module类的继承，即nn.Module是父类，ConvNet为子类。nn.Module中包含了绝大部分关于神经网络的通用计算，如初始化、前传等，用户可以重写nn.Module中的部分函数以实现定制化，如init()构造函数和forward()函数。
其次，复写init()和forward()这两个函数。init()为构造函数，每当类ConvNet被具体化一个实例的时候就会被调用。forward()函数则是在正向运行神经网络时被自动调用，它负责数据的向前传递过程，同时构造计算图。

class ConvNet(torch.nn.Module):def __init__(self):super(ConvNet, self).__init__()self.conv1 = torch.nn.Sequential(#定义一个卷积层，输入通道为1，输出通道为10，窗口大小为5torch.nn.Conv2d(1, 10, kernel_size=5),torch.nn.ReLU(),torch.nn.MaxPool2d(kernel_size=2),)self.conv2 = torch.nn.Sequential(torch.nn.Conv2d(10, 20, kernel_size=5),torch.nn.ReLU(),torch.nn.MaxPool2d(kernel_size=2),)self.fc = torch.nn.Sequential(torch.nn.Linear(320, 50),torch.nn.Linear(50, 10),)def forward(self, x):batch_size = x.size(0)x = self.conv1(x)  # 一层卷积层,一层池化层,一层激活层(图是先卷积后激活再池化，差别不大)x = self.conv2(x)  # 再来一次x = x.view(batch_size, -1)  # flatten 变成全连接网络需要的输入 (batch, 20,4,4) ==> (batch,320), -1 此处自动算出的是320x = self.fc(x)return x  # 最后输出的是维度为10的，也就是（对应数学符号的0~9）

卷积层
在这里插入图片描述

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)

in_channels：输入通道
out_channels：输出通道
kernel_size：卷积核大小
stride：步长
padding：填充

池化层
在这里插入图片描述

torch.nn.MaxPool2d(input, kernel_size, stride, padding)

激活函数

torch.nn.ReLU()

CNN模型

在这里插入图片描述
比如输入一个手写数字“5”的图像，它的维度为（batch,1,28,28）即单通道高宽分别为28像素。
1、首先通过一个卷积核为5×5的卷积层，其通道数从1变为10，高宽分别为24像素；
2、然后通过一个卷积核为2×2的最大池化层，通道数不变，高宽变为一半，即维度变成（batch,10,12,12）；
3、然后再通过一个卷积核为5×5的卷积层，其通道数从10变为20，高宽分别为8像素；
4、再通过一个卷积核为2×2的最大池化层，通道数不变，高宽变为一半，即维度变成（batch,20,4,4）；
5、之后将其view展平，使其维度变为320(2044)之后进入全连接层，用线性函数将其输出为10类，即“0-9”10个数字。

class ConvNet(torch.nn.Module):def __init__(self):super(ConvNet, self).__init__()self.conv1 = torch.nn.Sequential(torch.nn.Conv2d(1, 10, kernel_size=5),torch.nn.ReLU(),torch.nn.MaxPool2d(kernel_size=2),)self.conv2 = torch.nn.Sequential(torch.nn.Conv2d(10, 20, kernel_size=5),torch.nn.ReLU(),torch.nn.MaxPool2d(kernel_size=2),)#全连接层self.fc = torch.nn.Sequential(torch.nn.Linear(320, 50),torch.nn.Linear(50, 10),)def forward(self, x):batch_size = x.size(0)x = self.conv1(x)  # 一层卷积层,一层池化层,一层激活层(图是先卷积后激活再池化，差别不大)x = self.conv2(x)  # 再来一次x = x.view(batch_size, -1)  # flatten 变成全连接网络需要的输入 (batch, 20,4,4) ==> (batch,320), -1 此处自动算出的是320x = self.fc(x)return x  # 最后输出的是维度为10的，也就是（对应数学符号的0~9）model = ConvNet()

可以在全连接层之前加上

#以默认0.5的概率对这一层进行dropout操作，防止过拟合
x=F.dropout (x,training=self.training)

神经网络在训练中具有强大的拟合数据的能力，因此常常会出现过拟合的情形，这会使得神经网络局限在见过的样本中。dropout正是一种防止过拟合的技术。简单来说，dropout就是指在深度网络的训练过程中，根据一定的概率随机将其中的一些神经元暂时丢弃。这样在每个批的训练中，我们都是在训练不同的神经网络，最后在测试的时候再使用全部的神经元，以此增强模型的泛化能力。
在这里插入图片描述
为了防止过拟合，dropout操作可以在训练阶段将一部分神经元随机关闭，而在校验和测试的时候再打开。
可以使用net.eval()，相当于把dropout关闭

训练和测试

损失函数和优化器

criterion = torch.nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)  # lr学习率，momentum冲量

enumerate起到构造一个枚举器的作用。在对train_loader做循环迭代时,enumerate会自动输出一个数字指示循环次数，并记录在batch_idx中，它就等于0,1,2，… train_loader每迭代一次，就会输出一对数据inputs和target,分别对应一个批中的手写数字图像及对应的标签。

def train(epoch):running_loss = 0.0  # 这整个epoch的loss清零running_total = 0running_correct = 0for batch_idx, data in enumerate(train_loader, 0):inputs, target = dataoptimizer.zero_grad()   #清空梯度# forward + backward + updateoutputs = model(inputs)  #神经网络完成一次前馈的计算过程，得到预测输出outputloss = criterion(outputs, target)   #将output与标签target比较，计算误差loss.backward()  #反向传播optimizer.step()  #随机梯度下降# 把运行中的loss累加起来，为了下面300次一除running_loss += loss.item()# 把运行中的准确率acc算出来_, predicted = torch.max(outputs.data, dim=1)running_total += inputs.shape[0]running_correct += (predicted == target).sum().item()if batch_idx % 300 == 299:  # 不想要每一次都出loss，浪费时间，选择每300次出一个平均损失,和准确率print('[%d, %5d]: loss: %.3f , acc: %.2f %%'% (epoch + 1, batch_idx + 1, running_loss / 300, 100 * running_correct / running_total))running_loss = 0.0  # 这小批300的loss清零running_total = 0running_correct = 0  # 这小批300的acc清零

测试


def test():correct = 0total = 0with torch.no_grad():  # 测试集不用算梯度for data in test_loader:images, labels = dataoutputs = model(images)_, predicted = torch.max(outputs.data, dim=1)  # dim = 1 列是第0个维度，行是第1个维度，沿着行(第1个维度)去找1.最大值和2.最大值的下标total += labels.size(0)  # 张量之间的运算correct += (predicted == labels).sum().item()acc = correct / totalprint('[%d / %d]: Accuracy on test set: %.1f %% ' % (epoch+1, EPOCH, 100 * acc))  # 求测试的准确率，正确数/总数return acc

总的代码

import torch
import numpy as np
from matplotlib import pyplot as plt
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import torch.nn.functional as F"""
卷积运算 使用mnist数据集，和10-4，11类似的，只是这里：1.输出训练轮的acc 2.模型上使用torch.nn.Sequential
"""
# Super parameter ------------------------------------------------------------------------------------
batch_size = 64
learning_rate = 0.01
momentum = 0.5
EPOCH = 10# Prepare dataset ------------------------------------------------------------------------------------
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
# softmax归一化指数函数(https://blog.csdn.net/lz_peter/article/details/84574716),其中0.1307是mean均值和0.3081是std标准差train_dataset = datasets.MNIST(root='./data', train=True, transform=transform,download=True)  # 本地没有就加上download=True
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform,download=True)  # train=True训练集，=False测试集
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)fig = plt.figure()
for i in range(12):plt.subplot(3, 4, i+1)plt.tight_layout()plt.imshow(train_dataset.train_data[i], cmap='gray', interpolation='none')plt.title("Labels: {}".format(train_dataset.train_labels[i]))plt.xticks([])plt.yticks([])
plt.show()# 训练集乱序，测试集有序
# Design model using class ------------------------------------------------------------------------------
class ConvNet(torch.nn.Module):def __init__(self):super(ConvNet, self).__init__()self.conv1 = torch.nn.Sequential(torch.nn.Conv2d(1, 10, kernel_size=5),torch.nn.ReLU(),torch.nn.MaxPool2d(kernel_size=2),)self.conv2 = torch.nn.Sequential(torch.nn.Conv2d(10, 20, kernel_size=5),torch.nn.ReLU(),torch.nn.MaxPool2d(kernel_size=2),)self.fc = torch.nn.Sequential(torch.nn.Linear(320, 50),torch.nn.Linear(50, 10),)def forward(self, x):batch_size = x.size(0)x = self.conv1(x)  # 一层卷积层,一层池化层,一层激活层(图是先卷积后激活再池化，差别不大)x = self.conv2(x)  # 再来一次x = x.view(batch_size, -1)  # flatten 变成全连接网络需要的输入 (batch, 20,4,4) ==> (batch,320), -1 此处自动算出的是320x = self.fc(x)return x  # 最后输出的是维度为10的，也就是（对应数学符号的0~9）model = ConvNet()# Construct loss and optimizer ------------------------------------------------------------------------------
criterion = torch.nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)  # lr学习率，momentum冲量# Train and Test CLASS --------------------------------------------------------------------------------------
# 把单独的一轮一环封装在函数类里
def train(epoch):print("training ",epoch)running_loss = 0.0  # 这整个epoch的loss清零running_total = 0running_correct = 0for batch_idx, data in enumerate(train_loader, 0):inputs, target = dataoptimizer.zero_grad()# forward + backward + updateoutputs = model(inputs)loss = criterion(outputs, target)loss.backward()optimizer.step()# 把运行中的loss累加起来，为了下面300次一除running_loss += loss.item()# 把运行中的准确率acc算出来_, predicted = torch.max(outputs.data, dim=1)running_total += inputs.shape[0]running_correct += (predicted == target).sum().item()if batch_idx % 300 == 299:  # 不想要每一次都出loss，浪费时间，选择每300次出一个平均损失,和准确率print('[%d, %5d]: loss: %.3f , acc: %.2f %%'% (epoch + 1, batch_idx + 1, running_loss / 300, 100 * running_correct / running_total))running_loss = 0.0  # 这小批300的loss清零running_total = 0running_correct = 0  # 这小批300的acc清零# torch.save(model.state_dict(), './model_Mnist.pth')# torch.save(optimizer.state_dict(), './optimizer_Mnist.pth')def test():correct = 0total = 0with torch.no_grad():  # 测试集不用算梯度for data in test_loader:images, labels = dataoutputs = model(images)_, predicted = torch.max(outputs.data, dim=1)  # dim = 1 列是第0个维度，行是第1个维度，沿着行(第1个维度)去找1.最大值和2.最大值的下标total += labels.size(0)  # 张量之间的比较运算correct += (predicted == labels).sum().item()acc = correct / totalprint('[%d / %d]: Accuracy on test set: %.1f %% ' % (epoch+1, EPOCH, 100 * acc))  # 求测试的准确率，正确数/总数return acc# Start train and Test --------------------------------------------------------------------------------------
if __name__ == '__main__':acc_list_test = []for epoch in range(EPOCH):train(epoch)# if epoch % 10 == 9:  #每训练10轮 测试1次acc_test = test()acc_list_test.append(acc_test)plt.plot(acc_list_test)plt.xlabel('Epoch')plt.ylabel('Accuracy On TestSet')plt.show()

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/45767.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Cypress UI自动化之安装环境

Cypress UI自动化之安装环境

注：macOS系统 一、git环境 略 二、node环境 1、安装nvm 前提：有装过Homebrew，参考adb使用方法文档 1、安装nvm：首先要保证之前没有安装过node，如果之前安装过，先 brew uninstall node brew install n…
阅读更多...
计算云服务4

计算云服务4

第四章 弹性伸缩服务 什么是弹性伸缩(AS) 弹性伸缩(Auto Scaling，AS)是根据用户的业务需求，通过策略自动调整其业务资源的服务。用户可以根据业务需求自行定义伸缩配置和伸缩策略，降低人为反复调整资源以应对业务变化和高峰压力的工作量&am…
阅读更多...
C语言 | Leetcode C语言题解之第231题2的幂

C语言 | Leetcode C语言题解之第231题2的幂

题目&#xff1a; 题解&#xff1a; const int BIG 1 << 30;bool isPowerOfTwo(int n) {return n > 0 && BIG % n 0; }
阅读更多...
为什么远程办公不被公司普遍接受?

为什么远程办公不被公司普遍接受?

为什么远程办公不被公司普遍接受? 如果说传统企业不接受远程公办，那么为什么互联网企业也不接受远程办公呢？ VPN 虚拟专用网络(Virtual Private Network） VPN 是远程办公的基石，没有VPN远程办公处处受限。什么是VPN呢？ 它能实现跨地域，不受地域限制地把办公室网络和个…
阅读更多...
暑期备考美国数学竞赛AMC8和AMC10：吃透1850道真题和知识点

暑期备考美国数学竞赛AMC8和AMC10：吃透1850道真题和知识点

距离接下来的AMC8、AMC10美国数学竞赛还有几个月的时间&#xff0c;实践证明&#xff0c;做真题&#xff0c;吃透真题和背后的知识点是备考AMC8、AMC10有效的方法之一。 通过做真题&#xff0c;可以帮助孩子找到真实竞赛的感觉&#xff0c;而且更加贴近比赛的内容&#xff0c;…
阅读更多...
全面升级的对象创建——抽象工厂模式（Python实现和JAVA实现）

全面升级的对象创建——抽象工厂模式（Python实现和JAVA实现）

1. 引言 大家好&#xff01;在之前的文章中&#xff0c;我们探讨了简单工厂和工厂方法模式&#xff1a; 轻松创建对象——简单工厂模式&#xff08;Python实现&#xff09; 轻松创建对象——简单工厂模式&#xff08;Java实现&#xff09; 灵活多变的对象创建——工厂方法模式…
阅读更多...
12-《向日葵》

12-《向日葵》

向日葵 向日葵&#xff08;拉丁文&#xff1a;Helianthus annuusL.&#xff09;&#xff0c;为木兰纲、菊目、菊科、向日葵属的一年生草本植物。高1&#xff5e;3.5米。茎直立&#xff0c;圆形多棱角&#xff0c;质硬被白色粗硬毛。广卵形的叶片通常互生&#xff0c;先端锐突或…
阅读更多...
PyQt 模拟实现QSignalMapper 实现多个按钮点击监控

PyQt 模拟实现QSignalMapper 实现多个按钮点击监控

QSignalMapper 类用来接受多个信号&#xff0c;将信号汇总后再发射一个新信号。 用处主要是使多个执行类似功能的槽函数化简为一个&#xff1b; QSignalMapper 类在 PyQt 中已经被废弃&#xff0c;并且在较新版本的 PyQt 中已经不存在这个类。 在 PyQt 中&#xff0c;我们可…
阅读更多...
传输层协议之UDP

传输层协议之UDP

1、端口号 我们在应用层创建的套接字&#xff0c;是需要通过bind()接口绑定我们的IP地址与端口号的&#xff0c;这是因为数据从传输层向上交付到应用层时&#xff0c;需要用端口号来查找特定的服务进程。一般在网络通信时&#xff0c;用IP地址标识一台主机&#xff0c;用端口号…
阅读更多...
在Linux上导出NFS共享---网络文件系统

在Linux上导出NFS共享---网络文件系统

目录 一、NFS介绍 二、NFS 所需要的服务 三、搭建NFS服务器共享文件到客户端 在虚拟机129上配置&#xff1a; 在虚拟机135上配置 测试 四、autofs自动挂载 1、安装软件启动 2、编写 /etc/auto.master,在里面添加内容如下 3、编写 /etc/auto.nfs&#xff0c;其内容如下 …
阅读更多...
Cisco 命令速查表（非常详细）零基础入门到精通，收藏这一篇就够了

Cisco 命令速查表（非常详细）零基础入门到精通，收藏这一篇就够了

Cisco IOS&#xff08;Internetwork Operating System&#xff09;是 Cisco 系统公司开发的专有操作系统&#xff0c;用于其路由器和交换机。它提供了一个稳健的、可扩展的、以命令行接口&#xff08;CLI&#xff09;为基础的网络操作环境。通过掌握 Cisco IOS 命令&#xff0c…
阅读更多...
Go语言---select

Go语言---select

select的作用 Go 里面提供了一个关键字 select&#xff0c;通过 select 可以监听 channel上的数据流动。 select 的用法与switch 语言非常类似&#xff0c;由 select 开始一个新的选择块&#xff0c;每个选择条件由 case语句来描述。 与 switch 语句可以选择任何可使用相等比较…
阅读更多...
Spark底层原理：案例解析（第34天）

Spark底层原理：案例解析（第34天）

系列文章目录 一、Spark架构设计概述 二、Spark核心组件 三、Spark架构设计举例分析 四、Job调度流程详解 五、Spark交互流程详解 文章目录 系列文章目录前言一、Spark架构设计概述1. 集群资源管理器&#xff08;Cluster Manager&#xff09;2. 工作节点&#xff08;Worker No…
阅读更多...
从汇编层看64位程序运行——栈帧(Stack Frame)边界

从汇编层看64位程序运行——栈帧(Stack Frame)边界

大纲 RBP&#xff0c;RSP栈帧边界总结参考资料 在《从汇编层看64位程序运行——栈帧(Stack Frame)入门》中&#xff0c;我们简单介绍了栈帧的概念&#xff0c;以及它和函数调用之间的关系。如文中所述&#xff0c;栈帧是一种虚拟的概念&#xff0c;它表达了一个执行中的函数的栈…
阅读更多...
如何找回误删的文件？4个常用文件恢复方法！

如何找回误删的文件？4个常用文件恢复方法！

对于许多用户来说&#xff0c;误删文件是一种常见而令人懊恼的情况。恢复误删文件的重要性在于&#xff0c;它可以帮助用户找回宝贵的数据&#xff0c;避免因数据丢失带来的各种不便和损失。 如何找回不小心删除的文件&#xff1f; 误删数据不知道怎么恢复&#xff0c;会给我…
阅读更多...
美团一面，你碰到过CPU 100%的情况吗？你是怎么处理的？

美团一面，你碰到过CPU 100%的情况吗？你是怎么处理的？

本文主要分为三部分 分析一下CPU 100%的常见原因 CPU 100%如何排查 回答这个问题的一个参考答案 CPU被打满的常见原因 1. 死循环 在实际工作中&#xff0c;可能每个开发都写过死循环的代码。 死循环有两种&#xff1a; 在 while、for、forEach 循环中的死循环。 无限递…
阅读更多...
centos安装minio文件系统服务器（踩坑版）

centos安装minio文件系统服务器（踩坑版）

centos安装minio文件系统服务器&#xff08;踩坑版&#xff09; 引安装1. 下载2. 启动3. 创建access keys4. 创建buckets 坑 引 本来安装挺简单的&#xff0c;网上的教程一大堆&#xff0c;有些写的也挺详细的。不过自己还是踩到坑了&#xff0c;耽误了个把小时&#xff0c;特…
阅读更多...
【分库】分库的核心原则

【分库】分库的核心原则

目录 分库的核心原则 前言 分区透明性与一致性保证 弹性伸缩性与容错性设计 数据安全与访问控制机制 分库的核心原则 前言 在设计和实施分库策略时&#xff0c;遵循一系列核心原则是至关重要的&#xff0c;以确保系统不仅能够在当前规模下高效运行&#xff0c;还能够随着…
阅读更多...
单目测距 单目相机测距 图片像素坐标转实际坐标的一种转换方案

单目测距 单目相机测距 图片像素坐标转实际坐标的一种转换方案

需要相机位置固定 原图 红色的点是我们标注的像素点&#xff0c;这些红色的点我们知道它的像素坐标&#xff0c;以及以右下角相机位置为原点的x y 实际坐标数值 通过转换&#xff0c;可以得到整个图片内部其余像素点的实际坐标&#xff0c; 这些红色的点是通过转换关系生成的&…
阅读更多...
Python | Leetcode Python题解之第231题2的幂

Python | Leetcode Python题解之第231题2的幂

题目&#xff1a; 题解&#xff1a; class Solution:BIG 2**30def isPowerOfTwo(self, n: int) -> bool:return n > 0 and Solution.BIG % n 0
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023