2_3-numpy-cnn-mnist手写数字识别

最新推荐文章于 2024-04-22 22:00:32 发布
最新推荐文章于 2024-04-22 22:00:32 发布
阅读量4.3k 收藏 27
点赞数 7
分类专栏： numpy构建神经网络 文章标签： numpy cnn 神经网络 mnist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csuyzt/article/details/82669885
版权

numpy实现神经网络系列

工程地址：https://github.com/yizt/numpy_neuron_network

基础知识

0_1-全连接层、损失函数的反向传播

0_2_1-卷积层的反向传播-单通道、无padding、步长1

0_2_2-卷积层的反向传播-多通道、无padding、步长1

0_2_3-卷积层的反向传播-多通道、无padding、步长不为1

0_2_4-卷积层的反向传播-多通道、有padding、步长不为1

0_2_5-池化层的反向传播-MaxPooling、AveragePooling、GlobalAveragePooling、GlobalMaxPooling

0_3-激活函数的反向传播-ReLU、LeakyReLU、PReLU、ELU、SELU

0_4-优化方法-SGD、AdaGrad、RMSProp、Adadelta、Adam

DNN练习

1_1_1-全连接神经网络做线性回归

1_1_2-全连接神经网络做mnist手写数字识别

CNN练习

2_1-numpy卷积层实现

2_2-numpy池化层实现

2_3-numpy-cnn-mnist手写数字识别

本文目录

一、定义前向、后向传播过程

本文将用numpy实现cnn, 并测试mnist手写数字识别

如果对神经网络的反向传播过程还有不清楚的，可以参考 全连接层、损失函数的反向传播、卷积层的反向传播、池化层的反向传播

网络结构如下,包括1个卷积层,1个最大池化层，1个打平层2个全连接层：

input(1,28*28)=> conv(1,3,3) => relu => max pooling => flatten => fc(64) => relu => fc(10)

这里定义卷积层只有一个输出通道,全连接层的神经元也只有64个神经元;主要是由于纯numpy的神经网络比较慢，本文主要目的理解神经网络的反向传播过程，以及如何用numpy实现神经网络，因此不追求设计最合适的网络结构;numpy实现的实现的神经网络无法应用到实际的项目中，请使用深度学习框架(如：Tensorflow、Keras、Caffe等)

# 定义权重、神经元、梯度
import numpy as np
weights = {}
weights_scale = 1e-2
filters = 1
fc_units=64
weights["K1"] = weights_scale * np.random.randn(1, filters, 3, 3).astype(np.float64)
weights["b1"] = np.zeros(filters).astype(np.float64)
weights["W2"] = weights_scale * np.random.randn(filters * 13 * 13, fc_units).astype(np.float64)
weights["b2"] = np.zeros(fc_units).astype(np.float64)
weights["W3"] = weights_scale * np.random.randn(fc_units, 10).astype(np.float64)
weights["b3"] = np.zeros(10).astype(np.float64)

# 初始化神经元和梯度
nuerons={}
gradients={}
# 定义前向传播和反向传播
from nn.layers import conv_backward,fc_forward,fc_backward
from nn.layers import flatten_forward,flatten_backward
from nn.activations import relu_forward,relu_backward
from nn.losses import cross_entropy_loss

import pyximport
pyximport.install()
from nn.clayers import conv_forward,max_pooling_forward,max_pooling_backward



# 定义前向传播
def forward(X):
    nuerons["conv1"]=conv_forward(X.astype(np.float64),weights["K1"],weights["b1"])
    nuerons["conv1_relu"]=relu_forward(nuerons["conv1"])
    nuerons["maxp1"]=max_pooling_forward(nuerons["conv1_relu"].astype(np.float64),pooling=(2,2))

    nuerons["flatten"]=flatten_forward(nuerons["maxp1"])

    nuerons["fc2"]=fc_forward(nuerons["flatten"],weights["W2"],weights["b2"])
    nuerons["fc2_relu"]=relu_forward(nuerons["fc2"])

    nuerons["y"]=fc_forward(nuerons["fc2_relu"],weights["W3"],weights["b3"])

    return nuerons["y"]

