用pytorch对mnist手写数字进行分类

最新推荐文章于 2024-05-28 19:59:57 发布
最新推荐文章于 2024-05-28 19:59:57 发布
阅读量1.3k 收藏 19
点赞数 3
分类专栏： python 深度学习成长日志 文章标签： pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43163694/article/details/106193375
版权

最近在学习pytorch框架，所以按照莫烦python的代码跑了一遍
github代码

整理手写数字数据

# Mnist 手写数字
train_data = torchvision.datasets.MNIST(
    root='./mnist/',    # 保存或者提取位置
    train=True,  # this is training data
    transform=torchvision.transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
                                                    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
    download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
)

test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)

# 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# 为了节约时间, 我们测试时只测试前2000个
test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000]/255.   # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_data.test_labels[:2000]

数据是pytorch的对象数据
<torch.utils.data.dataloader.DataLoader object at 0x000002292CF4C160>
数据分为训练数据、测试数据、测试矩阵和测试标签

构建cnn网络

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(  # input shape (1, 28, 28)
            nn.Conv2d(
                in_channels=1,      # input height
                out_channels=16,    # n_filters
                kernel_size=5,      # filter size
                stride=1,           # filter movement/step
                padding=2,      # 如果想要 con2d 出来的图片长宽没有变化, padding=(kernel_size-1)/2 当 stride=1
            ),      # output shape (16, 28, 28)
            nn.ReLU(),    # activation
            nn.MaxPool2d(kernel_size=2),    # 在 2x2 空间里向下采样, output shape (16, 14, 14)
        )
        self.conv2 = nn.Sequential(  # input shape (16, 14, 14)
            nn.Conv2d(16, 32, 5, 1, 2),  # output shape (32, 14, 14)
            nn.ReLU(),  # activation
            nn.MaxPool2d(2),  # output shape (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   # fully connected layer, output 10 classes

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)   # 展平多维的卷积图成 (batch_size, 32 * 7 * 7)
        output = self.out(x)
        return output
"""
CNN (
  (conv1): Sequential (
    (0): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU ()
    (2): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
  )
  (conv2): Sequential (
    (0): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU ()
    (2): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
  )
  (out): Linear (1568 -> 10)
)
"""

可以看到这个cnn网络这样构建的
在这里插入图片描述
由这个图可以看到28*28通道为1经过卷积核卷积得28*28\通道为16，再经过ReLu激活函数进行激活和MaxPool进行数据压缩，得出14*14通道为16
在这里插入图片描述
由这个图可以看到14*14通道为16经过卷积核卷积得14*14\通道为32，再经过ReLu激活函数进行激活和MaxPool进行数据压缩，得出7*7通道为32
在这里插入图片描述
最后展开一个32*7*7的向量，设置10个分类的向量

训练

optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.CrossEntropyLoss()   # the target label is not one-hotted

# training and testing
for epoch in range(EPOCH):
    for step, (b_x, b_y) in enumerate(train_loader):   # 分配 batch data, normalize x when iterate train_loader
        output = cnn(b_x)               # cnn output
        loss = loss_func(output, b_y)   # cross entropy loss
        optimizer.zero_grad()           # clear gradients for this training step
        loss.backward()                 # backpropagation, compute gradients
        optimizer.step()                # apply gradients

每次正向传播一次，要反向更新参数loss.backward()
loss_func 是计算损失的一个方式

测试

test_output = cnn(test_x[:10])
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')

输出结果：

[7 2 1 0 4 1 4 9 5 9] prediction number
[7 2 1 0 4 1 4 9 5 9] real number

保存模型

torch.save(cnn.state_dict(), 'net_params.pkl')

这个是将模型训练的参数保存，而不是这个网络

提取模型

cnn.load_state_dict(torch.load('net_params.pkl'))

这个这是提取网络参数，所以用之前先构建网络

完整代码

保存模型

import torch
import torch.nn as nn
import torch.utils.data as Data
import torchvision      # 数据库模块
import matplotlib.pyplot as plt

torch.manual_seed(1)    # reproducible

# Hyper Parameters
EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
BATCH_SIZE = 50
LR = 0.001          # 学习率
DOWNLOAD_MNIST = False  # 如果你已经下载好了mnist数据就写上 False


# Mnist 手写数字
train_data = torchvision.datasets.MNIST(
    root='./mnist/',    # 保存或者提取位置
    train=True,  # this is training data
    transform=torchvision.transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
                                                    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
    download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
)

