基于Pytorch深度学习神经网络MNIST手写数字识别系统源码（带界面和手写画板）

于 2024-05-15 21:55:39 发布
阅读量367 收藏 2
点赞数 4
分类专栏： 手写识别 文章标签： 深度学习 pytorch 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59023219/article/details/138924426
版权

 第一步：准备数据

mnist开源数据集

第二步：搭建模型

我们这里搭建了一个LeNet5网络

参考代码如下：

import torch
from torch import nn


class Reshape(nn.Module):
    def forward(self, x):
        return x.view(-1, 1, 28, 28)


class LeNet5(nn.Module):
    def __init__(self):
        super(LeNet5, self).__init__()
        self.net = nn.Sequential(
            Reshape(),

            # CONV1, ReLU1, POOL1
            nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2),
            # nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),

            # CONV2, ReLU2, POOL2
            nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Flatten(),

            # FC1
            nn.Linear(in_features=16 * 5 * 5, out_features=120),
            nn.ReLU(),

            # FC2
            nn.Linear(in_features=120, out_features=84),
            nn.ReLU(),

            # FC3
            nn.Linear(in_features=84, out_features=10)
        )
        # 添加softmax层
        self.softmax = nn.Softmax()

    def forward(self, x):
        logits = self.net(x)
        # 将logits转为概率
        prob = self.softmax(logits)
        return prob


if __name__ == '__main__':
	model = LeNet5()
	X = torch.rand(size=(256, 1, 28, 28), dtype=torch.float32)
	for layer in model.net:
	    X = layer(X)
	    print(layer.__class__.__name__, '\toutput shape: \t', X.shape)
	X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32)
	print(model(X))

第三步：训练代码

import torch
from torch import nn
from torchvision import datasets
from torchvision.transforms import ToTensor
from torch.utils.data import DataLoader

from model import LeNet5


# DATASET
train_data = datasets.MNIST(
	root='./data',
	train=False,
	download=True,
	transform=ToTensor()
)

test_data = datasets.MNIST(
	root='./data',
	train=False,
	download=True,
	transform=ToTensor()
)


# PREPROCESS
batch_size = 256
train_dataloader = DataLoader(dataset=train_data, batch_size=batch_size)
test_dataloader = DataLoader(dataset=test_data, batch_size=batch_size)
for X, y in train_dataloader:
	print(X.shape)		# torch.Size([256, 1, 28, 28])
	print(y.shape)		# torch.Size([256])
	break


# MODEL
device = 'cuda' if torch.cuda.is_available() else 'cpu'
model = LeNet5().to(device)


# TRAIN MODEL
loss_func = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(params=model.parameters())

def train(dataloader, model, loss_func, optimizer, epoch):
	model.train()
	data_size = len(dataloader.dataset)
	for batch, (X, y) in enumerate(dataloader):
		X, y = X.to(device), y.to(device)

		y_hat = model(X)
		loss = loss_func(y_hat, y)

		optimizer.zero_grad()
		loss.backward()
		optimizer.step()

	loss, current = loss.item(), batch * len(X)
	print(f'EPOCH{epoch+1}\tloss: {loss:>7f}', end='\t')


# Test model
def test(dataloader, model, loss_fn):
	size = len(dataloader.dataset)
	num_batches = len(dataloader)
	model.eval()
	test_loss, correct = 0, 0
	with torch.no_grad():
		for X, y in dataloader:
			X, y = X.to(device), y.to(device)
			pred = model(X)
			test_loss += loss_fn(pred, y).item()
			correct += (pred.argmax(1) == y).type(torch.float).sum().item()
	test_loss /= num_batches
	correct /= size
	print(f'Test Error: Accuracy: {(100 * correct):>0.1f}%, Average loss: {test_loss:>8f}\n')


if __name__ == '__main__':
	epoches = 80
	for epoch in range(epoches):
		train(train_dataloader, model, loss_func, optimizer, epoch)
		test(test_dataloader, model, loss_func)

	# Save models
	torch.save(model.state_dict(), 'model.pth')
	print('Saved PyTorch LeNet5 State to model.pth')

第四步：统计训练过程

EPOCH1	loss: 1.908403	Test Error: Accuracy: 58.3%, Average loss: 1.943602

EPOCH2	loss: 1.776060	Test Error: Accuracy: 72.2%, Average loss: 1.750917

EPOCH3	loss: 1.717706	Test Error: Accuracy: 73.6%, Average loss: 1.730332

