【pytorch】手写数字识别

news2024/12/27 16:52:42

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，窗口大小为5
            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 此处自动算出的是320
        x = 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 此处自动算出的是320
        x = 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 = 0
    running_correct = 0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()   #清空梯度

        # forward + backward + update
        outputs = model(inputs)  #神经网络完成一次前馈的计算过程，得到预测输出output
        loss = 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 = 0
            running_correct = 0  # 这小批300的acc清零

测试


def test():
    correct = 0
    total = 0
    with torch.no_grad():  # 测试集不用算梯度
        for data in test_loader:
            images, labels = data
            outputs = 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 / total
    print('[%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 此处自动算出的是320
        x = 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 = 0
    running_correct = 0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()

        # forward + backward + update
        outputs = 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 = 0
            running_correct = 0  # 这小批300的acc清零

        # torch.save(model.state_dict(), './model_Mnist.pth')
        # torch.save(optimizer.state_dict(), './optimizer_Mnist.pth')


def test():
    correct = 0
    total = 0
    with torch.no_grad():  # 测试集不用算梯度
        for data in test_loader:
            images, labels = data
            outputs = 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 / total
    print('[%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.coloradmin.cn/o/1923354.html

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

相关文章

esp32 usb cdc串口读写

esp32 usb cdc串口读写

void setup() { Serial.begin(); // 在USB CDC On Boot使能（Enabled）情况下，这里是USBCDC Serial.setDebugOutput(true); } void loop() { if (Serial.available() > 0) { // 检查是否有可用的数据 String input Serial.readS…
阅读更多...
大模型应用中什么是IFT（指令微调）？

大模型应用中什么是IFT（指令微调）？

大模型应用中什么是IFT（指令微调）？ 背景 随着人工智能技术的发展，特别是自然语言处理（NLP）领域的进步，预训练语言模型（如GPT-3、BERT）已经展现出了强大的语言理解和生成…
阅读更多...
少儿编程 2024年6月电子学会图形化编程等级考试Scratch二级真题解析（判断题）

少儿编程 2024年6月电子学会图形化编程等级考试Scratch二级真题解析（判断题）

2024年6月scratch编程等级考试二级真题 判断题（共10题，每题2分，共20分） 26、下列积木的运算结果为false 答案：错 考点分析：考查逻辑运算符的使用，60>50为true，取反为false&…
阅读更多...
Java高频面试基础知识点整理3

Java高频面试基础知识点整理3

干货分享，感谢您的阅读！背景​​​​​​高频面试题基本总结回顾（含笔试高频算法整理） 最全文章见：Java高频面试基础知识点整理 （一）Java基础高频知识考点 针对人员： 1.全部人员都…
阅读更多...
笔记 3 ：linux 0.11 中的重要的全局变量 （b）

笔记 3 ：linux 0.11 中的重要的全局变量 （b）

（15） 接着介绍缓冲区初始化，首先介绍一个全局量 end ，表示 源代码编译的终点，随后就是缓冲区： 上图里也介绍了关于缓冲区的其它几个全局变量。全局数组 hash_table 的位置肯定是在 end 以前定义的。end 后为…
阅读更多...
算法学习笔记（8.4）-完全背包问题

算法学习笔记（8.4）-完全背包问题

目录 Question： 图例： 动态规划思路 2 代码实现： 3 空间优化： 代码实现： 下面是0-1背包和完全背包具体的例题： 代码实现： 图例： 空间优化代码示例 Question： 给定n个物品…
阅读更多...
Python数据分析案例51——基于K均值的客户聚类分析可视化

Python数据分析案例51——基于K均值的客户聚类分析可视化

案例背景 本次案例带来的是最经典的K均值聚类，对客户进行划分类别的分析，其特点是丰富的可视化过程。这个经典的小案例用来学习或者课程作业在合适不过了。 数据介绍 数据集如下: 客户的编码，性别，年龄，年收入&#…
阅读更多...
创建yum源、NFS共享存储

创建yum源、NFS共享存储

1. YUM源的提供方式 1.1 配置本地源仓库 cd /etc/yum.repos.d/ vim local.repo [local] // 仓库类别 namelocal // 仓库名称 baseurlfile:///mnt // 指定 URL 访问路径为光盘挂载目录 enabled1 …
阅读更多...
UML建模案例分析-类图中的关系

UML建模案例分析-类图中的关系

概要 类图之间的关系比较多，绝大多数情况下重点关注的还是关联关系、组合、聚合这三种，最终是如何对应到代码上的。 例子 以订单为例：订单和订单项之间是组合关系，这和数据库实体之间不一样。数据库实体有主外键，开…
阅读更多...
绘画平台小程序的设计

绘画平台小程序的设计

管理员账户功能包括：系统首页，个人中心，学生管理，讲师管理，课程类型管理，课程信息管理，课程购买管理，作业类型管理 开发系统：Windows 架构模式：SSM JDK版本&…
阅读更多...
24/07/08数据结构(2.1203)顺序表实现

24/07/08数据结构(2.1203)顺序表实现

size属于结构体的作用域 如果要访问一个结构体的指针用-> 如果要访问一个结构体的变量用. 点操作 #include<stdio.h> #include<stdlib.h> #include<string.h> #include"seqlist.h" //typedef struct seqList{ // SLDataType* _data; //需…
阅读更多...
SpringBoot3.3.0升级方案

SpringBoot3.3.0升级方案

本文介绍了由SpringBoot2升级到SpringBoot3.3.0升级方案&#xff0c;新版本的升级可以解决旧版本存在的部分漏洞问题。 一、jdk17下载安装 1、下载 官网下载地址 Java Archive Downloads - Java SE 17 Jdk17下载后&#xff0c;可不设置系统变量java_home&#xff0c;仅在id…
阅读更多...
Leetcode 剑指 Offer II 086.分割回文串

Leetcode 剑指 Offer II 086.分割回文串

题目难度: 中等 原题链接 今天继续更新 Leetcode 的剑指 Offer&#xff08;专项突击版&#xff09;系列, 大家在公众号 算法精选 里回复 剑指offer2 就能看到该系列当前连载的所有文章了, 记得关注哦~ 题目描述 给定一个字符串 s &#xff0c;请将 s 分割成一些子串&#xff0…
阅读更多...
YOLOv10改进 | 特殊场景检测篇 | 单阶段盲真实图像去噪网络RIDNet辅助YOLOv10图像去噪（全网独家首发）

YOLOv10改进 | 特殊场景检测篇 | 单阶段盲真实图像去噪网络RIDNet辅助YOLOv10图像去噪（全网独家首发）

一、本文介绍 本文给大家带来的改进机制是单阶段盲真实图像去噪网络RIDNet&#xff0c;RIDNet&#xff08;Real Image Denoising with Feature Attention&#xff09;是一个用于真实图像去噪的卷积神经网络&#xff08;CNN&#xff09;&#xff0c;旨在解决现有去噪方法在处理…
阅读更多...
零信任作为解决方案，Hvv还能打进去么？

零信任作为解决方案，Hvv还能打进去么？

零信任平台由“中心组件服务”三大部分构成&#xff0c;以平台形式充分融合软件定义边界&#xff08;SDP&#xff09;、身份与访问管理&#xff08;IAM&#xff09;、微隔离 &#xff08;MSG&#xff09;的技术方案优势&#xff0c;通过关键技术的创新&#xff0c;实现最佳可信…
阅读更多...
PointCloudLib LocalMaximum_DeleteMaxPoint C++版本

PointCloudLib LocalMaximum_DeleteMaxPoint C++版本

测试效果 简介 在点云库&#xff08;Point Cloud Library&#xff0c;PCL&#xff09;中&#xff0c;处理点云数据时&#xff0c;经常需要去除局部最大点&#xff08;Local Maximum&#xff09;&#xff0c;这通常用于去除噪声、提取特定形状的特征或者简化点云数据。局部最大…
阅读更多...
python制作甘特图的基本知识（附Demo）

python制作甘特图的基本知识（附Demo）

目录 前言1. matplotlib2. plotly 前言 甘特图是一种常见的项目管理工具&#xff0c;用于表示项目任务的时间进度 直观地看到项目的各个任务在时间上的分布和进度 常用的绘制甘特图的工具是 matplotlib 和 plotly 主要以Demo的形式展示 1. matplotlib 功能强大的绘图库&a…
阅读更多...
江苏职教高考 计算机 C语言 复习资料

江苏职教高考 计算机 C语言 复习资料

江苏职教高考计算机专业考试内容为 文化课专业课 其中专业课包含&#xff1a; 计算机原理45分 计算机组维45分 计算机网络60分 C语言 6080分 电子电工90分 具体资料可查看链接 链接&#xff1a;https://pan.baidu.com/s/1OXD-zK4V3NsLLDMwfXcTlA?pwd2822 提取码&…
阅读更多...
风华绝代林徽因

风华绝代林徽因

林徽因 ◉ 卡西莫多 风华绝代林家女&#xff0c;呕心依护古胜迹 短暂一生半百余&#xff0c;忆念至今两甲子 山河有恙因她彩&#xff0c;窈窕淑女众倾慕 不只因她姿颜色&#xff0c;更因巾帼硬风骨 2024年7月12日
阅读更多...
Anaconda+Pycharm 项目运行保姆级教程（附带视频）

Anaconda+Pycharm 项目运行保姆级教程（附带视频）

最近很多小白在问如何用anacondapycharm运行一个深度学习项目&#xff0c;进行代码复现呢&#xff1f;于是写下这篇文章希望能浅浅起到一个指导作用。 附视频讲解地址&#xff1a;AnacondaPycharm项目运行实例_哔哩哔哩_bilibili 一、项目运行前的准备&#xff08;软件安装&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023