精华内容
下载资源
问答
  • 本篇文章主要介绍了PyTorch CNN实战之MNIST手写数字识别示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 1、Mnist_cnn.py 该脚本文件 用TensorFlow框架 实现CNN卷积神经网络处理Mnist手写数字识别数据集,准确率达到99.21%; 2、Mnist_cnn_tensorboard.py 该脚本文件在Mnist_cnn.py的基础上实现可视化。
  • 本文实例为大家分享了基于TensorFlow的CNN实现Mnist手写数字识别的具体代码,供大家参考,具体内容如下 一、CNN模型结构 输入层:Mnist数据集(28*28) 第一层卷积:感受视野5*5,步长为1,卷积核:32个 第一层...
  • 基于CNNMNIST手写数字识别,最简单的卷积神经网络,附带源码和说明文档,代码有UI页面,可以实现对MNIST数字识别,也可以实现对手写录入数字识别
  • MNIST手写字 Matlab程序,包含BP和CNN程序。不依赖任何库,包含MNIST数据,BP网络可达到98.3%的识别率,CNN可达到99%的识别率。CNN比较耗时,关于CNN的程序介绍:...
  • 基于python3.7版本的tensorflow2.0实现mnist手写数字识别代码
  • 由于pip安装的TensorFlow缺少一部分代码,以及...因此大部分网上代码不适用(主要问题在于读取mnist数据包和一些函数形式有问题)。这个代码可以运行。内含离线mnist数据库,mnist.py,main.py等。直接运行main.py即可
  • Java实现BP神经网络,内含BP神经网络类,采用MNIST数据集,包含服务器和客户端程序,可在服务器训练后使客户端直接使用训练结果,界面有画板,可以手写数字
  • Mnist手写数字识别CNN实现

    千次阅读 2019-01-10 13:39:44
    Mnist手写数字识别CNN实现 最近有点闲,想整一下机器学习,本以为自己编程还不错,想想机器学习也不难,结果被自己啪啪啪的打脸,还疼的不行。 废话不多说,开始搞事情。 本博客的主要内容是:通过TF一步一步用...

    Mnist手写数字识别之CNN实现

    最近有点闲,想整一下机器学习,本以为自己编程还不错,想想机器学习也不难,结果被自己啪啪啪的打脸,还疼的不行。

    废话不多说,开始搞事情。

    本博客的主要内容是:通过TF一步一步用卷积神经网络(CNN)实现手写Mnist数字识别

    如果你很牛逼,就不用看我哔哔了,我菜鸟一只,本博客中涉及到多个方面的知识,有的是引用其他博客的知识,会给出相应的连接,我就做一个知识的整理者。(ps:应该没有人整理的有我这么清楚明了吧。)

    实验环境:本代码是在win10系统上运行得出的结果,python版本3.6,其他相关的依赖库和文件均为2019/1/10截止前最新版本。

    目录结构:

    • 一、TF相关函数的使用介绍;
    • 二、CNN网络模型以及相关实现;
    • 三、运行结果展示;
    • 四、Tensor图;
    • 五、代码实现。

    一、TF相关函数使用介绍:

    注:下面相关函数的解释均来自TF的官方文档,配套中文翻译带示例。

    1.tf.reshape()
    在这里插入图片描述

    在这里插入图片描述
    2. tf.layers.conv2d()
    注:此函数实际上是卷积层函数,对张量进行卷积,此函数对应的是CNN中的卷积层。具体的参数如下:
    在这里插入图片描述
    在这里插入图片描述

    3. tf.layers.max_pooling2d()
    注:此函数的输入是经过 tf.layers.conv2d() 卷积后的张量,此函数对应的是CNN中的池化层
    在这里插入图片描述

    4.tf.layers.dense()
    在这里插入图片描述
    在这里插入图片描述

    5. tf.layers.dropout()
    在这里插入图片描述

    6. tf.losses.softmax_cross_entropy()
    在这里插入图片描述

    7. tf.metrics.accuracy()
    在这里插入图片描述

    二、CNN网络模型以及相关实现

    首先在开始CNN之前,请把这张图死记硬背记住,因为所有的一切都是围绕着这张图来实现的。
    在这里插入图片描述

    接下来就是你需要自己去看着三篇博客的内容:很重要对后续的代码理解,而且图文并茂,生动形象,逼真到你不要不要的。按照这个顺序看,容易理解一些。

    1、深入学习卷积神经网络中卷积层和池化层的意义

    2、卷积神经网络(一)——卷积、边缘化与池化层

    3、卷积神经网络中卷积、反卷积、池化解析

    三、运行结果展示

    此结果是训练了5000次后的模型,准确率还是蛮高的。最后从测试数据集中选取位置在20的图像进行测试。
    在这里插入图片描述
    从上图可以看出,采用Relu这个激活函数,刚开始的时候收敛速度非常快,经过几百步的训练就可以得到相对于比较高的识别率了。

    最后的运行结果如下所示,都预测正确了,准确率达到了96%,你要是有强迫症,你可以训练20000次,估计正确率能达到98左右,但是前提是你的电脑要牛掰,不然就是漫长的等待:
    在这里插入图片描述

    四、Tensor图

    在这里插入图片描述

    五、代码实现

    下面的代码写的很详细,每一步是干啥的都写了,结合上面所说的知识,理解应该不是很难

    # -*- coding: UTF-8 -*-
    import numpy as np
    import tensorflow as tf
    
    # down load and load Mnist library(55000 * 28 * 28)
    from tensorflow.examples.tutorials.mnist import input_data
    
    mnist = input_data.read_data_sets('mnist_data', one_hot=True)
    
    # 代表训练数据, /255. 的目的是其取值范围在【0,255】
    input_x = tf.placeholder(tf.float32, [None, 28 * 28]) / 255.
    
    # 代表的是10个标签,0,1,2,3....9
    output_y = tf.placeholder(tf.int32, [None, 10])
    
    # shape 前面使用-1,能够自动的对其形状进行推导
    input_x_image = tf.reshape(input_x, [-1, 28, 28, 1])
    
    # 从测试数据集中选取3000个测试数据进行验证模型,
    # 每次都使用这一批相同的测试数据进行测试,能够保证唯一性
    test_x = mnist.test.images[:3000]  # picture
    test_y = mnist.test.labels[:3000]  # label
    
    # 创建 CNN 模型
    # 构建第一层 CNN 模型,卷积层
    cover1 = tf.layers.conv2d(
    	inputs=input_x_image,  # shape is [28, 28, 1]
    	filters=32,            # 设置卷积深度为32,意思也就是说有32个卷积核
    	kernel_size=[5, 5],    # 设置卷积核的大小
    	strides=1,             # 设置卷积的步长
    	padding="same",        # 进行卷积后,大小不变
    	activation=tf.nn.relu  # 使用 Relu 这个激活函数
    )   # [28, 28, 32]
    
    # 构建第一层池化层,作用是对第一层卷积后的结果进行降维,获得池化大小区域内的单个数据进行填充
    pool1 = tf.layers.max_pooling2d(
    	inputs=cover1,          # shape [28,28,32]
    	pool_size=[2, 2],       # 设置池化层的大小
    	strides=2               # 设置池化层的步长
    )    # shape [14, 14, 32]
    
    # 构建第二层 CNN 模型,卷积层
    cover2 = tf.layers.conv2d(
    	inputs=pool1,          # shape is [14, 14, 32]
    	filters=64,            # 采用64个卷积核
    	kernel_size=[5, 5],    # 设置卷积核的大小
    	strides=1,             # 设置卷积的步长
    	padding="same",        # 进行卷积后,大小不变
    	activation=tf.nn.relu  # 使用 Relu 这个激活函数
    )   # shape [14, 14, 64]
    
    # 构建第二层池化层,作用是对第二层卷积后的结果进行降维,获得池化大小区域内的单个数据进行填充
    pool2 = tf.layers.max_pooling2d(
    	inputs=cover2,          # shape [14,14,64]
    	pool_size=[2, 2],       # 设置池化层的大小
    	strides=2               # 设置池化层的步长
    )    # shape [7, 7, 64]
    
    # 展开第二层池化后的数据,使得其维度为一维数组
    flat = tf.reshape(pool2, [-1, 7 * 7 * 64])  # shape [7*7*64]
    
    # 设置全连接层网络,共有 1024 个神经元,并且采用Relu这个激活函数
    dense = tf.layers.dense(inputs=flat, units=1024, activation=tf.nn.relu)
    
    # 为了避免1024个全连接网络神经元出现过拟合,采用Dropout丢弃掉一半的连接,即rate = 0.5
    dropout = tf.layers.dropout(inputs=dense, rate=0.5, training=True)
    
    # 定义最后输出10个节点,因为是0-9的数字,一共10个
    logites = tf.layers.dense(inputs=dropout, units=10)  # shape [1*1*10]
    
    # 通过使用 softmax 对所有的预测结果和正确结果进行比较并计算概率,
    # 然后再使用交叉熵计算概率密度误差,也就是我们的损失函数
    loss = tf.losses.softmax_cross_entropy(onehot_labels=output_y, logits=logites)
    
    # 采用 Adam 优化器去优化误差,设置学习率为0.001,能够更好的进行优化
    train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
    
    # 计算正确率,正确率的计算步骤:
    # 1、对所有的待检测数据进行识别并与正确的结果进行判断,返回bool类型;
    # 2、将所有的bool结果进行float操作然后求均值,这个均值就是正确率;
    # tf.metrics.accuracy() will return (accuracy,update_op)
    accuracy = tf.metrics.accuracy(
    	labels=tf.argmax(output_y, axis=1),  # 正确的数字(label)
    	predictions=tf.argmax(logites, axis=1)  # 预测的数字(label)
    )[1]
    
    with tf.Session() as sess:
    	# 初始化局部和全局变量
    	init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
    	sess.run(init)
    
    	# 保存tensor图
    	tf.summary.FileWriter('./log', sess.graph)
    
    	# 定义一共训练10000次
    	for i in range(5000):
    		# 每次的数据从mnist训练数据集中选取 50 份出来训练
    		batch = mnist.train.next_batch(50)  # get 50 sample
    
    		train_loss, train_op_ = sess.run([loss, train_op], {input_x: batch[0], output_y: batch[1]})
    
    		# 每训练100次打印一次训练模型的识别率
    		if i % 100 == 0:
    			test_accuracy = sess.run(accuracy, {input_x: test_x, output_y: test_y})
    			print('Step=%d, Train loss=%.6f, [Test accuracy=%.6f]' % (i, train_loss, test_accuracy))
    	
    	# 最后一次测试:从测试数据集中选取前 20 张图片进行识别
    	# 1.利用现在的模型进行预测数字,test_output 形状是[20,10]
    	test_output = sess.run(logites, {input_x: test_x[:20]})
    	# 2.获取最大可能性的数字,一维直接返回具体值,二维以上返回下标索引
    	inferenced = np.argmax(test_output, 1)
    	# 3.打印预测的数字和实际对应的数字
    	print('inferenced number:')
    	print(inferenced)
    	print('Real number:')
    	print(np.argmax(test_y[:20], 1))
    
    

    最后你运行可能需要mnist这个数据集,你自己去百度或者官网下载下来,解压一下就可以。最后附上我的工程结构图。
    在这里插入图片描述

    展开全文
  • FCN实现手写数字数据集MNIST识别,代码为自己翻写,包含MNIST数据集,代码与大量注释,及24页原创报告
  • 用Tensorflow搭建CNN卷积神经网络,实现MNIST手写数字识别-附件资源
  • 1. 确定CUDA和Driver版本,安装相应的Tensorflow版本,避免软件冲突。 例如:Ubuntu 16.04 (CUDA 9.0 for TensorFlow < 1.13.0) 2. 为了加快安装速度,更换了国内Conda源 conda config --add channels ...conda conf
  • 本人用CNN卷积神经网络编写的手写字体识别,大家可以下载下来参考下,研究生课程的作业
  • TensorFlow框架下利用用CNN进行MNIST手写字符识别
  • 完整的MNIST CNN手写识别数据集加代码,深度学习入门好资源!
  • 本文是使用BP神经网络中的softmax回归模型实现MNIST手写数字识别,实际上能实现MNIST手写数字识别的神经网络还有CNN(卷积神经网络),下一篇可能会写。 Tensorflow是个什么东西 Tensorflow是一个采用 数据流图,...
  • TensorFlow 2.0 (五) - mnist手写数字识别(CNN卷积神经网络) 源代码/数据集已上传到Github - tensorflow-tutorial-samples 大白话讲解卷积神经网络工作原理,推荐一个bilibili的讲卷积神经网络的视频,up主从...

    TensorFlow 2.0 (五) - mnist手写数字识别(CNN卷积神经网络)

    源代码/数据集已上传到 Github - tensorflow-tutorial-samples

    卷积神经网络gif动图

    大白话讲解卷积神经网络工作原理,推荐一个bilibili的讲卷积神经网络的视频,up主从youtube搬运过来,用中文讲了一遍。

    这篇文章是 TensorFlow 2.0 Tutorial 入门教程的第五篇文章,介绍如何使用卷积神经网络(Convolutional Neural Network, CNN)来提高mnist手写数字识别的准确性。之前使用了最简单的784x10的神经网络,达到了 0.91 的正确性,而这篇文章在使用了卷积神经网络后,正确性达到了0.99

    卷积神经网络(Convolutional Neural Network, CNN)是一种前馈神经网络,它的人工神经元可以响应一部分覆盖范围内的周围单元,对于大型图像处理有出色表现。

    卷积神经网络由一个或多个卷积层和顶端的全连通层(对应经典的神经网络)组成,同时也包括关联权重和池化层(pooling layer)。这一结构使得卷积神经网络能够利用输入数据的二维结构。与其他深度学习结构相比,卷积神经网络在图像和语音识别方面能够给出更好的结果。这一模型也可以使用反向传播算法进行训练。相比较其他深度、前馈神经网络,卷积神经网络需要考量的参数更少,使之成为一种颇具吸引力的深度学习结构。

    ——维基百科

    1. 安装TensorFlow 2.0

    Google与2019年3月发布了TensorFlow 2.0,TensorFlow 2.0 清理了废弃的API,通过减少重复来简化API,并且通过Keras能够轻松地构建模型,从这篇文章开始,教程示例采用TensorFlow 2.0版本。

    1
    
    pip install tensorflow==2.0.0-beta0
    

    或者在这里下载whl包安装:https://pypi.tuna.tsinghua.edu.cn/simple/tensorflow/

    2. 代码目录结构

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    
    data_set_tf2/  # TensorFlow 2.0的mnist数据集
        |--mnist.npz  
    test_images/   # 预测所用的图片
        |--0.png
        |--1.png
        |--4.png
    v4_cnn/
        |--ckpt/   # 模型保存的位置
            |--checkpoint
            |--cp-0005.ckpt.data-00000-of-00001
            |--cp-0005.ckpt.index
        |--predict.py  # 预测代码
        |--train.py    # 训练代码
    

    3. CNN模型代码(train.py)

    模型定义的前半部分主要使用Keras.layers提供的Conv2D(卷积)与MaxPooling2D(池化)函数。

    CNN的输入是维度为 (image_height, image_width, color_channels)的张量,mnist数据集是黑白的,因此只有一个color_channel(颜色通道),一般的彩色图片有3个(R,G,B),熟悉Web前端的同学可能知道,有些图片有4个通道(R,G,B,A),A代表透明度。对于mnist数据集,输入的张量维度就是(28,28,1),通过参数input_shape传给网络的第一层。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    
    import os
    import tensorflow as tf
    from tensorflow.keras import datasets, layers, models
    
    
    class CNN(object):
        def __init__(self):
            model = models.Sequential()
            # 第1层卷积,卷积核大小为3*3,32个,28*28为待训练图片的大小
            model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
            model.add(layers.MaxPooling2D((2, 2)))
            # 第2层卷积,卷积核大小为3*3,64个
            model.add(layers.Conv2D(64, (3, 3), activation='relu'))
            model.add(layers.MaxPooling2D((2, 2)))
            # 第3层卷积,卷积核大小为3*3,64个
            model.add(layers.Conv2D(64, (3, 3), activation='relu'))
    
            model.add(layers.Flatten())
            model.add(layers.Dense(64, activation='relu'))
            model.add(layers.Dense(10, activation='softmax'))
    
            model.summary()
    
            self.model = model
    

    model.summary()用来打印我们定义的模型的结构。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    
    Model: "sequential"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    conv2d (Conv2D)              (None, 26, 26, 32)        320       
    _________________________________________________________________
    max_pooling2d (MaxPooling2D) (None, 13, 13, 32)        0         
    _________________________________________________________________
    conv2d_1 (Conv2D)            (None, 11, 11, 64)        18496     
    _________________________________________________________________
    max_pooling2d_1 (MaxPooling2 (None, 5, 5, 64)          0         
    _________________________________________________________________
    conv2d_2 (Conv2D)            (None, 3, 3, 64)          36928     
    _________________________________________________________________
    flatten (Flatten)            (None, 576)               0         
    _________________________________________________________________
    dense (Dense)                (None, 64)                36928     
    _________________________________________________________________
    dense_1 (Dense)              (None, 10)                650       
    =================================================================
    Total params: 93,322
    Trainable params: 93,322
    Non-trainable params: 0
    _________________________________________________________________
    

    我们可以看到,每一个Conv2DMaxPooling2D层的输出都是一个三维的张量(height, width, channels)。height和width会逐渐地变小。输出的channel的个数,是由第一个参数(例如,32或64)控制的,随着height和width的变小,channel可以变大(从算力的角度)。

    模型的后半部分,是定义输出张量的。layers.Flatten会将三维的张量转为一维的向量。展开前张量的维度是(3, 3, 64) ,转为一维(576)的向量后,紧接着使用layers.Dense层,构造了2层全连接层,逐步地将一维向量的位数从576变为64,再变为10。

    后半部分相当于是构建了一个隐藏层为64,输入层为576,输出层为10的普通的神经网络。最后一层的激活函数是softmax,10位恰好可以表达0-9十个数字。

    最大值的下标即可代表对应的数字,使用numpy很容易计算出来:

    1
    2
    3
    4
    5
    6
    
    import numpy as np
    
    y1 = [0, 0.8, 0.1, 0.1, 0, 0, 0, 0, 0, 0]
    y2 = [0, 0.1, 0.1, 0.1, 0.5, 0, 0.2, 0, 0, 0]
    np.argmax(y1) # 1
    np.argmax(y2) # 4
    

    4. mnist数据集预处理(train.py)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    
    class DataSource(object):
        def __init__(self):
            # mnist数据集存储的位置,如何不存在将自动下载
            data_path = os.path.abspath(os.path.dirname(__file__)) + '/../data_set_tf2/mnist.npz'
            (train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data(path=data_path)
            # 6万张训练图片,1万张测试图片
            train_images = train_images.reshape((60000, 28, 28, 1))
            test_images = test_images.reshape((10000, 28, 28, 1))
            # 像素值映射到 0 - 1 之间
            train_images, test_images = train_images / 255.0, test_images / 255.0
    
            self.train_images, self.train_labels = train_images, train_labels
            self.test_images, self.test_labels = test_images, test_labels
    

    因为mnist数据集国内下载不稳定,因此数据集也同步到了Github仓库。

    对mnist数据集的介绍,大家可以参考这个系列的第一篇文章TensorFlow入门(一) - mnist手写数字识别(网络搭建)

    5. 开始训练并保存训练结果(train.py)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    
    class Train:
        def __init__(self):
            self.cnn = CNN()
            self.data = DataSource()
    
        def train(self):
            check_path = './ckpt/cp-{epoch:04d}.ckpt'
            # period 每隔5epoch保存一次
            save_model_cb = tf.keras.callbacks.ModelCheckpoint(check_path, save_weights_only=True, verbose=1, period=5)
    
            self.cnn.model.compile(optimizer='adam',
                                   loss='sparse_categorical_crossentropy',
                                   metrics=['accuracy'])
            self.cnn.model.fit(self.data.train_images, self.data.train_labels, epochs=5, callbacks=[save_model_cb])
    
            test_loss, test_acc = self.cnn.model.evaluate(self.data.test_images, self.data.test_labels)
            print("准确率: %.4f,共测试了%d张图片 " % (test_acc, len(self.data.test_labels)))
    
    
    if __name__ == "__main__":
        app = Train()
        app.train()
    

    在执行python train.py后,会得到以下的结果:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    
    Train on 60000 samples
    Epoch 1/5
    60000/60000 [==============================] - 45s 749us/sample - loss: 0.1477 - accuracy: 0.9536
    Epoch 2/5
    60000/60000 [==============================] - 45s 746us/sample - loss: 0.0461 - accuracy: 0.9860
    Epoch 3/5
    60000/60000 [==============================] - 50s 828us/sample - loss: 0.0336 - accuracy: 0.9893
    Epoch 4/5
    60000/60000 [==============================] - 50s 828us/sample - loss: 0.0257 - accuracy: 0.9919
    Epoch 5/5
    59968/60000 [============================>.] - ETA: 0s - loss: 0.0210 - accuracy: 0.9930
    Epoch 00005: saving model to ./ckpt/cp-0005.ckpt
    60000/60000 [==============================] - 51s 848us/sample - loss: 0.0210 - accuracy: 0.9930
    10000/10000 [==============================] - 3s 290us/sample - loss: 0.0331 - accuracy: 0.9901
    准确率: 0.9901,共测试了10000张图片
    

    可以看到,在第一轮训练后,识别准确率达到了0.9536,5轮之后,使用测试集验证,准确率达到了0.9901

    在第五轮时,模型参数成功保存在了./ckpt/cp-0005.ckpt。接下来我们就可以加载保存的模型参数,恢复整个卷积神经网络,进行真实图片的预测了。

    6. 图片预测(predict.py)

    为了将模型的训练和加载分开,预测的代码写在了predict.py中。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    
    import tensorflow as tf
    from PIL import Image
    import numpy as np
    
    from train import CNN
    
    '''
    python 3.7
    tensorflow 2.0.0b0
    pillow(PIL) 4.3.0
    '''
    
    class Predict(object):
        def __init__(self):
            latest = tf.train.latest_checkpoint('./ckpt')
            self.cnn = CNN()
            # 恢复网络权重
            self.cnn.model.load_weights(latest)
    
        def predict(self, image_path):
            # 以黑白方式读取图片
            img = Image.open(image_path).convert('L')
            img = np.reshape(img, (28, 28, 1)) / 255.
            x = np.array([1 - img])
    
            # API refer: https://keras.io/models/model/
            y = self.cnn.model.predict(x)
    
            # 因为x只传入了一张图片,取y[0]即可
            # np.argmax()取得最大值的下标,即代表的数字
            print(image_path)
            print(y[0])
            print('        -> Predict digit', np.argmax(y[0]))
    
    
    if __name__ == "__main__":
        app = Predict()
        app.predict('../test_images/0.png')
        app.predict('../test_images/1.png')
        app.predict('../test_images/4.png')
    

    最终,执行predict.py,可以看到:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    
    $ python predict.py
    ../test_images/0.png
    [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
            -> Predict digit 0
    ../test_images/1.png
    [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
            -> Predict digit 1
    ../test_images/4.png
    [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
            -> Predict digit 4
    

    与TensorFlow1.0的区别总结

    1. 数据集从tensorflow.examples.tutorials.mnist切换到了tensorflow.keras.datasets
    2. Keras的接口成为了主力,datasets, layers, models都是从Keras引入的,而且在网络的搭建上,代码更少,更为简洁。

    附: 推荐

    展开全文
  • 利用pythorch 实现kaggle比赛中mnist识别,准确率99+%,运用CNN MLP LSTM等多种方法,内含数据和文档,环境配置方法,代码有注释,解压后可直接运行,适合初学者!
  • mnist手写识别

    2019-02-09 15:53:57
    mnist手写识别
  • 用于卷积神经网络CNNMNIST手写数字图片集,bmp格式,共包含已经分好组的200张图片,共20组,每组0-9 10个数字
  • Tensoflow+CNN实现简单的mnist手写数字识别

    MNIST数据集

    该数据集的下载官网是 mnist
    在tensorflow里面可直接用下面代码实现:

    from tensorflow.examples.tutorials.mnist import input_data
    mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

    改代码运行之后所在路径下会多出一个MNIST_data 的文件夹,里面为mnist数据集的四个文件(假如运行时间很长那就是在下载,可以自己把mnist的四个文件拷贝到该文件夹下面)。
    下载下来的数据集被分成两部分:60000行的训练数据集(mnist.train)和10000行的测试数据集(mnist.test),每一个MNIST数据单元有两部分组成:一张包含手写数字的图片和一个对应的标签。我们把这些图片设为“xs”,把这些标签设为“ys”。训练数据集和测试数据集都包含xs和ys,比如训练数据集的图片是mnist.train.images,训练数据集的标签是mnist.train.labels
    在MNIST训练数据集中,mnist.train.images 是一个形状为 [60000, 784] 的张量,第一个维度数字用来索引图片,第二个维度数字用来索引每张图片中的像素点。在此张量里的每一个元素,都表示某张图片里的某个像素的强度值,值介于0和1之间。

    CNN网络框架


    该图是利用Tensorflow中的Tensorboard功能画出来的。
    可以看到从下往上分别是input–>conv1–>pool1–>conv2–>pool2–>fc1–>fc2–output,即输入,卷积层1,池化层1,卷积层2,池化层2,全连接层1,全连接层2,输出标签信息。
    最原始的输入为[n_samples, 784],reshape 之后为 x_image ,大小为[n_samples, 28, 28, 1],其中 n_samples是样本数量,28*28为一幅图片的规格,1为颜色通道,因为在这是黑白图,假如是彩色的RGB图,颜色通道就是3。
    在conv1层中,滤波器的尺寸为5*5(即patch的大小),滤波器的数量有32个,所以经过conv1层后的输出规格为 [n_samples, 28, 28, 32]。
    在pool1层中,滤波器的尺寸为2*2,移动步长在x轴方向和y轴方向分别为2,所以经过这一层后的输出为[n_samples, 14, 14, 32]。
    在conv2层中,滤波器的尺寸为5*5,滤波器的数量有64个,每一个对图像在深度方向上做卷积操作,所以输出的规格为[n_samples, 14, 14 ,64]。
    在pool2层中,滤波器与pool1层一样,输出为[n_samples, 7, 7, 64]。
    在fc1即第一层全连接层中,加入了dropout,防止过拟合,dropout的作用就是部分连接(这也是cnn与传统的神经网络的区别之一)。
    fc2层输入为[n_samples, 1024],输出是一个10维的列向量,按0,1编码,它的标签是什么,就在对应位置处置1,否则为0。比如输出的标签为2,则编码为[0 0 1 0 0 0 0 0 0 0]。

    整个神经网络最终的优化目标函数为交叉熵:
    Hy(y)=iyilog(yi)
    y 是我们预测的概率分布, y’ 是实际的分布, 在实际操作的时候,因为每个batch大小为100,即每次取100个样本进行训练,这样的话交叉熵用代码表示为
    cross_entropy=tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction), reduction_indices=[1]))
    然后用Adam优化器来优化这个目标函数,使其最小
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

    交叉熵随训练次数的增加其变化趋势如图:
    这里写图片描述

    以上参考极客学院的tensorflow官方中文版手册

    源代码

    # -*- coding:utf-8: -*-
    import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    
    mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
    
    
    def compute_accuracy(v_xs, v_ys):
        global prediction
        y_pre = sess.run(prediction, feed_dict={xs: v_xs, keep_prob: 1})
        # print('y_pre=', np.shape(y_pre))
        # print('tf.argmax(y_pre, 1)=', sess.run(tf.argmax(y_pre, 1)))
        correct_prediction = tf.equal(tf.argmax(y_pre, 1), tf.argmax(v_ys, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        result = sess.run(accuracy, feed_dict={xs: v_xs, ys: v_ys, keep_prob: 1})
        return result
    
    
    def weight_variable(shape, layer_name):
        with tf.name_scope('weights'):
            initial = tf.truncated_normal(shape, stddev=0.1)
            weights = tf.Variable(initial, name='W')
            tf.summary.histogram(layer_name+'/weights', weights)
        return weights
    
    
    def bias_variable(shape, layer_name):
        with tf.name_scope('biases'):
            initial = tf.constant(0.1, shape=shape)
            biases = tf.Variable(initial, name='b')
            tf.summary.histogram(layer_name+'biases', biases)
        return biases
    
    
    def conv2d(x, W, layer_name):  # 卷积层函数
        # stride 格式为: [1, x_movement, y_movement, 1]
        # must have strides[0]=strides[3]=1
        outputs = tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
        tf.summary.histogram(layer_name+'/outputs', outputs)
        return outputs
        # W: [filter_height, filter_width, in_channels, out_channels]
    
    
    def max_pool_2x2(x, layer_name):  # 池化层函数
        outputs = tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
        tf.summary.histogram(layer_name+'/outputs', outputs)
        return outputs
    
    
    with tf.name_scope('inputs'):
        # define placeholder for inputs to network
        xs = tf.placeholder(tf.float32, [None, 784], name='x_input')  # 28*28
        ys = tf.placeholder(tf.float32, [None, 10], name='y_input')
        keep_prob = tf.placeholder(tf.float32, name='keep_prob')
    # keep_prob是保留概率,即我们要保留的结果所占比例,
    # 它作为一个placeholder,在run时传入, 当keep_prob=1的时候,相当于100%保留,也就是dropout没有起作用。
    x_image = tf.reshape(xs, [-1, 28, 28, 1], name='x_image')  # 图片高度为1
    # print(x_image.shape)  # [n_samples, 28, 28, 1]
    
    ##########################################################################
    ###  构建整个卷积神经网络
    ##########################################################################
    
    # conv1 layer #
    with tf.name_scope('conv1'):
        W_conv1 = weight_variable([5, 5, 1, 32], 'conv1')  # patch 5*5, in_size=1. out_size=32
        b_conv1 = bias_variable([32], 'conv1')
        h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1, 'conv1')+b_conv1)  # output_size = 28*28*32
    
    with tf.name_scope('pool1'):
        h_pool1 = max_pool_2x2(h_conv1, 'pool1')  # output_size = 14*14*32
    
    with tf.name_scope('conv2'):
        # conv2 layer #
        W_conv2 = weight_variable([5, 5, 32, 64], 'conv2')  # patch 5*5, in_size=32. out_size=64
        b_conv2 = bias_variable([64], 'conv2')
        h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2, 'conv2')+b_conv2)  # output_size = 14*14*64
    
    with tf.name_scope('pool2'):
        h_pool2 = max_pool_2x2(h_conv2, 'pool2')  # output_size = 7*7*64
    
    with tf.name_scope('fc1'):
        # func1 layer #
        W_fc1 = weight_variable([7*7*64, 1024], 'fc1')
        b_fc1 = bias_variable([1024], 'fc1')
    
        h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])  # [n_samples, 7, 7, 64]-->[n_samples,7*7*64]
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1)+b_fc1)
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)  # dropout防止过拟合
    
    with tf.name_scope('fc2'):
        # func2 layer #
        W_fc2 = weight_variable([1024, 10], 'fc2')
        b_fc2 = bias_variable([10], 'fc2')
        prediction = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2)+b_fc2)
    
    
    with tf.name_scope('cross_entropy'):
        cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction), reduction_indices=[1]))
        tf.summary.scalar('corss_entropy', cross_entropy)
    
    
    with tf.name_scope('train'):
        train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    
    sess = tf.Session()
    merged = tf.summary.merge_all()
    writer = tf.summary.FileWriter("logs/", sess.graph)
    
    sess.run(tf.global_variables_initializer())
    
    for i in range(1000):
        batch_xs, batch_ys = mnist.train.next_batch(100)
        # print batch_xs.shape, batch_ys.shape
        ## 输出 (100, 784) (100, 10)
        sess.run(train_step, feed_dict={xs: batch_xs, ys: batch_ys, keep_prob: 0.5})
        if i % 50 == 0:
            rs = sess.run(merged, feed_dict={xs: batch_xs, ys: batch_ys, keep_prob: 0.5})
            writer.add_summary(rs, i)
            print(compute_accuracy(mnist.test.images[: 1000], mnist.test.labels[: 1000]))

    以上代码参考morvan的tensorflow教程

    运行结果

    这里写图片描述
    手写数字识别准确率达到了96.3%

    last but not least

    这是我的关于深度学习的第一篇博客,我相信我能坚持写下去,与更多的朋友交流深度学习,计算机视觉等相关领域的知识。也感谢我身边有个一直督促我前进的人,哈哈。最后附上NG和他夫人的照片。
    这里写图片描述

    展开全文
  • mnist.npz 适合新手的手写数字识别本地数据集,可以用来做简单的卷积神经网络,循环神经网络等深度学习模型
  • PyTorch: CNN实战MNIST手写数字识别

    千次阅读 2019-04-19 15:51:23
    PyTorch: CNN实战MNIST手写数字识别cnn导包加载数据构造CNN训练并计算损失结果 cnn 卷积神经网络CNN的结构一般包含这几个层: 输入层:用于数据的输入 卷积层:使用卷积核进行特征提取和特征映射 激励层:由于...

    PyTorch: CNN实战MNIST手写数字识别

    cnn

    卷积神经网络CNN的结构一般包含这几个层: 
    输入层:用于数据的输入 
    卷积层:使用卷积核进行特征提取和特征映射 
    激励层:由于卷积也是一种线性运算,因此需要增加非线性映射 
    池化层:进行下采样,对特征图稀疏处理,减少数据运算量。 
    全连接层:通常在CNN的尾部进行重新拟合,减少特征信息的损失 
    输出层:用于输出结果
    

    导包

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import torch.optim as optim
    from torchvision import datasets, transforms
    from torch.autograd import Variable
    

    换了一台电脑,这台只装了pytorch,没有装Torchvision,重新安装Torchvision

    conda install torchvision
    
    D:\document\ML\camp>conda install torchvision
    Fetching package metadata ...............
    
    PackageNotFoundError: Packages missing in current channels:
    
      - torchvision
    
    

    找不到相应的package
    换官网上安装命令conda install pytorch-cpu torchvision-cpu -c pytorch,报http请求错误

    D:\document\ML\camp>conda install pytorch-cpu torchvision-cpu -c pytorch
    Fetching package metadata ...
    CondaHTTPError: HTTP 000 CONNECTION FAILED for url <https://conda.anaconda.org/pytorch/win-64/repodata.json>
    Elapsed: -
    
    

    删掉中间的pytorch

    D:\document\ML\camp>conda install torchvision-cpu -c pytorch
    Fetching package metadata .................
    Solving package specifications: .
    
    Package plan for installation in environment C:\ProgramData\Anaconda3:
    
    The following NEW packages will be INSTALLED:
    
        torchvision-cpu: 0.2.2-py_3 pytorch
    
    Proceed ([y]/n)? y
    
    torchvision-cp 100% |###############################| Time: 0:00:01  23.94 kB/s
    
    

    装好了

    加载数据

    # MNIST Dataset
    train_dataset = datasets.MNIST(root='./data/',
                                   train=True,
                                   transform=transforms.ToTensor(),
                                   download=True)
    
    test_dataset = datasets.MNIST(root='./data/',
                                  train=False,
                                  transform=transforms.ToTensor())
    
    # Data Loader (Input Pipeline)
    train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                               batch_size=batch_size,
                                               shuffle=True)
    
    test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                              batch_size=batch_size,
                                              shuffle=False)
    
    

    构造CNN

    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            # 输入1通道,输出10通道,kernel 5*5
            self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
            self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
            self.mp = nn.MaxPool2d(2)
            # fully connect
            self.fc = nn.Linear(320, 10)
    
        def forward(self, x):
            # in_size = 64
            in_size = x.size(0) # one batch
            # x: 64*10*12*12
            x = F.relu(self.mp(self.conv1(x)))
            # x: 64*20*4*4
            x = F.relu(self.mp(self.conv2(x)))
            # x: 64*320
            x = x.view(in_size, -1) # flatten the tensor
            # x: 64*10
            x = self.fc(x)
            return F.log_softmax(x)
    
    
    model = Net()
    
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
    

    训练并计算损失

    def train(epoch):
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = Variable(data), Variable(target)
            optimizer.zero_grad()
            output = model(data)
            loss = F.nll_loss(output, target)
            loss.backward()
            optimizer.step()
            if batch_idx % 200 == 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 loss():
        test_loss = 0
        correct = 0
        for data, target in test_loader:
            data, target = Variable(data, volatile=True), Variable(target)
            output = model(data)
            # sum up batch loss
            test_loss += F.nll_loss(output, target, size_average=False).item()
            # get the index of the max log-probability
            pred = output.data.max(1, keepdim=True)[1]
            correct += pred.eq(target.data.view_as(pred)).cpu().sum()
    
        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)
        loss()
    

    结果

    最后得到的准确率为98%, loss: 0.0507

    Train Epoch: 1 [0/60000 (0%)]	Loss: 2.320769
    Train Epoch: 1 [12800/60000 (21%)]	Loss: 0.519038
    Train Epoch: 1 [25600/60000 (43%)]	Loss: 0.335463
    Train Epoch: 1 [38400/60000 (64%)]	Loss: 0.266052
    Train Epoch: 1 [51200/60000 (85%)]	Loss: 0.192065
    
    Test set: Average loss: 0.1718, Accuracy: 9496/10000 (94%)
    
    Train Epoch: 2 [0/60000 (0%)]	Loss: 0.196151
    Train Epoch: 2 [12800/60000 (21%)]	Loss: 0.117710
    Train Epoch: 2 [25600/60000 (43%)]	Loss: 0.112761
    Train Epoch: 2 [38400/60000 (64%)]	Loss: 0.215878
    Train Epoch: 2 [51200/60000 (85%)]	Loss: 0.158413
    
    Test set: Average loss: 0.1082, Accuracy: 9683/10000 (96%)
    
    Train Epoch: 3 [0/60000 (0%)]	Loss: 0.140935
    Train Epoch: 3 [12800/60000 (21%)]	Loss: 0.135737
    Train Epoch: 3 [25600/60000 (43%)]	Loss: 0.092188
    Train Epoch: 3 [38400/60000 (64%)]	Loss: 0.084430
    Train Epoch: 3 [51200/60000 (85%)]	Loss: 0.077458
    
    Test set: Average loss: 0.0812, Accuracy: 9763/10000 (97%)
    
    Train Epoch: 4 [0/60000 (0%)]	Loss: 0.064760
    Train Epoch: 4 [12800/60000 (21%)]	Loss: 0.151439
    Train Epoch: 4 [25600/60000 (43%)]	Loss: 0.113604
    Train Epoch: 4 [38400/60000 (64%)]	Loss: 0.061374
    Train Epoch: 4 [51200/60000 (85%)]	Loss: 0.036855
    
    Test set: Average loss: 0.0656, Accuracy: 9807/10000 (98%)
    
    Train Epoch: 5 [0/60000 (0%)]	Loss: 0.159602
    Train Epoch: 5 [12800/60000 (21%)]	Loss: 0.054143
    Train Epoch: 5 [25600/60000 (43%)]	Loss: 0.112333
    Train Epoch: 5 [38400/60000 (64%)]	Loss: 0.163274
    Train Epoch: 5 [51200/60000 (85%)]	Loss: 0.067363
    
    Test set: Average loss: 0.0667, Accuracy: 9796/10000 (97%)
    
    Train Epoch: 6 [0/60000 (0%)]	Loss: 0.092683
    Train Epoch: 6 [12800/60000 (21%)]	Loss: 0.111712
    Train Epoch: 6 [25600/60000 (43%)]	Loss: 0.053559
    Train Epoch: 6 [38400/60000 (64%)]	Loss: 0.033269
    Train Epoch: 6 [51200/60000 (85%)]	Loss: 0.048830
    
    Test set: Average loss: 0.0587, Accuracy: 9822/10000 (98%)
    
    Train Epoch: 7 [0/60000 (0%)]	Loss: 0.043137
    Train Epoch: 7 [12800/60000 (21%)]	Loss: 0.034103
    Train Epoch: 7 [25600/60000 (43%)]	Loss: 0.072622
    Train Epoch: 7 [38400/60000 (64%)]	Loss: 0.066607
    Train Epoch: 7 [51200/60000 (85%)]	Loss: 0.041002
    
    Test set: Average loss: 0.0544, Accuracy: 9840/10000 (98%)
    
    Train Epoch: 8 [0/60000 (0%)]	Loss: 0.009038
    Train Epoch: 8 [12800/60000 (21%)]	Loss: 0.059637
    Train Epoch: 8 [25600/60000 (43%)]	Loss: 0.012170
    Train Epoch: 8 [38400/60000 (64%)]	Loss: 0.018512
    Train Epoch: 8 [51200/60000 (85%)]	Loss: 0.049446
    
    Test set: Average loss: 0.0475, Accuracy: 9846/10000 (98%)
    
    Train Epoch: 9 [0/60000 (0%)]	Loss: 0.016563
    Train Epoch: 9 [12800/60000 (21%)]	Loss: 0.068632
    Train Epoch: 9 [25600/60000 (43%)]	Loss: 0.027334
    Train Epoch: 9 [38400/60000 (64%)]	Loss: 0.032353
    Train Epoch: 9 [51200/60000 (85%)]	Loss: 0.021624
    
    Test set: Average loss: 0.0507, Accuracy: 9840/10000 (98%)
    
    
    Process finished with exit code 0
    
    展开全文
  • 梯度下降纯手工实现 MLP CNN RNN SEQ2SEQ识别手写MNIST数据集十分类问题代码详解.
  • CNN(Convolutional Neural Network)卷积神经网络对于MNIST手写数字识别的实战代码和心得 首先是对代码结构思路进行思路图展示,如下: 参数和原理剖析: 因为MNIST图片为长和宽相同的28像素,为黑白两色,所以图片...
  • 本工程使用C99标准的纯C语言(不使用STL)编写了CNN,实现在MNIST数据集上的手写数字识别。本文目的是为将来在FPGA等更底层的边缘设备上实现CNN做铺垫,当然CNN的训练过程在服务器上进行,推断过程在边缘端进行,...
  • 下载训练集,MNIST数据集,手写数字识别 cnn网络
  • 搭建了一个简单的CNN神经网络实现手写数字识别

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,681
精华内容 2,672
关键字:

mnist手写数字识别cnn