EPOCH4	loss: 1.719344	Test Error: Accuracy: 76.0%, Average loss: 1.703456

EPOCH5	loss: 1.659312	Test Error: Accuracy: 76.6%, Average loss: 1.694500

EPOCH6	loss: 1.647946	Test Error: Accuracy: 76.9%, Average loss: 1.691286

EPOCH7	loss: 1.653712	Test Error: Accuracy: 77.0%, Average loss: 1.690819

EPOCH8	loss: 1.653270	Test Error: Accuracy: 76.8%, Average loss: 1.692459

EPOCH9	loss: 1.649021	Test Error: Accuracy: 77.5%, Average loss: 1.686158

EPOCH10	loss: 1.648204	Test Error: Accuracy: 78.3%, Average loss: 1.678802

EPOCH11	loss: 1.647159	Test Error: Accuracy: 78.4%, Average loss: 1.676133

EPOCH12	loss: 1.647390	Test Error: Accuracy: 78.6%, Average loss: 1.674455

EPOCH13	loss: 1.646807	Test Error: Accuracy: 78.4%, Average loss: 1.675752

EPOCH14	loss: 1.630824	Test Error: Accuracy: 79.1%, Average loss: 1.668470

EPOCH15	loss: 1.524222	Test Error: Accuracy: 86.3%, Average loss: 1.599240

EPOCH16	loss: 1.524022	Test Error: Accuracy: 86.7%, Average loss: 1.594947

EPOCH17	loss: 1.524296	Test Error: Accuracy: 87.1%, Average loss: 1.588946

EPOCH18	loss: 1.523599	Test Error: Accuracy: 87.3%, Average loss: 1.588275

EPOCH19	loss: 1.523655	Test Error: Accuracy: 87.5%, Average loss: 1.586576

EPOCH20	loss: 1.523659	Test Error: Accuracy: 88.2%, Average loss: 1.579286

EPOCH21	loss: 1.523733	Test Error: Accuracy: 87.9%, Average loss: 1.582472

EPOCH22	loss: 1.523748	Test Error: Accuracy: 88.2%, Average loss: 1.578699

EPOCH23	loss: 1.523788	Test Error: Accuracy: 88.0%, Average loss: 1.579700

EPOCH24	loss: 1.523708	Test Error: Accuracy: 88.1%, Average loss: 1.579758

EPOCH25	loss: 1.523683	Test Error: Accuracy: 88.4%, Average loss: 1.575913

EPOCH26	loss: 1.523646	Test Error: Accuracy: 88.7%, Average loss: 1.572831

EPOCH27	loss: 1.523654	Test Error: Accuracy: 88.9%, Average loss: 1.570528

EPOCH28	loss: 1.523642	Test Error: Accuracy: 89.0%, Average loss: 1.570223

EPOCH29	loss: 1.523663	Test Error: Accuracy: 89.0%, Average loss: 1.570385

EPOCH30	loss: 1.523658	Test Error: Accuracy: 88.9%, Average loss: 1.571195

EPOCH31	loss: 1.523653	Test Error: Accuracy: 88.4%, Average loss: 1.575981

EPOCH32	loss: 1.523653	Test Error: Accuracy: 89.0%, Average loss: 1.570087

EPOCH33	loss: 1.523642	Test Error: Accuracy: 88.9%, Average loss: 1.571018

EPOCH34	loss: 1.523649	Test Error: Accuracy: 89.0%, Average loss: 1.570439

EPOCH35	loss: 1.523629	Test Error: Accuracy: 90.4%, Average loss: 1.555473

EPOCH36	loss: 1.461187	Test Error: Accuracy: 97.1%, Average loss: 1.491042

EPOCH37	loss: 1.461230	Test Error: Accuracy: 97.7%, Average loss: 1.485049

EPOCH38	loss: 1.461184	Test Error: Accuracy: 97.7%, Average loss: 1.485653

EPOCH39	loss: 1.461156	Test Error: Accuracy: 98.2%, Average loss: 1.479966

EPOCH40	loss: 1.461335	Test Error: Accuracy: 98.2%, Average loss: 1.479197

EPOCH41	loss: 1.461152	Test Error: Accuracy: 98.7%, Average loss: 1.475477

EPOCH42	loss: 1.461153	Test Error: Accuracy: 98.7%, Average loss: 1.475124

EPOCH43	loss: 1.461153	Test Error: Accuracy: 98.9%, Average loss: 1.472885