# 定义反向传播
def backward(X,y_true):
    loss,dy=cross_entropy_loss(nuerons["y"],y_true)
    gradients["W3"],gradients["b3"],gradients["fc2_relu"]=fc_backward(dy,weights["W3"],nuerons["fc2_relu"])
    gradients["fc2"]=relu_backward(gradients["fc2_relu"],nuerons["fc2"])

    gradients["W2"],gradients["b2"],gradients["flatten"]=fc_backward(gradients["fc2"],weights["W2"],nuerons["flatten"])

    gradients["maxp1"]=flatten_backward(gradients["flatten"],nuerons["maxp1"])

    gradients["conv1_relu"]=max_pooling_backward(gradients["maxp1"].astype(np.float64),nuerons["conv1_relu"].astype(np.float64),pooling=(2,2))
    gradients["conv1"]=relu_backward(gradients["conv1_relu"],nuerons["conv1"])
    gradients["K1"],gradients["b1"],_=conv_backward(gradients["conv1"],weights["K1"],X)
    return loss
# 获取精度
def get_accuracy(X,y_true):
    y_predict=forward(X)
    return np.mean(np.equal(np.argmax(y_predict,axis=-1),
                            np.argmax(y_true,axis=-1)))

二、加载数据

mnist.pkl.gz数据源： http://deeplearning.net/data/mnist/mnist.pkl.gz 

from nn.load_mnist import load_mnist_datasets
from nn.utils import to_categorical
train_set, val_set, test_set = load_mnist_datasets('mnist.pkl.gz')
train_x,val_x,test_x=np.reshape(train_set[0],(-1,1,28,28)),np.reshape(val_set[0],(-1,1,28,28)),np.reshape(test_set[0],(-1,1,28,28))
train_y,val_y,test_y=to_categorical(train_set[1]),to_categorical(val_set[1]),to_categorical(test_set[1])
# 随机选择训练样本
train_num = train_x.shape[0]
def next_batch(batch_size):
    idx=np.random.choice(train_num,batch_size)
    return train_x[idx],train_y[idx]

x,y= next_batch(16)
print("x.shape:{},y.shape:{}".format(x.shape,y.shape))
x.shape:(16, 1, 28, 28),y.shape:(16, 10)

三、训练网络

由于numpy卷积层层前向、后向过程较慢,这里只迭代2000步,mini-batch设置为2;实际只训练了4000个样本(也有不错的精度,增加迭代次数精度会继续提升;增加卷积层输出通道数，精度上限也会提升);总样本有5w个。


from nn.optimizers import SGD
# 初始化变量
batch_size=2
steps = 2000

# 更新梯度
sgd=SGD(weights,lr=0.01,decay=1e-6)

for s in range(steps):
    X,y=next_batch(batch_size)

    # 前向过程
    forward(X)
    # 反向过程
    loss=backward(X,y)


    sgd.iterate(weights,gradients)

    if s % 100 ==0:
        print("\n step:{} ; loss:{}".format(s,loss))
        idx=np.random.choice(len(val_x),200)
        print(" train_acc:{};  val_acc:{}".format(get_accuracy(X,y),get_accuracy(val_x[idx],val_y[idx])))

print("\n final result test_acc:{};  val_acc:{}".
      format(get_accuracy(test_x,test_y),get_accuracy(val_x,val_y)))
 step:0 ; loss:2.3025710785961633
 train_acc:0.5;  val_acc:0.105

 step:100 ; loss:2.322658576777174
 train_acc:0.0;  val_acc:0.135

 step:200 ; loss:2.2560641373902453
 train_acc:0.0;  val_acc:0.15

 step:300 ; loss:2.1825470524006914
 train_acc:1.0;  val_acc:0.105

 step:400 ; loss:2.208445091755495
 train_acc:0.0;  val_acc:0.12

 step:500 ; loss:1.413758817626698
 train_acc:0.5;  val_acc:0.475

 step:600 ; loss:0.8138671602711395
 train_acc:1.0;  val_acc:0.605

 step:700 ; loss:0.040969240382020794
 train_acc:1.0;  val_acc:0.695

 step:800 ; loss:0.2943919590130214
 train_acc:1.0;  val_acc:0.8

 step:900 ; loss:0.7937038773889639
 train_acc:0.5;  val_acc:0.775

 step:1000 ; loss:0.20416262923266468
 train_acc:1.0;  val_acc:0.82

 step:1100 ; loss:3.492562642433139
 train_acc:0.5;  val_acc:0.755

 step:1200 ; loss:0.44327566847604044
 train_acc:1.0;  val_acc:0.81

 step:1300 ; loss:0.381620659555296
 train_acc:1.0;  val_acc:0.78

 step:1400 ; loss:0.1379428630137357
 train_acc:1.0;  val_acc:0.715

 step:1500 ; loss:0.0048211652445979145
 train_acc:1.0;  val_acc:0.78

 step:1600 ; loss:0.6156347089073209
 train_acc:1.0;  val_acc:0.78

 step:1700 ; loss:2.9270997739154003
 train_acc:0.5;  val_acc:0.84

 step:1800 ; loss:0.7148056981166203
 train_acc:1.0;  val_acc:0.845

 step:1900 ; loss:3.3810034206400825
 train_acc:0.5;  val_acc:0.745

 final result test_acc:0.8279;  val_acc:0.839

