精华内容
下载资源
问答
  • 一份基于cnn手写数字识别的代码,供大家参考,具体内容如下 # -*- coding: utf-8 -*- import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data # 加载数据集 mnist = input_data....
  • 卷积神经网络(Convolutional Neural Networks, CNN)是一类包含卷积计算且具有深度结构的前馈神经网络(Feedforward Neural Networks),是深度学习(deep learning)的代表算法之一 [1-2] 。卷积神经网络具有表征...
  • 基于卷积神经网络的手写数字识别python代码实现 卷积神经网络(Convolutional Neural Network,CNN)中,卷积层的神经元只与前一层的部分神经元节点相连,即它的神经元间的连接是非全连接的,且同一层中某些神经元...
  • 使用Python+TensorFlow,全连接的神经网络,基于MNIST数据集。数据集包含60000张训练图片,10000张测试图片。MNIST_model文件夹是已经训练30000次的模型,也可以自己再训练。app.py文件可以测试自己的图片。 也可以...
  • CNN_Handwritten_Digit_Recognizer (CNN手写数字识别)A CNN handwritten digit recognizer with graphical UI, implemented with Python (tensorflow, kivy).一个带界面的CNN手写数字识别,使用Python(tensorflow, ...

    CNN_Handwritten_Digit_Recognizer (CNN手写数字识别)

    A CNN handwritten digit recognizer with graphical UI, implemented with Python (tensorflow, kivy).

    一个带界面的CNN手写数字识别,使用Python(tensorflow, kivy)实现。

    Introduction (简介)

    This is a simple handwritten digit recognizer application, implemented with only Python language. Basically, I use Tensorflow to build the CNN classifier as the recognizer, and use Kivy to realize the UI. This program supports mouse or touch screen, and can recognize 0-9 altogether 10 numbers. The keypoint is as follows:

    Use Tensorflow (as well as its Estimator API) to build the CNN model. Use MNIST dataset to train the model.

    Use Kivy to build the UI.

    After drawing digit on the Kivy App window, the app export the digit as a image, which, after being processed with PIL, is feeded to the CNN model. The recognition result is displayed on the window later.

    这是一个简单的手写数字识别小应用,全部使用Python语言实现,主要使用Tensorflow搭建CNN分类器作为后台识别器,使用Kivy框架编写前端界面,支持鼠标或触控操作,能够识别0-9这10个数字。实现的技术要点如下:

    使用Tensorflow(和其Estimator API)构建CNN模型,使用MNIST数据集训练模型;

    使用Kivy框架构建前端界面;

    在Kivy界面上写字后,将界面导出成图片,使用PIL处理后喂给后端的CNN进行识别,识别结果显示在界面上。

    Dependencies (依赖环境)

    Python 3

    Tensorflow

    Kivy

    Numpy

    PIL

    Run (运行方法)

    Run the main app:

    python main.py

    Train the model (trained model is included, so the main app can work immediately)

    python trainer.py

    You can also modify some hyperparams in trainer.py.

    使用以下命令启动主程序:

    python main.py

    使用一下命令进行模型的训练(已有训练好的模型,可以直接使用):

    python trainer.py

    可以在trainer.py文件中更改各种模型的超参数。

    Existing Problems (存在的问题)

    Some existing problems, which I will try to find out the reasons and fix in the future when I'm free. There we have:

    When drawing digit at the first time after the app runs, the response time is quite long. I guess it's about the loading of tf, and multi-thread may help.

    The effectiveness of the recognition is not very good. The classifer is easy to mix some digits (like 2 & 7, 2 & 3, 0 & 6 etc.).

    If I modify the x in MNIST dataset, changing values not equal to 0 into 1, the training speed will be much slower. I don't know why.

    If you know how to handle these existing problem, or any other problems, feel free to let me know. Thank you!

    现在已知存在的问题,之后有时间再找原因修复。问题有:

    启动程序后,第一次写字,响应速度慢,猜想是第一次要加载tf相关的东西,拖慢了速度,估计可以用多线程解决;

    识别效果一般,有几个数字(如2和7,2和3,0和6)经常混淆;

    若将MNIST数据集进行处理,将x中所有非0值改为1,训练速度会极大的下降,不知道是为什么。

    存在的这些问题或其他问题,若有大神知道原因或解决方法,求告知。

    Finally (最后)

    I wrote it just for fun, btw learn the use of Tensorflow and git. I'm new to TF and DL. Any seggestions is welcomed. Thank you!

    这个小程序就是自己写着玩,顺便学学Tensorflow和git的使用。TF和深度学习新手,请多包涵,请多指导。

    Reference (参考资料)

    展开全文
  • # 创建占位符是 tf 读取数据的一种方法,让python代码来提供数据 with tf.name_scope('image'): x_image = tf.reshape(x, [-1, 28, 28, 1]) # -1表示由实际情况来定,图像数目*宽*高/28/28/1=第一维数 tf.summary....

    注释很详细,这里不再赘述。 

    import tensorflow.compat.v1 as tf
    tf.disable_v2_behavior()
    from tensorflow.examples.tutorials.mnist import input_data  # 下载数据集
    
    # 初始化参数
    def weight_variable(shape):
        initial = tf.truncated_normal(shape, stddev=0.1)
        # shape是必选项,输出张量维度,stddev=0.1用于设置正态分布被截断前的标准差
        return tf.Variable(initial)
    
    def bias_variable(shape):
        initial = tf.constant(0.1, shape=shape)
        # 开始时设置为0.1
        return tf.Variable(initial)
    
    def conv2d(x, W):
        return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
    
    def max_pool_2x2(x):
        return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
        # ksize为卷积核大小  padding取valid时卷积之后图像大小为N=(imgSize-ksize)/strides
        # x 表示输入图像,要求是一个tensor具有[batch,in_height,in_width,in_channels]这样的shape,为float32或者64
        # 过滤器要求是一个tensor,具有[filter_height,filter_width,in_channels,out_channels]这样的shape
    
    # 获取数据
    mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
    
    # tf.name_scope()和tf.variable_scope()是两个作用域,
    # 一般与两个创建/调用变量的函数tf.variable() 和tf.get_variable()搭配使用,用于变量共享
    # input image:pixel 28*28 = 784
    with tf.name_scope('input'):
        x = tf.placeholder(tf.float32, [None, 784])
        y_ = tf.placeholder('float', [None, 10])  # y_ 代表真实结果
        # 创建占位符是 tf 读取数据的一种方法,让python代码来提供数据
    
    with tf.name_scope('image'):
        x_image = tf.reshape(x, [-1, 28, 28, 1])  # -1表示由实际情况来定,图像数目*宽*高/28/28/1=第一维数
        tf.summary.image('input_image', x_image, 8)
        # 输出带图像的probuf,汇总数据的图像的的形式如下: ’ tag /image/0’, ’ tag /image/1’…,如:input/image/0等
    
    # 第一个卷积层
    with tf.name_scope('conv_layer1'):
        W_conv1 = weight_variable([5, 5, 1, 32])  # 卷积核(kernel): 5*5*1, kernel个数: 32
        b_conv1 = bias_variable([32])
        h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)  # 输出(output): 28*28*32
    # 池化
    with tf.name_scope('pooling_layer'):
        h_pool1 = max_pool_2x2(h_conv1)  # 最大池化, 输出(output): 14*14*32
    
    # 第二个卷积层
    with tf.name_scope('conv_layer2'):
        W_conv2 = weight_variable([5, 5, 32, 64])  # 卷积核(kernel): 5*5, 深度: 32, kernel个数: 64
        b_conv2 = bias_variable([64])
        h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)  # 输出(output): 14*14*64
    # 池化
    with tf.name_scope('pooling_layer'):
        h_pool2 = max_pool_2x2(h_conv2)  # 最大池化, 输出(output): 7*7*64
    
    
    # 第一个全连接层
    with tf.name_scope('fc_layer3'):
        W_fc1 = weight_variable([7 * 7 * 64, 1024])
        b_fc1 = bias_variable([1024])  # 大小 : 1*1024
        h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)  # 输出(output): 1*1024
    
    # dropout层  dropout层一般加在全连接层 防止过拟合,提升模型泛化能力
    with tf.name_scope('dropout'):
        keep_prob = tf.placeholder(tf.float32)
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
    
    
    # 第二个全连接层
    # 训练模型 : y = softmax(x * w + b)
    with tf.name_scope('output_fc_layer4'):
        W_fc2 = weight_variable([1024, 10])
        b_fc2 = bias_variable([10])  # 大小 : 1*10
    
    with tf.name_scope('softmax'):
        y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)  # 输出(output): 1*10
    
    with tf.name_scope('lost'):
        cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))   # 交叉熵计算损失函数
        tf.summary.scalar('lost', cross_entropy)
    
    with tf.name_scope('train'):
        train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
        # AdamOptimizer是tensorflow中的一种优化器,1e-4是学习率
        # 为了最小化损失函数,需要用到反向传播思想,随机梯度下降算法来最小化损失函数
    
    with tf.name_scope('accuracy'):
        correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
        tf.summary.scalar('accuracy', accuracy)  # 显示标量信息
        '''
        tf.argmax(y_conv, 1) 是返回第二维(行方向)上最大值的索引,
        tf.equal() 是比较两个值是否相等,返回一个 bool 值(True or False),
        tf.cast() 是将bool 值转换为 1.0 or 0.0 的浮点类型,
        tf.reduce_mean() 是计算平均值。
        '''
    
    merged = tf.summary.merge_all()
    train_summary = tf.summary.FileWriter(r'C:\Users\12956\Anaconda3\Lib\site-packages', tf.get_default_graph())
    # 将这里的地址路径改成tensorboard文件夹的绝对路径地址
    
    init = tf.global_variables_initializer()
    # 进行初始化,之前只是定义variable
    
    # 执行
    with tf.Session() as sess:
        sess.run(init)
        # 构建一个session,在session中运行
        # 训练数据 : 得到参数 w 和 b
        for i in range(2000):  # 迭代2000次
            batch = mnist.train.next_batch(50)
            # 批量给网络提供数据
    
            result, _ = sess.run([merged, train_step], feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0})
            # 在mnist数据集中,0是输入的图片,1是输入的标签,这个batch是784*10的
            # train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
    
            if i % 100 == 0:
                # train_accuracy = sess.run(accuracy, feed_dict)
                train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0})  # 无dropout
                print('step %d, training accuracy %g' % (i, train_accuracy))
    
                # result = sess.run(merged, feed_dict={x: batch[0], y_: batch[1]})
                train_summary.add_summary(result, i)
    
        train_summary.close()
    
        print('test accuracy %g' % accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
    
    
    

    可以直接复制运行,记得将路径改一下~

    #import tensorflow as tf
    import tensorflow.compat.v1 as tf
    tf.disable_v2_behavior()
    #from tensorflow.examples.tutorials.mnist import input_data
    #用下面这几句代码来代替上面这句
    #import tensorflow as tf
    
    tf.__version__
    mint = tf.keras.datasets.mnist
    (x_, y_), (x_1, y_1) = mint.load_data()
    import matplotlib.pyplot as plt
    plt.imshow(x_[0], cmap="binary")
    plt.show()
    
    import tensorflow.examples.tutorials.mnist.input_data as input_data
    mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
    
    # import tensorflow as tf
    # (train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()
    
    # from tensorflow.examples.tutorials.mnist import input_data
    # mnist = input_data.read_data_sets ( ” MNIST_data/ ”, one_hot=True)
    
    # import tensorflow.examples.tutorials.mnist.input_data as input_data
    # mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
    
    # 初始化权重函数
    def weight_variable(shape):
        initial = tf.truncated_normal(shape, stddev=0.1);  # 生成维度是shape标准差是0.1的正态分布数
        return tf.Variable(initial)
    
    
    # 初始化偏置项
    def bias_variable(shape):
        initial = tf.constant(0.1, shape=shape)  # 生成维度为shape的全为0.1的向量
        return tf.Variable(initial)
    
    
    # 定义卷积函数
    def conv2d(x, w):
        return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')
        # strides: 卷积时在图像每一维的步长,这是一个一维的向量,
        # [ 1, strides, strides, 1],第一位和最后一位固定必须是1
        # padding参数是string类型,值为“SAME” 和 “VALID”,表示的是卷积的形式。
        # 设置为"SAME"时,会在原图像边缘外增加几圈0来使卷积后的矩阵和原图像矩阵的维度相同
        # 设置为"VALID"则不考虑这一点,卷积后的矩阵维度会相应减少,例如原图像如果是5*5,卷积核是3*3
        # 那么卷积过后的输出矩阵回是3*3的
    
    
    # 定义一个2*2的最大池化层
    def max_pool_2_2(x):
        return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
        # 第一个参数value:需要池化的输入,一般池化层接在卷积层后面,
        # 依然是[batch, height, width, channels]这样的shape
        # 第二个参数ksize:池化窗口的大小,取一个四维向量,一般是[1, height, width, 1],
        # 因为我们不想在batch和channels上做池化,所以这两个维度设为了1
        # 第三个参数strides:和卷积类似,窗口在每一个维度上滑动的步长,
        # 一般也是[1, stride,stride, 1]
        # 第四个参数padding:和卷积类似,可以取'VALID' 或者'SAME'
    
    
    if __name__ == "__main__":
        # 定义输入变量
        x = tf.placeholder("float", shape=[None, 784])  # 占位
        # 浮点型变量,行数不定,列数为784(每个图像是一个长度为784(28*28)的向量)
    
        # 定义输出变量
        y_ = tf.placeholder("float", shape=[None, 10])  # 占位
        # 浮点型变量,行数不定,列数为10,输出一个长度为10的向量来表示每个数字的可能性
        # 初始化权重,第一层卷积,32的意思代表的是输出32个通道
        # 其实,也就是设置32个卷积,每一个卷积都会对图像进行卷积操作
    
        w_conv1 = weight_variable([5, 5, 1, 32])  # 生成了32个5*5的矩阵
        # 初始化偏置项
        b_conv1 = bias_variable([32])
    
        x_image = tf.reshape(x, [-1, 28, 28, 1])
        # 将输入的x转成一个4D向量,第2、3维对应图片的宽高,最后一维代表图片的颜色通道数
        # 输入的图像为灰度图,所以通道数为1,如果是RGB图,通道数为3
        # tf.reshape(x,[-1,28,28,1])的意思是将x自动转换成28*28*1的数组
        # -1的意思是代表不知道x的shape,它会按照后面的设置进行转换
    
        # 卷积并激活
        h_conv1 = tf.nn.relu(conv2d(x_image, w_conv1) + b_conv1)
        # 池化
        h_pool1 = max_pool_2_2(h_conv1)
        # 第二层卷积
        # 初始权重
        w_conv2 = weight_variable([5, 5, 32, 64])
        # 在32个第一层卷积层上每个再用一个5*5的卷积核在做特征提取,并输出到第二层卷积层,
        # 第二层设置了64个卷积层
    
        # 初始化偏置项
        b_conv2 = bias_variable([64])
        # 将第一层卷积池化后的结果作为第二层卷积的输入加权求和后激活
        h_conv2 = tf.nn.relu(conv2d(h_pool1, w_conv2) + b_conv2)
        # 池化
        h_pool2 = max_pool_2_2(h_conv2)
        # 设置全连接层的权重
        w_fc1 = weight_variable([7 * 7 * 64, 1024])
        # 28*28的原图像经过两次池化后变为7*7,设置了1024个输出单元
    
        # 设置全连接层的偏置
        b_fc1 = bias_variable([1024])
        # 将第二层卷积池化后的结果,转成一个7*7*64的数组
        h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
        # 通过全连接之后并激活
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, w_fc1) + b_fc1)
        # 防止过拟合
        keep_prob = tf.placeholder("float")  # 占位
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
        # 设置每个单元保留的概率来随机放弃一些单元来防止过拟合
    
        # 输出层
        w_fc2 = weight_variable([1024, 10])
        b_fc2 = bias_variable([10])
        # 加权求和并激活
        y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, w_fc2) + b_fc2)
    
        # 日志输出,每迭代100次输出一次日志
        # 定义交叉熵为损失函数
        cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
        # 最小化交叉熵
        train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
        # 计算准确率
        correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
        sess = tf.Session()
        sess.run(tf.initialize_all_variables())
        # 上面的两行是在为tf的输出变量做准备
        # 下载minist的手写数字的数据集
        mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
        for i in range(20000):  # 迭代20000次
            batch = mnist.train.next_batch(50)  # 设置batch,即每次用来训练模型的数据个数
            if i % 100 == 0:  # 每100次迭代输出一次精度
                train_accuracy = accuracy.eval(session=sess, feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0})
                # 给之前占位的x和y_本次训练的batch个数据中第一个数据的图像矩阵和标签,不考虑过拟合
                # 计算当前的精度
    
                print("step %d,training accuracy %g" % (i, train_accuracy))
            train_step.run(session=sess, feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
            # 当i不能被100整除时的训练过程,考虑过拟合,单元保留的概率为0.5
    
        print("test accuracy %g" % accuracy.eval(session=sess, feed_dict={
            x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
        # 输出测试集的精度

     两种代码实现的功能一样,只是写法不同,第一种是使用with方法编写的,第二种是C语言思想编写的,先定义函数,再使用。

    学无止境,一起学习~

     

    展开全文
  • 实验CNN数字手写识别基于python jupyter notebook android (可运行)可安装在手机.zip实验CNN数字手写识别基于python jupyter notebook android (可运行)可安装在手机.zip实验CNN数字手写识别基于python ...
  • 感觉刚才的代码不够给力,所以再保存一份基于cnn手写数字识别的代码# -*- coding: utf-8 -*-import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data# 加载数据集 mnist = input_...

    感觉刚才的代码不够给力,所以再保存一份基于cnn的手写数字自识别的代码

    # -*- 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)
    
    # 以交互式方式启动session
    # 如果不使用交互式session,则在启动session前必须
    # 构建整个计算图,才能启动该计算图
    sess = tf.InteractiveSession()
    
    """构建计算图"""
    # 通过占位符来为输入图像和目标输出类别创建节点
    # shape参数是可选的,有了它tensorflow可以自动捕获维度不一致导致的错误
    x = tf.placeholder("float", shape=[None, 784])  # 原始输入
    y_ = tf.placeholder("float", shape=[None, 10])  # 目标值
    
    # 为了不在建立模型的时候反复做初始化操作,
    # 我们定义两个函数用于初始化
    def weight_variable(shape):
        # 截尾正态分布,stddev是正态分布的标准偏差
        initial = tf.truncated_normal(shape=shape, stddev=0.1)
        return tf.Variable(initial)
    def bias_variable(shape):
        initial = tf.constant(0.1, shape=shape)
        return tf.Variable(initial)
    
    # 卷积核池化,步长为1,0边距
    def conv2d(x, W):
        return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
    def max_pool_2x2(x):
        return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                              strides=[1, 2, 2, 1], padding='SAME')
    
    """第一层卷积"""
    # 由一个卷积和一个最大池化组成。滤波器5x5中算出32个特征,是因为使用32个滤波器进行卷积
    # 卷积的权重张量形状是[5, 5, 1, 32],1是输入通道的个数,32是输出通道个数
    W_conv1 = weight_variable([5, 5, 1, 32])
    # 每一个输出通道都有一个偏置量
    b_conv1 = bias_variable([32])
    
    # 位了使用卷积,必须将输入转换成4维向量,2、3维表示图片的宽、高
    # 最后一维表示图片的颜色通道(因为是灰度图像所以通道数维1,RGB图像通道数为3)
    x_image = tf.reshape(x, [-1, 28, 28, 1])
    
    # 第一层的卷积结果,使用Relu作为激活函数
    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1))
    # 第一层卷积后的池化结果
    h_pool1 = max_pool_2x2(h_conv1)
    
    """第二层卷积"""
    W_conv2 = weight_variable([5, 5, 32, 64])
    b_conv2 = bias_variable([64])
    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)
    
    """全连接层"""
    # 图片尺寸减小到7*7,加入一个有1024个神经元的全连接层
    W_fc1 = weight_variable([7*7*64, 1024])
    b_fc1 = bias_variable([1024])
    # 将最后的池化层输出张量reshape成一维向量
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
    # 全连接层的输出
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
    
    """使用Dropout减少过拟合"""
    # 使用placeholder占位符来表示神经元的输出在dropout中保持不变的概率
    # 在训练的过程中启用dropout,在测试过程中关闭dropout
    keep_prob = tf.placeholder("float")
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
    
    """输出层"""
    W_fc2 = weight_variable([1024, 10])
    b_fc2 = bias_variable([10])
    # 模型预测输出
    y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
    
    # 交叉熵损失
    cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
    
    # 模型训练,使用AdamOptimizer来做梯度最速下降
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    
    # 正确预测,得到True或False的List
    correct_prediction = tf.equal(tf.argmax(y_, 1), tf.argmax(y_conv, 1))
    # 将布尔值转化成浮点数,取平均值作为精确度
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    # 在session中先初始化变量才能在session中调用
    sess.run(tf.global_variables_initializer())
    
    # 迭代优化模型
    for i in range(2000):
        # 每次取50个样本进行训练
        batch = mnist.train.next_batch(50)
        if i%100 == 0:
            train_accuracy = accuracy.eval(feed_dict={
                x: batch[0], y_: batch[1], keep_prob: 1.0})  # 模型中间不使用dropout
            print("step %d, training accuracy %g" % (i, train_accuracy))
        train_step.run(feed_dict={x:batch[0], y_:batch[1], keep_prob: 0.5})
    print("test accuracy %g" % accuracy.eval(feed_dict={
                x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
    
    

    做了2000次迭代,在测试集上的识别精度能够到0.9772……

    展开全文
  • Python开发,基于TensorFlow+MNIST,含数据集与训练好的模型,已经打包为exe,带UI界面
  • 卷积神经网络经典案例,手写数字识别代码详解,注释之处如有错误,欢迎指正 from tensorflow.examples.tutorials.mnist import input_data import tensorflow as tf #初始化权重函数 def weight_variable(shape):...

    卷积神经网络经典案例,手写数字识别代码详解,注释之处如有错误,欢迎指正

    from tensorflow.examples.tutorials.mnist import input_data
    import tensorflow as tf
    
    #初始化权重函数
    def weight_variable(shape):
        initial = tf.truncated_normal(shape,stddev=0.1);#生成维度是shape标准差是0.1的正态分布数
        return tf.Variable(initial)
    
    #初始化偏置项
    def bias_variable(shape):
        initial = tf.constant(0.1,shape=shape)#生成维度为shape的全为0.1的向量
        return tf.Variable(initial)
    
    #定义卷积函数
    def conv2d(x,w):
        return tf.nn.conv2d(x,w,strides=[1,1,1,1],padding='SAME')
        #strides: 卷积时在图像每一维的步长,这是一个一维的向量,
        #[ 1, strides, strides, 1],第一位和最后一位固定必须是1
        #padding参数是string类型,值为“SAME” 和 “VALID”,表示的是卷积的形式。
        #设置为"SAME"时,会在原图像边缘外增加几圈0来使卷积后的矩阵和原图像矩阵的维度相同
        #设置为"VALID"则不考虑这一点,卷积后的矩阵维度会相应减少,例如原图像如果是5*5,卷积核是3*3
        #那么卷积过后的输出矩阵回是3*3的
        
    #定义一个2*2的最大池化层
    def max_pool_2_2(x):
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
        #第一个参数value:需要池化的输入,一般池化层接在卷积层后面,
        #依然是[batch, height, width, channels]这样的shape
        #第二个参数ksize:池化窗口的大小,取一个四维向量,一般是[1, height, width, 1],
        #因为我们不想在batch和channels上做池化,所以这两个维度设为了1
        #第三个参数strides:和卷积类似,窗口在每一个维度上滑动的步长,
        #一般也是[1, stride,stride, 1]
        #第四个参数padding:和卷积类似,可以取'VALID' 或者'SAME'
     
    if __name__ == "__main__":
        #定义输入变量
        x = tf.placeholder("float",shape=[None,784])#占位    
        #浮点型变量,行数不定,列数为784(每个图像是一个长度为784(28*28)的向量)
        
        #定义输出变量
        y_ = tf.placeholder("float",shape=[None,10])#占位
        #浮点型变量,行数不定,列数为10,输出一个长度为10的向量来表示每个数字的可能性
        #初始化权重,第一层卷积,32的意思代表的是输出32个通道
        # 其实,也就是设置32个卷积,每一个卷积都会对图像进行卷积操作
        
        w_conv1 = weight_variable([5,5,1,32])###生成了32个5*5的矩阵
        #初始化偏置项
        b_conv1 = bias_variable([32])
        
        x_image = tf.reshape(x,[-1,28,28,1])
        #将输入的x转成一个4D向量,第2、3维对应图片的宽高,最后一维代表图片的颜色通道数
        # 输入的图像为灰度图,所以通道数为1,如果是RGB图,通道数为3
        # tf.reshape(x,[-1,28,28,1])的意思是将x自动转换成28*28*1的数组
        # -1的意思是代表不知道x的shape,它会按照后面的设置进行转换
        
        # 卷积并激活
        h_conv1 = tf.nn.relu(conv2d(x_image,w_conv1) + b_conv1)
        #池化
        h_pool1 = max_pool_2_2(h_conv1)
        #第二层卷积
        #初始权重
        w_conv2 = weight_variable([5,5,32,64])
        #在32个第一层卷积层上每个再用一个5*5的卷积核在做特征提取,并输出到第二层卷积层,
        #第二层设置了64个卷积层
        
        #初始化偏置项
        b_conv2 = bias_variable([64])
        #将第一层卷积池化后的结果作为第二层卷积的输入加权求和后激活
        h_conv2 = tf.nn.relu(conv2d(h_pool1,w_conv2) + b_conv2)
        #池化
        h_pool2 = max_pool_2_2(h_conv2)
        # 设置全连接层的权重
        w_fc1 = weight_variable([7*7*64,1024])
        #28*28的原图像经过两次池化后变为7*7,设置了1024个输出单元
        
        # 设置全连接层的偏置
        b_fc1 = bias_variable([1024])
        # 将第二层卷积池化后的结果,转成一个7*7*64的数组
        h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
        # 通过全连接之后并激活
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,w_fc1) + b_fc1)
        # 防止过拟合
        keep_prob = tf.placeholder("float")#占位
        h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
        #设置每个单元保留的概率来随机放弃一些单元来防止过拟合
     
        #输出层
        w_fc2 = weight_variable([1024,10])
        b_fc2 = bias_variable([10])
        #加权求和并激活
        y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,w_fc2) + b_fc2)
     
        #日志输出,每迭代100次输出一次日志
        #定义交叉熵为损失函数
        cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
        #最小化交叉熵
        train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
        #计算准确率
        correct_prediction = tf.equal(tf.argmax(y_conv,1),tf.argmax(y_,1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
        sess = tf.Session()
        sess.run(tf.initialize_all_variables())
        #上面的两行是在为tf的输出变量做准备
        # 下载minist的手写数字的数据集
        mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
        for i in range(20000):#迭代20000次
            batch = mnist.train.next_batch(50)#设置batch,即每次用来训练模型的数据个数
            if i % 100 == 0:#每100次迭代输出一次精度
                train_accuracy = accuracy.eval(session=sess,
                                               feed_dict={x:batch[0],y_:batch[1],keep_prob:1.0})
                #喂给之前占位的x和y_本次训练的batch个数据中第一个数据的图像矩阵和标签,不考虑过拟合
                #计算当前的精度
                
                print("step %d,training accuracy %g"%(i,train_accuracy))
            train_step.run(session = sess,feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})
            #当i不能被100整除时的训练过程,考虑过拟合,单元保留的概率为0.5
     
        print("test accuracy %g" % accuracy.eval(session=sess,feed_dict={
            x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
        #输出测试集的精度

    结果如下:

    因为20000次计算花的时间太长,这里我就换成1000次就输出结果了

    展开全文
  • 包含了可直接运行的CNN的Lenet5模型实现手写数字识别Mnist以及介绍Lenet5模型的PPT
  • 本文实例为大家分享了基于TensorFlow的CNN实现Mnist手写数字识别的具体代码,供大家参考,具体内容如下一、CNN模型结构输入层:Mnist数据集(28*28)第一层卷积:感受视野5*5,步长为1,卷积核:32个第一层池化:池化...
  • 本篇文章主要介绍了PyTorch CNN实战之MNIST手写数字识别示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • python写的手写数字识别,建了一个CNN的神经网络
  • python语言编写,利用TensorFlow建立两层卷积神经网络,数据集为手写识别数据集MNIST,识别准确率99%
  • 摘要: 手把手带你实战——《CNN入门:手写数字识别》!-------------深度学习最令人兴奋的领域之一就是计算机视觉。通过卷积神经网络,我们已经能够创建自动驾驶汽车系统、面部检测系统和自动医学图像分析等等。在...
  • Python实现识别手写数字 简易图片存储管理系统来源:中文源码网浏览: 次日期:2018年9月2日【下载文档:Python实现识别手写数字 简易图片存储管理系统.txt】(友情提示:右键点上行txt文档名->目标另存为)Python...
  • 基于BP神经网络的手写数字识别系统,程序使用python语言编写,训练数据集为mnist;交互界面使用PYQT编写,用户可在画板通过鼠标书写数字作为识别对象。
  • 1、Mnist_cnn.py 该脚本文件 用TensorFlow框架 实现CNN卷积神经网络处理Mnist手写数字识别数据集,准确率达到99.21%; 2、Mnist_cnn_tensorboard.py 该脚本文件在Mnist_cnn.py的基础上实现可视化。
  • 博客:https://blog.csdn.net/weixin_45775701/article/details/109446515
  • python写的手写数字识别,建了一个CNN的神经网络
  • 这种用于识别手写数字的基于CNN的模型在训练12个时期之后获得99.2%的验证准确度。 它在Kaggle的MNIST数据集上训练
  • 由1.0升级的这个2.0其实也非常的简单,无非是按照1.0预处理那样的方式,处理好图片,准确率确实提高了 1.数据集 我是做成黑底白字的图片放在data文件夹里 命名格式是0_,1_这种,_前代表label,图片来源于网上 ...
  • 自己最近写的一个小程序,360报毒添加信任即可,界面UI是用的tkinter,训练的网络是卷积神经网络CNN手写识别率还不错,数字9不太准是因为mnist数据集本身训练集写的和国人习惯不一样。欢迎star 我的github源码:...
  • MNIST手写字 Matlab程序,包含BP和CNN程序。不依赖任何库,包含MNIST数据,BP网络可达到98.3%的识别率,CNN可达到99%的识别率。CNN比较耗时,关于CNN的程序介绍:...
  • FCN实现手写数字数据集MNIST的识别,代码为自己翻写,包含MNIST数据集,代码与大量注释,及24页原创报告
  • 使用cnn手写数字识别“Artificial Intelligence is a branch of science which offers with helping machines discover solutions to complex problems in a greater human-like-fashion” (Sridhar, 2020)....

空空如也

空空如也

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

cnn手写数字识别python

python 订阅