EPOCH44	loss: 1.461151	Test Error: Accuracy: 99.1%, Average loss: 1.470957

EPOCH45	loss: 1.461156	Test Error: Accuracy: 99.1%, Average loss: 1.471141

EPOCH46	loss: 1.461152	Test Error: Accuracy: 99.1%, Average loss: 1.470793

EPOCH47	loss: 1.461151	Test Error: Accuracy: 98.8%, Average loss: 1.474548

EPOCH48	loss: 1.461151	Test Error: Accuracy: 99.1%, Average loss: 1.470666

EPOCH49	loss: 1.461151	Test Error: Accuracy: 99.1%, Average loss: 1.471546

EPOCH50	loss: 1.461151	Test Error: Accuracy: 99.0%, Average loss: 1.471407

EPOCH51	loss: 1.461151	Test Error: Accuracy: 98.8%, Average loss: 1.473795

EPOCH52	loss: 1.461164	Test Error: Accuracy: 98.2%, Average loss: 1.480009

EPOCH53	loss: 1.461151	Test Error: Accuracy: 99.2%, Average loss: 1.469931

EPOCH54	loss: 1.461152	Test Error: Accuracy: 99.2%, Average loss: 1.469916

EPOCH55	loss: 1.461151	Test Error: Accuracy: 98.9%, Average loss: 1.472574

EPOCH56	loss: 1.461151	Test Error: Accuracy: 98.6%, Average loss: 1.476035

EPOCH57	loss: 1.461151	Test Error: Accuracy: 98.2%, Average loss: 1.478933

EPOCH58	loss: 1.461150	Test Error: Accuracy: 99.4%, Average loss: 1.468186

EPOCH59	loss: 1.461151	Test Error: Accuracy: 99.4%, Average loss: 1.467602

EPOCH60	loss: 1.461151	Test Error: Accuracy: 99.1%, Average loss: 1.471206

EPOCH61	loss: 1.461151	Test Error: Accuracy: 98.8%, Average loss: 1.473356

EPOCH62	loss: 1.461151	Test Error: Accuracy: 99.2%, Average loss: 1.470242

EPOCH63	loss: 1.461150	Test Error: Accuracy: 99.1%, Average loss: 1.470826

EPOCH64	loss: 1.461151	Test Error: Accuracy: 98.7%, Average loss: 1.474476

EPOCH65	loss: 1.461150	Test Error: Accuracy: 99.3%, Average loss: 1.469116

EPOCH66	loss: 1.461150	Test Error: Accuracy: 99.4%, Average loss: 1.467823

EPOCH67	loss: 1.461150	Test Error: Accuracy: 99.5%, Average loss: 1.466486

EPOCH68	loss: 1.461152	Test Error: Accuracy: 99.3%, Average loss: 1.468688

EPOCH69	loss: 1.461150	Test Error: Accuracy: 99.5%, Average loss: 1.466256

EPOCH70	loss: 1.461150	Test Error: Accuracy: 99.5%, Average loss: 1.466588

EPOCH71	loss: 1.461150	Test Error: Accuracy: 99.6%, Average loss: 1.465280

EPOCH72	loss: 1.461150	Test Error: Accuracy: 99.4%, Average loss: 1.467110

EPOCH73	loss: 1.461151	Test Error: Accuracy: 99.6%, Average loss: 1.465245

EPOCH74	loss: 1.461150	Test Error: Accuracy: 99.5%, Average loss: 1.466551

EPOCH75	loss: 1.461150	Test Error: Accuracy: 99.5%, Average loss: 1.466001

EPOCH76	loss: 1.461150	Test Error: Accuracy: 99.3%, Average loss: 1.468074

EPOCH77	loss: 1.461151	Test Error: Accuracy: 99.6%, Average loss: 1.465709

EPOCH78	loss: 1.461150	Test Error: Accuracy: 99.5%, Average loss: 1.466567

EPOCH79	loss: 1.461150	Test Error: Accuracy: 99.6%, Average loss: 1.464922

EPOCH80	loss: 1.461150	Test Error: Accuracy: 99.6%, Average loss: 1.465109

第五步：搭建GUI界面

第六步：整个工程的内容

有训练代码和训练好的模型以及训练过程，提供数据，提供GUI界面代码，主要使用方法可以参考里面的“文档说明_必看.docx”

 代码的下载路径（新窗口打开链接）：基于Pytorch深度学习神经网络MNIST手写数字识别系统源码（带界面和手写画板）

​

有问题可以私信或者留言，有问必答