test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)

# 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# 为了节约时间, 我们测试时只测试前2000个
test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000]/255.   # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_data.test_labels[:2000]

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(  # input shape (1, 28, 28)
            nn.Conv2d(
                in_channels=1,      # input height
                out_channels=16,    # n_filters
                kernel_size=5,      # filter size
                stride=1,           # filter movement/step
                padding=2,      # 如果想要 con2d 出来的图片长宽没有变化, padding=(kernel_size-1)/2 当 stride=1
            ),      # output shape (16, 28, 28)
            nn.ReLU(),    # activation
            nn.MaxPool2d(kernel_size=2),    # 在 2x2 空间里向下采样, output shape (16, 14, 14)
        )
        self.conv2 = nn.Sequential(  # input shape (16, 14, 14)
            nn.Conv2d(16, 32, 5, 1, 2),  # output shape (32, 14, 14)
            nn.ReLU(),  # activation
            nn.MaxPool2d(2),  # output shape (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   # fully connected layer, output 10 classes

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)   # 展平多维的卷积图成 (batch_size, 32 * 7 * 7)
        output = self.out(x)
        return output

cnn = CNN()
print(cnn)  # net architecture
"""
CNN (
  (conv1): Sequential (
    (0): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU ()
    (2): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
  )
  (conv2): Sequential (
    (0): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU ()
    (2): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
  )
  (out): Linear (1568 -> 10)
)
"""

optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.CrossEntropyLoss()   # the target label is not one-hotted

# training and testing
for epoch in range(EPOCH):
    for step, (b_x, b_y) in enumerate(train_loader):   # 分配 batch data, normalize x when iterate train_loader
        output = cnn(b_x)               # cnn output
        loss = loss_func(output, b_y)   # cross entropy loss
        optimizer.zero_grad()           # clear gradients for this training step
        loss.backward()                 # backpropagation, compute gradients
        optimizer.step()                # apply gradients

torch.save(cnn.state_dict(), 'net_params.pkl')

test_output = cnn(test_x[:10])
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')

提取代码

import torch
import torch.nn as nn
import torch.utils.data as Data
import torchvision      # 数据库模块
import matplotlib.pyplot as plt

torch.manual_seed(1)    # reproducible

# Hyper Parameters
EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
BATCH_SIZE = 50
LR = 0.001          # 学习率
DOWNLOAD_MNIST = False  # 如果你已经下载好了mnist数据就写上 False


# Mnist 手写数字
train_data = torchvision.datasets.MNIST(
    root='./mnist/',    # 保存或者提取位置
    train=True,  # this is training data
    transform=torchvision.transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
                                                    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
    download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
)

test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)

# 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# 为了节约时间, 我们测试时只测试前2000个
test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000]/255.   # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_data.test_labels[:2000]

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(  # input shape (1, 28, 28)
            nn.Conv2d(
                in_channels=1,      # input height
                out_channels=16,    # n_filters
                kernel_size=5,      # filter size
                stride=1,           # filter movement/step
                padding=2,      # 如果想要 con2d 出来的图片长宽没有变化, padding=(kernel_size-1)/2 当 stride=1
            ),      # output shape (16, 28, 28)
            nn.ReLU(),    # activation
            nn.MaxPool2d(kernel_size=2),    # 在 2x2 空间里向下采样, output shape (16, 14, 14)
        )
        self.conv2 = nn.Sequential(  # input shape (16, 14, 14)
            nn.Conv2d(16, 32, 5, 1, 2),  # output shape (32, 14, 14)
            nn.ReLU(),  # activation
            nn.MaxPool2d(2),  # output shape (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   # fully connected layer, output 10 classes

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)   # 展平多维的卷积图成 (batch_size, 32 * 7 * 7)
        output = self.out(x)
        return output

cnn = CNN()

cnn.load_state_dict(torch.load('net_params.pkl'))
test_output = cnn(test_x[:10])
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')

总结

以上理解是个人理解，可能会有缺失或错误，请各位指教

莫烦python