# 随机查看预测结果
import matplotlib.pyplot as plt

idx=np.random.choice(test_x.shape[0],3)
x,y=test_x[idx],test_y[idx]
y_predict = forward(x)
for i in range(3):
    plt.figure(figsize=(3,3))
    plt.imshow(np.reshape(x[i],(28,28)))
    plt.show()
    print("y_true:{},y_predict:{}".format(np.argmax(y[i]),np.argmax(y_predict[i])))

这里写图片描述

y_true:0,y_predict:0

这里写图片描述

y_true:4,y_predict:4

这里写图片描述

y_true:8,y_predict:8
yizt
关注
  • 7
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
手搓卷积神经网络(CNN)进行手写数字识别(python)
Yurakucho的博客
04-12 3600
只用了numpy等基础库手搓了一个识别MNIST数字的CNN。 600张图单次训练的准确率70-80%。
用CNN进行MNIST手写字符识别_CNN_MNIST_CNN手写数字识别_
09-29
本项目主要介绍了如何在TensorFlow框架下利用CNN对MNIST数据集进行手写数字识别，这是一项经典的计算机视觉任务，对于理解和实践深度学习具有重要意义。 MNIST数据集是一个广泛使用的手写数字数据库，包含60,000个...
纯NumPy实现CNN网络，MNIST精确度99.3%
EthanLifeGreat的博客
05-28 1153
用NumPy仿照PyTorch写了一个深度学习模块包，实现了CNN，在MNIST上有99.33%的测试精度。 完整代码地址：EthanLifeGreat/NumPy_CNN: This project implemented some Convolutional Neural Network modules using pure NumPy. And a network built by these modules achieved over 99% test accuracy on MNIST d.
机器学习算法学习01：利用Numpy编写KNN算法解决手写体数字识别问题
theworld666的博客
09-15 2302
机器学习算法学习01：利用Numpy编写KNN算法解决手写体数字识别问题 前言 在深度学习未彻底被大众接受前，人们对人工智能的研究是企图研究出一系列巧妙的算法解决相关计算机视觉问题，这里面涌现了无数令人叹为观止的算法（随机森林，遗传算法，SVM，马尔科夫链，KNN等）即使在深度学习逐渐占据解决计算机视觉人工智能问题的算法的今天，不可否认，依旧有许多深度学习算法吸收了这些传统算法的思想，从而来进行改进，所以学习这些传统算法也是非常有必要的????????????。本次我们介绍的是如何利用numpy库来构造KN
【深度学习-第5篇】使用Python快速实现CNN分类（模式识别）任务，含一维、二维、三维数据演示案例（使用pytorch框架）
fengzhuqiaoqiu的博客
04-22 2221
​CNN也可以扩展到非图像领域使用，比如对一组一维数据，也是同样可以实现分类的。本篇文章是之前CNN分类的MATLAB实现那篇文章的姊妹篇，通过这篇文章，大家将会快速掌握使用pytorch框架进行CNN分类的编程方法，另外对于主体代码流程，我也做了傻瓜化使用的封装，方便大家使用。 ​
基于numpy的CNN实现，进行MNIST手写数字识别
肥仔的博客
05-31 1773
主要框架来自于这篇文章：https://blog.csdn.net/qq_36393962/article/details/99354969，下面会以原文来代称这篇文章 本文在原文的基础上增加了交叉熵以及mnist数据集的处理，并对卷积层反向传播更新权重的代码进行了一些相应的改动。建议先按原文脉络学习一下相关理论知识（原文讲的非常完整详细，但是个人感觉卷积层反向传播更新参数那部分有问题，卷积层更新参数的原理可参考刘建平前辈的文章），再参考下述实现代码。 文章目录零、MNIST数据集读取+layer模板代码一
Numpy + CNN实现手写数字识别
shenhao-stu的博客
04-24 612
Assignment 6：CNN实现手写数字识别 文章目录Assignment 6：CNN实现手写数字识别PackageLoad MNIST DatasetPlot One SampleAuxiliary FunctionLoss FunctionConvolutional LayerPooling LayerFC LayerRelu LayerSoftMax Layer推导Compute CostA Simple CNNTrainingPredict Package import math import
CNN学习MNIST实现手写数字识别
fakerth的博客
11-05 1481
CNN学习MNIST实现手写数字识别
使用numpy搭建神经网络，进行手写数字识别-2019
yyy的技术日常
06-27 1万+
使用numpy搭建神经网络，进行手写数字识别 1 实验目的与要求 实验要求使用神经网络来完成基于MNIST的手写数字的分类。其中MNIST数据库是由Yann提供的手写数字数据库文件。这个数据库主要包含了60000张的训练图像和10000张的测试图像，囊括了各种手写数字图片。数据样本如下图所示。 实验要求使用手动搭建神经网络，实现前后向，参数更新。神经网络结构不限,建议使用CNN，并利用训练好的神经网络对于测试集进行分类，依据初步的分类结果，对所设计的网络结构进行分析与改进，最后对于结果进行分析，并与前两次
使用numpy库从零开始实现卷积网络，完成mnist手写体数据集的识别
weixin_43872532的博客
01-24 693
参考教材：《深度学习入门，基于python的理论与实现》——斋藤康毅 卷积神经网络CNN卷积神经网络的基本概念卷积层和池化层的实现4维数组基于im2col的展开卷积层和池化层的实现CNN的实现基于mnist数据集的训练附录主要代码：simple_convnet.pytrain_convnet.py其余依赖项 卷积神经网络的基本概念 卷积网络的概念就不详细说明了，具体可参考这篇博客：卷积神经网络超详细介绍，而我想从实现的角度来完成这篇博客。 当然，本文实现的卷积网络并不复杂，先贴上一张思维导图，具体概念可.
MNIST手写数字识别
最新发布
06-12
MNIST手写数字识别是一个经典的机器学习和深度学习任务，主要目标是训练模型来自动识别手写数字。这个任务在计算机视觉领域具有重要的地位，因为它为初学者提供了很好的入门实践，同时也被用作评估新算法性能的基础...
基于TensorFlow的CNN实现Mnist手写数字识别
12-17
总结来说，这个例子展示了如何使用TensorFlow构建一个简单的CNN模型，用于解决Mnist手写数字识别问题。通过卷积层和池化层的结合，模型能有效提取图像特征，全连接层则负责将这些特征转换为分类决策。通过调整网络...
MNIST.rar_MNIST手写数字体识别_mnist 手写识别_python机器学习_tensorflow_手写识别 MNI
09-25
MNIST手写数字体识别是机器学习领域一个经典的入门级任务，主要目的是通过计算机程序来辨识手写数字。这个任务通常用来测试和演示各种机器学习算法，特别是深度学习中的卷积神经网络（CNN）。本项目是基于Python的...
tensorflow使用CNN分析mnist手写体数字数据集
12-17
本文实例为大家分享了tensorflow使用CNN分析mnist手写体数字数据集，供大家参考，具体内容如下 import tensorflow as tf import numpy as np import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' from tensorflow....
卷积神经网络实现手写数字识别（纯numpy实现）
Keras深度学习
01-19 3万+
前面讲解了使用纯numpy实现数值微分和误差反向传播法的手写数字识别，这两种网络都是使用全连接层的结构。全连接层存在什么问题呢？那就是数据的形状被“忽视”了。比如，输入数据是图像时，图像通常是高、长、通道方向上的3维形状。但是，向全连接层输入时，需要将3维数据拉平为1维数据。实际上，前面提到的使用了MNIST数据集的例子中，输入图像就是1通道、高28像素、长28像素的（1, 28, 28）形状，但却被排成1列，以784个数据的形式输入到最开始的Affine层。 图像是3维形状，这个形状中应该含有重要的空间信
用CNN实现MNIST手写数字集识别
CD_lucky的博客
04-27 306
构建了一个简单的四层神经网络，然后把数据集送入到网络进行训练，最后在测试，得到结果如下： import torch import numpy as np import matplotlib.pyplot as plt from torch import nn from torch import optim import os from torch.autograd import Variable from torch.utils.data import DataLoader from torchvision
Python代码实现简单的MNIST手写数字识别（适合初学者看）
热门推荐
zugexiaodui的博客
08-12 5万+
补充：由于很多同学找我要原数据集和代码，所以我上传到了资源里，https://download.csdn.net/download/zugexiaodui/10913834 初学机器学习，第一步是做一个简单的手写数字识别，我选用的是MNIST数据集（用其他数据集也可以，原理都差不多），算法是KNN（下载库直接调用函数，算法的具体实现没有过多关心）。在网上也看到过MNIST数据集的Python代码...
深度学习实战入门——CNN实现MNIST手写数字识别
人形自走写bug机的Blog
03-15 7180
深度学习实战入门——CNN实现MNIST手写数字识别 今天来从头自己搭一个非常简单的卷积网络，使用的数据集是MNIST. MNIST应该算是一个被用烂了的数据集了，非常非常适合初学，数据量比较小，数据处理、训练和预测的时间都比较短，可以很好地用于把控网络搭建的整个过程。 0x01 数据和自定义函数的准备 MNIST数据集的下载地址是http://yann.lecun.com/exdb/mnist/ ，可能稍微有一点点慢，有耐心即可。一共有四个文件： 文件名 说明 大小 train-image
手写汉字数字识别详细过程（构建数据集+CNN神经网络+Tensorflow）
BIGWJZ的博客
06-26 9860
手写汉字数字识别（构建数据集+CNN神经网络） 期末，P老师布置了一个大作业，自己构建数据集实现手写汉字数字的识别。太捞了，记录一下过程。大概花了一个下午加半个晚上，主要是做数据集花时间。 一、构建数据集——使用h5py 1.收集数据，这部分由我勤劳的室友们一起手写了800个汉字 一、二、三、四、五、六、七、八、九、十完成。这部分也没啥好说的，慢慢写呗。我们用了IPAD，然后截图，这样出来的图片质...
基于TensorFlow的CNN实现Mnist手写数字识别，带有可视化界面
05-14
好的，以下是基于TensorFlow的CNN实现Mnist手写数字识别的代码，带有可视化界面。 首先需要安装必要的库，包括TensorFlow、Tkinter和Pillow： ``` pip install tensorflow pip install tkinter pip install pillow ``` 然后，我们需要下载Mnist数据集。可以在TensorFlow的官方GitHub页面找到下载链接，或者使用以下代码下载： ``` from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets('MNIST_data', one_hot=True) ``` 接下来，我们可以开始构建CNN模型。下面的代码展示了一个简单的CNN模型： ``` import tensorflow as tf # Define parameters learning_rate = 0.001 training_iters = 20000 batch_size = 128 display_step = 10 # Network parameters n_input = 784 n_classes = 10 dropout = 0.75 # Create placeholders x = tf.placeholder(tf.float32, [None, n_input]) y = tf.placeholder(tf.float32, [None, n_classes]) keep_prob = tf.placeholder(tf.float32) # Create convnet def conv2d(x, W, b, strides=1): x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME') x = tf.nn.bias_add(x, b) return tf.nn.relu(x) def maxpool2d(x, k=2): return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME') def conv_net(x, weights, biases, dropout): x = tf.reshape(x, shape=[-1, 28, 28, 1]) conv1 = conv2d(x, weights['wc1'], biases['bc1']) conv1 = maxpool2d(conv1, k=2) conv2 = conv2d(conv1, weights['wc2'], biases['bc2']) conv2 = maxpool2d(conv2, k=2) fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]]) fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1']) fc1 = tf.nn.relu(fc1) fc1 = tf.nn.dropout(fc1, dropout) out = tf.add(tf.matmul(fc1, weights['out']), biases['out']) return out # Initialize weights and biases weights = { 'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])), 'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])), 'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])), 'out': tf.Variable(tf.random_normal([1024, n_classes])) } biases = { 'bc1': tf.Variable(tf.random_normal([32])), 'bc2': tf.Variable(tf.random_normal([64])), 'bd1': tf.Variable(tf.random_normal([1024])), 'out': tf.Variable(tf.random_normal([n_classes])) } # Construct model pred = conv_net(x, weights, biases, keep_prob) # Define loss and optimizer cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) # Evaluate model correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) ``` 接下来，我们可以开始训练模型，同时在训练过程中使用Tkinter创建一个可视化界面，用于展示模型的训练过程和识别结果。以下是完整的代码： ``` import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data import tkinter as tk from PIL import Image, ImageDraw # Define parameters learning_rate = 0.001 training_iters = 20000 batch_size = 128 display_step = 10 # Network parameters n_input = 784 n_classes = 10 dropout = 0.75 # Create placeholders x = tf.placeholder(tf.float32, [None, n_input]) y = tf.placeholder(tf.float32, [None, n_classes]) keep_prob = tf.placeholder(tf.float32) # Create convnet def conv2d(x, W, b, strides=1): x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME') x = tf.nn.bias_add(x, b) return tf.nn.relu(x) def maxpool2d(x, k=2): return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME') def conv_net(x, weights, biases, dropout): x = tf.reshape(x, shape=[-1, 28, 28, 1]) conv1 = conv2d(x, weights['wc1'], biases['bc1']) conv1 = maxpool2d(conv1, k=2) conv2 = conv2d(conv1, weights['wc2'], biases['bc2']) conv2 = maxpool2d(conv2, k=2) fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]]) fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1']) fc1 = tf.nn.relu(fc1) fc1 = tf.nn.dropout(fc1, dropout) out = tf.add(tf.matmul(fc1, weights['out']), biases['out']) return out # Initialize weights and biases weights = { 'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])), 'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])), 'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])), 'out': tf.Variable(tf.random_normal([1024, n_classes])) } biases = { 'bc1': tf.Variable(tf.random_normal([32])), 'bc2': tf.Variable(tf.random_normal([64])), 'bd1': tf.Variable(tf.random_normal([1024])), 'out': tf.Variable(tf.random_normal([n_classes])) } # Construct model pred = conv_net(x, weights, biases, keep_prob) # Define loss and optimizer cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) # Evaluate model correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) # Start training init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) step = 1 while step * batch_size < training_iters: batch_x, batch_y = mnist.train.next_batch(batch_size) sess.run(optimizer, feed_dict={x: batch_x, y: batch_y, keep_prob: dropout}) if step % display_step == 0: acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y, keep_prob: 1.}) print("Step " + str(step*batch_size) + ", Training Accuracy= " + "{:.5f}".format(acc)) step += 1 print("Optimization Finished!") # Create Tkinter GUI root = tk.Tk() root.title("Mnist Digit Recognition") # Create canvas for drawing canvas_width = 200 canvas_height = 200 canvas = tk.Canvas(root, width=canvas_width, height=canvas_height, bg="white") canvas.pack() # Create PIL image for drawing image = Image.new("L", (canvas_width, canvas_height), 0) draw = ImageDraw.Draw(image) # Define function for classifying drawn digit def classify_digit(): # Resize image to 28x28 digit_image = image.resize((28, 28)) # Convert image to numpy array digit_array = tf.keras.preprocessing.image.img_to_array(digit_image) digit_array = digit_array.reshape((1, 784)) digit_array = digit_array.astype('float32') digit_array /= 255 # Classify digit using trained model prediction = sess.run(tf.argmax(pred, 1), feed_dict={x: digit_array, keep_prob: 1.}) # Display prediction prediction_label.config(text="Prediction: " + str(prediction[0])) # Define function for clearing canvas def clear_canvas(): canvas.delete("all") draw.rectangle((0, 0, canvas_width, canvas_height), fill=0) # Create buttons and labels classify_button = tk.Button(root, text="Classify", command=classify_digit) classify_button.pack(side="top") clear_button = tk.Button(root, text="Clear", command=clear_canvas) clear_button.pack(side="top") prediction_label = tk.Label(root, text="") prediction_label.pack(side="bottom") # Define canvas event handlers def on_left_button_down(event): canvas.bind("<B1-Motion>", on_mouse_move) def on_left_button_up(event): canvas.unbind("<B1-Motion>") def on_mouse_move(event): x, y = event.x, event.y canvas.create_oval(x-10, y-10, x+10, y+10, fill="black") draw.ellipse((x-10, y-10, x+10, y+10), fill=255) canvas.bind("<Button-1>", on_left_button_down) canvas.bind("<ButtonRelease-1>", on_left_button_up) root.mainloop() ``` 在训练过程中，程序会打印出每个batch的训练准确率。在训练完成后，程序会创建一个Tkinter窗口，包含一个用于绘制手写数字的画布、一个用于清除画布的按钮、一个用于识别手写数字并显示结果的按钮，以及一个用于显示识别结果的标签。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值