AI街潜水的八角
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CNN网络识别Mnist的源码，有详细注释，非常适合新手入门
03-27
该代码是在学习深度学习的过程中，自行编写的代码，利用cnn网络来对mnist手写字符进行高精度的识别，并加入了详细的注释，非常适合作为初次接触深度学习的新手入门。欢迎下载。
MNIST手写数字识别——详解（附源码）
weixin_49999303的博客
07-30 410
BATCH_SIZE = 512 #大概需要2G的显存 每批处理的数据 EPOCHS = 20 # 总共训练轮次，即把一个数据集训练几轮 DEVICE = torch . device("cuda" if torch . cuda . is_available() else "cpu") # 让torch判断使用GPU还是CPU#定义优化器 model = ConvNet() . to(DEVICE) optimizer = optim . Adam(model . parameters())
[Tensorflow] MNIST源码分析
YasinQiu的博客
03-08 2397
源代码地址: https://github.com/tensorflow/tensorflow/tree/master/tensorflow/examples/tutorials/mnist mnist.py 主要功能: 构建一个完全连接(fully connected)的MINST模型 推理 interface() def inference(images, hidden...
基于深度学习的MNIST手写数字数据集识别（准确率99%，附代码）
热门推荐
Ps_hello的博客
11-01 1万+
Mnist数据集可以算是学习深度学习最常用到的了。这个数据集包含70000张手写数字图片，分别是60000张训练图片和10000张测试图片，训练集由来自250个不同人手写的数字构成，一般来自高中生，一半来自工作人员，测试集（test set）也是同样比例的手写数字数据，并且保证了测试集和训练集的作者不同。每个图片都是2828个像素点,数据集会把一张图片的数据转成一个2828=784的一维向量存储起来。
mnist代码解读
Dorothy_Xue
12-12 957
源码地址：https://github.com/tensorflow/tensorflow/tree/master/tensorflow/examples/tutorials/mnist 1. mnist.py 构建一个完全连接的mnist模型 导包： from __future__ import absolute_import from __future__ import divisio...
运用pytorch实现MNIST分类（含完整代码）
weixin_63964879的博客
07-06 415
运行结果准确率在96%左右。
基于Pytorch的卷积神经网络MNIST手写数字识别系统源码（95分以上大作业项目）.zip
06-10
基于Pytorch的卷积神经网络MNIST手写数字识别系统源码（95分以上大作业项目）.zip 高分设计项目，代码完整下载可用，纯手打高分设计，可以作为期末大作业和课程设计，小白也可实战。 基于Pytorch的卷积神经网络...
基于Pytorch实现的卷积神经网络MNIST手写数字识别python源码+文档说明+数据集.zip
06-01
基于Pytorch实现的卷积神经网络MNIST手写数字识别python源码+文档说明+数据集.zip基于Pytorch实现的卷积神经网络MNIST手写数字识别python源码+文档说明+数据集.zip基于Pytorch实现的卷积神经网络MNIST手写数字识别...
基于Pytorch实现的卷积神经网络MNIST手写数字识别python源码+文档说明+数据集（高分项目）
06-01
基于Pytorch实现的卷积神经网络MNIST手写数字识别python源码+文档说明+数据集（高分项目）本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的...
基于Pytorch的卷积神经网络MNIST手写数字识别源码+部署教程文档+全部数据+训练好的模型（高分项目）.zip
04-22
基于Pytorch的卷积神经网络MNIST手写数字识别源码+部署教程文档+全部数据+训练好的模型（高分项目）.zip基于Pytorch的卷积神经网络MNIST手写数字识别源码+部署教程文档+全部数据+训练好的模型（高分项目）.zip基于...
基于Pytorch框架搭建LeNet5网络实现MNIST手写数字识别python源码.zip
最新发布
07-01
基于Pytorch框架搭建LeNet5网络实现MNIST手写数字识别python源码.zip基于Pytorch框架搭建LeNet5网络实现MNIST手写数字识别python源码.zip基于Pytorch框架搭建LeNet5网络实现MNIST手写数字识别python源码.zip 基于...
Pytorch的mnist源代码理解分析
weixin_44070509的博客
07-13 642
源代码链接来自官方示例：https://github.com/pytorch/examples/blob/master/mnist/main.py，本文主要依据个人理解对该代码进行注释分析。
基于深度学习神经网络MNIST手写数字识别系统源码（带界面和手写画板，不调深度学习框架包）
修行之路
01-22 563
基于深度学习神经网络MNIST手写数字识别系统源码（带界面，不调深度学习框架包）
tensorflow源代码分析（3）-mnist cnn卷积神经网络模型源代码
hobertony_7的专栏
12-05 262
# coding=utf-8 from __future__ import absolute_import from __future__ import division from __future__ import print_function import argparse import sys import tempfile from tensorflow.examples.tutor...
利用 LeNet-5 实现 MNIST 手写数字识别(Pytorch)
yyyyypppppzzzzz的博客
12-10 4728
西电-计算机视觉-实验三 一、实验要求 二、实验分析 三、代码实现 #!/usr/bin/env python # @Date: 2021/12/10 # @Desc: 手写字体识别 import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torch.utils.data import DataLoader from torchvision import dat
PyTorch之实现LeNet-5卷积神经网络对mnist手写数字图片进行分类
qq_34600424的博客
01-17 1456
论文：Gradient-based learning applied to document recognition 简单介绍 意义：对手写数据集进行识别，对后续卷积网络的发展起到了奠基作用 特点： 1）局部感受野(local receptive fields): 基于图像局部相关的原理，保留了图像局部结构，同时减少了网络的权值。 2）权值共享(shared weights): 也是基于图像局部相关的原理，同时减少网络的权值参数。 3）下采样(sub-sampling)：对平移和形变更加鲁棒，实现特征的
Pytorch深度学习案例1：mnist手写数字识别
2301_76606951的博客
05-14 826
的 Iterable。输入层为(1,28,28)，经过第一个卷积层（卷积核为3，stride为1，padding为0）变为（32，26，26），经过第一个池化层（池化核为2）变为（32，13，13），经过第二个卷积层（卷积核为3，stride为1，padding为0）变为（64，11，11），经过第二个池化层（池化核为2）变为（64，5，5）(pred.argmax(1) == y).type(torch.float).sum().item()表示计算预测正确的样本数量，并将其作为一个标量值返回。
pytorch（一）：实现mnist手写数字识别
ali1174的专栏
04-21 5694
Pytorch的入门训练--CNN手写mnist识别
pytorch基于卷积神经网络的手写数字识别GUI界面搭建
06-03
好的，这是一个很有趣的问题，我来给您解答。 首先，我们需要训练一个卷积神经网络模型来实现手写数字识别。您可以使用PyTorch深度学习框架来实现这个模型。您可以使用MNIST数据集进行训练。在训练完成后，您需要将模型保存下来以备后续使用。 接下来，我们需要搭建一个GUI界面。您可以使用Python的Tkinter库来实现一个基本的GUI界面。在界面中，您可以添加一个画布，让用户在上面手写数字。然后，您需要使用Python的Pillow库将画布中的图像转换成28x28的灰度图像，并将其传递给卷积神经网络模型进行预测。最后，您可以将预测结果显示在GUI界面上。 下面是一个示例代码，供您参考： ```python import tkinter as tk from PIL import Image, ImageDraw import torch from torchvision import transforms # 加载训练好的模型 model = torch.load('model.pth') # 定义图像转换 transform = transforms.Compose([ transforms.Grayscale(), transforms.Resize((28, 28)), transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # 定义GUI界面 class App: def __init__(self, master): self.master = master self.canvas = tk.Canvas(master, width=200, height=200, bg='white') self.canvas.pack() self.canvas.bind('<B1-Motion>', self.draw) self.button = tk.Button(master, text='识别', command=self.predict) self.button.pack() self.label = tk.Label(master, text='') self.label.pack() # 在画布上绘制 def draw(self, event): x, y = event.x, event.y r = 8 self.canvas.create_oval(x-r, y-r, x+r, y+r, fill='black') # 图像预处理和预测 def predict(self): # 获取画布图像 x0 = self.master.winfo_rootx() + self.canvas.winfo_x() y0 = self.master.winfo_rooty() + self.canvas.winfo_y() x1 = x0 + self.canvas.winfo_width() y1 = y0 + self.canvas.winfo_height() image = ImageGrab.grab((x0, y0, x1, y1)) # 图像预处理 image = transform(image) # 图像预测 with torch.no_grad(): output = model(image.unsqueeze(0)) pred = output.argmax(dim=1, keepdim=True) # 显示预测结果 self.label.config(text='预测结果: {}'.format(pred.item())) # 运行GUI界面 root = tk.Tk() app = App(root) root.mainloop() ``` 请注意，这只是一个基本的示例代码，您可以根据自己的需求进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值