咏&志
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
脱坑指南1：pycharm 实战手写数字 mnist数据集
iajin的博客
07-05 6887
本人小白实践记录心酸大作业历程： 数据集 MNIST手写数字数据集（下载地址及相关介绍：http://yann.lecun.com/exdb/mnist/） 下载下来是一串这个东西： 一脸懵，怎么读取?怎么看？ 官方example直接扔出来程序，根本不知道怎么写path，也没有专门视频讲这个。 【真相1】先得解压.gz 2、pycharm编译器设置 Permission...
1.Softmax回归模型实现MNIST手写数字分类（python代码详解）
twlve的博客
03-14 3646
Softmax回归模型实现MNIST手写数字分类（python代码详解） 关键点： Softmax回归处理多分类问题，其是Logistic回归在多分类问题上的推广 softmax回归使用交叉熵损失函数来学习最优的参数矩阵W，对样本进行分类 Softmax回归是有监督的。 STEP 1：读取数据 '''读取数据''' from tensorflow.keras.datasets import mnist from __future__ import division import tensorflow a
深度学习P1-实现mnist手写数字识别
qq_66033623的博客
07-07 245
本文为🔗中的学习记录博客我的环境：1.语言：python3.72.编译器：pycharm。
Pytorch入门实战第一周：实现mnist手写数字识别
weixin_46620278的博客
03-12 1103
🍨本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客K同学啊语言：python3、Pytorch框架编辑器：pycharm2020深度学习环境：torch1.12.1+cu113torchvision.datasets是Pytorch自带的数据库，用户可以通过代码在线下载数据，这里使用的是torchvision.datasets中的MNIST数据集参数说明：root。
深度学习入门：3.手写数字分类
最新发布
weixin_43946736的博客
05-28 882
通过对MNIST数据集的识别介绍深度学习的一个流程
三、MNIST手写数字分类任务项目实战
beyond谚语的博客
06-20 903
分类任务和回归任务本质上并没有太大的区别，只是最终得到的结果和损失函数不同而已。MNIST手写数字分类任务，最终得到的是10个值，也类似一个one-hot编码格式，表示该图片是0-9数字的概率，概率值最大的就是预测的最终结果当然标签也得是one-hot编码格式，例如标签图片是，对应网络模型：1*784，通过隐藏层转化为128个特征，再转换为10个输出结果，最后连接一个Softmax转化为每个类别的概率值分类问题一般使用交叉熵损失函数。
[PyTorch] 基于Python和PyTorch的MNIST的手写数字数据集的分类
真理无穷，进一步有进一步的欢喜
06-10 7987
好比编程入门有 Hello World，机器学习入门有 MNIST 。
使用PyTorch实现卷积神经网络（CNN），对MNIST数据集中的手写数字进行分类
qq_52110584的博客
04-02 847
这是一个使用PyTorch实现的卷积神经网络（CNN），用于对MNIST数据集中的手写数字进行分类。该网络由两个卷积层组成，其中间有ReLU激活函数和最大池化层。第一个卷积层有16个过滤器，过滤器大小为5x5，填充为2，以保持输出大小与输入相同。第二个卷积层有32个过滤器，与第一个卷积层具有相同的过滤器大小和填充。在第二个卷积层之后，输出被展平，并通过具有10个输出神经元的全连接层传递，对应于10个可能的数字。从全连接层的输出经过softmax激活函数，以获得最终分类概率。
002-基于Pytorch的手写汉字数字分类
ahhjian的专栏
03-25 357
本节将介绍一个简单而典型的基于Pytorch框架的图像分类任务，所用的数据集是手写体汉字数字，模型是LeNet-5。通过该实例的学习，可以了解基于深度网络模型的计算机视觉任务的基本流程。
用PyTorch实现MNIST手写数字识别对应源码文件
10-18
在本文中，我们将深入探讨如何使用PyTorch框架来实现MNIST手写数字识别任务。MNIST数据集是一个广泛使用的数据库，包含60,000个训练样本和10,000个测试样本，每个样本都是28x28像素的手写数字图像。这个数据集对于...
基于Pytorch实现MNIST手写数字数据集识别（源码+数据）.rar
05-06
1、资源内容：基于Pytorch实现MNIST手写数字数据集识别（源码+数据）.rar 2、适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。 3、更多仿真源码和数据集...
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手写数字识别对应源码文件
07-26
使用PyTorch实现MNIST手写数字识别对应源码文件。 参考图书《python深度学习 pytorch版》 详细代码及注释。
Pycharm+TensorFlow编写CNN实现Mnist手写数据集识别
AIGC Studio：分享AIGC前沿知识和好玩应用，公众号同名。
07-16 4854
# 导入本次需要的模块 import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data # 下载并加载数据 mnist = input_data.read_data_sets(r'F:\手写数字识别\新建文件夹\data', one_hot=True) def compute_accuracy...
【小白也可做】pytorch实现普通CNN的MNIST手写数字分类，含t-SNE聚类图、混淆矩阵图绘制，内含通用代码，可根据自己的项目需要进行修改
weixin_44829487的博客
09-02 2301
config类中定义了项目所有需要的参数，可以在里面修改训练参数。
K近邻算法（一） python实现，手写数字识别(from机器学习实战)
xie_qiuqiu的博客
02-19 1459
k近邻法（KNN）算法概述算法概述优点 精度高、对异常值不敏感、无数据输入假定。 缺点 计算复杂度高、空间复杂度高。 试用数据范围 数值型和标称型工作原理：将新数据的每个特征与样本集中数据对应特征进行比较，计算之间的距离值，选取样本数据集中前k个最相似的数据。伪代码： 1. 计算已知类别数据集中的点与当前点之间的距离 2. 按照距离递增次序排序 3. 选取与当前点距离最小的k个点
基于 PyTorch 的手写数字分类
Warmer_Sweeter
06-16 1743
引言在本文中，我们将在 PyTorch 中构建一个非常简单的神经网络来进行手写数字的分类。首先，我们将开始探索 MNIST 数据集，解释我们如何加载和格式化数据。然后，我们将跳转到激励和实...
Pytorch使用CNN实现手写数字识别
windmyself的专栏
06-30 1031
环境：python3、torch1.2.0(torch1.5.0也可以)、torchvision0.4.0 代码：（注：download=False第一次应该设为True，原因在代码注释里） # 参考链接：https://www.cnblogs.com/yangmang/p/7530748.html import torch import torch.nn as nn from torch.autograd import Variable import torch.utils.data as dat.
Pytorch 深度学习 手写数字分类（亲测）
panda HAHA的博客
03-03 362
Pytorch 深度学习 手写数字分类
基于PyTorch的MNIST手写数字分类模型原理
05-19
MNIST是一个手写数字数据集，它包含了大量的手写数字图片和对应的标签。这个数据集已经成为了机器学习中一个很重要的数据集，因为它简单易用，同时也能够展示机器学习算法的效果。 基于PyTorch的MNIST手写数字分类模型通常采用卷积神经网络（Convolutional Neural Network, CNN）来实现。卷积神经网络是一种专门用于图像识别的深度学习算法，它通过多层卷积和池化操作，提取图像中的特征，并最终将其映射到对应的分类结果上。 在PyTorch中，我们可以使用torchvision模块中的datasets和transforms来预处理MNIST数据集。我们可以通过下面的代码来创建MNIST数据集： ``` import torch import torchvision.datasets as dsets import torchvision.transforms as transforms train_dataset = dsets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True) test_dataset = dsets.MNIST(root='./data', train=False, transform=transforms.ToTensor()) ``` 接下来，我们可以通过torch.nn模块来构建卷积神经网络模型。在这个模型中，我们通常会采用多个卷积层和池化层，最终将特征映射到全连接层上，再通过softmax函数得到分类结果。 ``` import torch.nn as nn import torch.nn.functional as F class CNNModel(nn.Module): def __init__(self): super(CNNModel, self).__init__() self.conv1 = nn.Conv2d(1, 32, kernel_size=5, stride=1, padding=2) self.conv2 = nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2) self.fc1 = nn.Linear(7 * 7 * 64, 1024) self.fc2 = nn.Linear(1024, 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, 7 * 7 * 64) x = F.relu(self.fc1(x)) x = self.fc2(x) return F.log_softmax(x, dim=1) model = CNNModel() ``` 接着，我们可以使用torch.optim模块来定义优化器和损失函数，并进行模型训练和测试。 ``` import torch.optim as optim criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5) def train(epoch): model.train() for batch_idx, (data, target) in enumerate(train_loader): optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() if batch_idx % 10 == 0: print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item())) def test(): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: output = model(data) test_loss += criterion(output, target).item() pred = output.argmax(dim=1, keepdim=True) correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset))) for epoch in range(1, 10): train(epoch) test() ``` 通过以上步骤，我们就可以基于PyTorch构建并训练出一个MNIST手写数字分类模型了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值