精华内容
下载资源
问答
  • tensorflow手写数字识别

    2020-12-16 10:36:33
    tensorflow手写数字识别
  • TensorFlow手写数字识别
  • TensorFlow手写数字识别预处理代码,备注详细可以直接运行,为后续具体算法的 实现提供了可靠、规范的数据源。处理内容包括MNIST数据的下载、读取、整形、归一化、标签独热编码以及画图显示等。
  • tensorflow手写数字识别python源码官网案例,带详细注释,适合刚初学tensorflow的mnist数据集训练识别, 相关链接: 手写数字识别 ----在已经训练好的数据上根据28*28的图片获取识别概率(基于Tensorflow,Python) ...
  • tensorflow手写数字识别 python 编写qt界面演示视频:https://www.bilibili.com/video/BV1uz4y1r7P1?from=search&seid=9468972372585662716
  • 本代码使用python基于TensorFlow设计手写数字识别算法,并编程实现GUI界面,构建手写数字识别系统。这是本人的本科毕业论文课题,当然,这个也是机器学习的基本问题。本博文不会以论文的形式展现,而是以编程实战...
  • 使用TensorFlow实现简单的手写数字0-9识别,下载后解压配置环境运行。
  • TensorFlow手写数字识别mnist example源码分析

    TensorFlow手写数字识别mnist example源码分析
    TensorFlow 默认安装在 /usr/lib/Python/site-packages/tensorflow/

    实例文件位于tensorflow/models/image/mnist/convolutional.py,为TensorFlow自带的example文件。

    # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
    #
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.
    # ==============================================================================
    """Simple, end-to-end, LeNet-5-like convolutional MNIST model example.
    This should achieve a test error of 0.7%. Please keep this model as simple and
    linear as possible, it is meant as a tutorial for simple convolutional models.
    Run with --self_test on the command line to execute a short self-test.
    """
    from __future__ import absolute_import
    from __future__ import division
    from __future__ import print_function
    import argparse
    import gzip
    import os
    import sys
    import time
    
    import numpy
    from six.moves import urllib
    from six.moves import xrange  # pylint: disable=redefined-builtin
    import tensorflow as tf
    
    SOURCE_URL = 'http://yann.lecun.com/exdb/mnist/'  # 数据源
    WORK_DIRECTORY = 'data'  # 工作目录,存放下载的数据
    # MNIST 数据集特征:
    #     图像尺寸 28x28
    IMAGE_SIZE = 28
    NUM_CHANNELS = 1  # 黑白图像
    PIXEL_DEPTH = 255  # 像素值0~255
    NUM_LABELS = 10  # 标签分10个类别
    VALIDATION_SIZE = 5000  # 验证集大小
    SEED = 66478  # 随机数种子,可设为 None 表示真的随机
    BATCH_SIZE = 64  # 批处理大小为64
    NUM_EPOCHS = 10  # 数据全集一共过10遍网络
    EVAL_BATCH_SIZE = 64  # 验证集批处理大小也是64
    # 验证时间间隔,每训练100个批处理,做一次评估
    EVAL_FREQUENCY = 100  # Number of steps between evaluations.
    
    FLAGS = None
    
    
    def data_type():
        """Return the type of the activations, weights, and placeholder variables."""
        if FLAGS.use_fp16:
            return tf.float16
        else:
            return tf.float32
    
    
    def maybe_download(filename):
        """如果下载过了数据,就不再重复下载"""
        if not tf.gfile.Exists(WORK_DIRECTORY):
            tf.gfile.MakeDirs(WORK_DIRECTORY)
        filepath = os.path.join(WORK_DIRECTORY, filename)
        if not tf.gfile.Exists(filepath):
            filepath, _ = urllib.request.urlretrieve(SOURCE_URL + filename, filepath)
            with tf.gfile.GFile(filepath) as f:
                size = f.size()
            print('Successfully downloaded', filename, size, 'bytes.')
        return filepath
    
    
    def extract_data(filename, num_images):
        # 抽取数据,变为 4维张量[图像索引,y, x, c]
        # 去均值、做归一化,范围变到[-0.5, 0.5]
        print('Extracting', filename)
        with gzip.open(filename) as bytestream:
            bytestream.read(16)
            buf = bytestream.read(IMAGE_SIZE * IMAGE_SIZE * num_images * NUM_CHANNELS)
            data = numpy.frombuffer(buf, dtype=numpy.uint8).astype(numpy.float32)
            data = (data - (PIXEL_DEPTH / 2.0)) / PIXEL_DEPTH
            data = data.reshape(num_images, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS)
            return data
    
    
    def extract_labels(filename, num_images):
        """Extract the labels into a vector of int64 label IDs."""
        print('Extracting', filename)
        with gzip.open(filename) as bytestream:
            bytestream.read(8)
            buf = bytestream.read(1 * num_images)
            labels = numpy.frombuffer(buf, dtype=numpy.uint8).astype(numpy.int64)
        return labels
    
    
    def fake_data(num_images):
        """Generate a fake dataset that matches the dimensions of MNIST."""
        """生成一个匹配MNIST数据集大小的伪造数据集"""
        data = numpy.ndarray(
            shape=(num_images, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS),
            dtype=numpy.float32)
        labels = numpy.zeros(shape=(num_images,), dtype=numpy.int64)
        for image in xrange(num_images):
            label = image % 2
            data[image, :, :, 0] = label - 0.5
            labels[image] = label
        return data, labels
    
    
    def error_rate(predictions, labels):
        """Return the error rate based on dense predictions and sparse labels."""
        return 100.0 - (
            100.0 *
            numpy.sum(numpy.argmax(predictions, 1) == labels) /
            predictions.shape[0])
    
    
    # 主函数
    def main(_):
        if FLAGS.self_test:
            print('Running self-test.')
            train_data, train_labels = fake_data(256)
            validation_data, validation_labels = fake_data(EVAL_BATCH_SIZE)
            test_data, test_labels = fake_data(EVAL_BATCH_SIZE)
            num_epochs = 1
        else:
            # 下载数据
            train_data_filename = maybe_download('train-images-idx3-ubyte.gz')
            train_labels_filename = maybe_download('train-labels-idx1-ubyte.gz')
            test_data_filename = maybe_download('t10k-images-idx3-ubyte.gz')
            test_labels_filename = maybe_download('t10k-labels-idx1-ubyte.gz')
    
            # 载入数据到numpy
            train_data = extract_data(train_data_filename, 60000)
            train_labels = extract_labels(train_labels_filename, 60000)
            test_data = extract_data(test_data_filename, 10000)
            test_labels = extract_labels(test_labels_filename, 10000)
    
            # 产生评测集
            validation_data = train_data[:VALIDATION_SIZE, ...]
            validation_labels = train_labels[:VALIDATION_SIZE]
            train_data = train_data[VALIDATION_SIZE:, ...]
            train_labels = train_labels[VALIDATION_SIZE:]
            num_epochs = NUM_EPOCHS # 数据全集一共过10遍网络
        train_size = train_labels.shape[0]
    
        # 训练样本和标签将从这里送入网络。
        # 每训练迭代步,占位符节点将被送入一个批处理数据
        # 训练数据节点
        train_data_node = tf.placeholder(
            data_type(),
            shape=(BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS))
        # 训练标签节点
        train_labels_node = tf.placeholder(tf.int64, shape=(BATCH_SIZE,))
        # 评测数据节点
        eval_data = tf.placeholder(
            data_type(),
            shape=(EVAL_BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS))
        # 下面这些变量是网络的可训练权值
        # conv1 权值维度为 32 x channels x 5 x 5, 32 为特征图数目
        conv1_weights = tf.Variable(
            tf.truncated_normal([5, 5, NUM_CHANNELS, 32],  # 5x5 filter, depth 32.
                                stddev=0.1,
                                seed=SEED, dtype=data_type()))
        # conv1 偏置
        conv1_biases = tf.Variable(tf.zeros([32], dtype=data_type()))
        # conv2 权值维度为 64 x 32 x 5 x 5
        conv2_weights = tf.Variable(tf.truncated_normal(
            [5, 5, 32, 64], stddev=0.1,
            seed=SEED, dtype=data_type()))
        # conv2 偏置
        conv2_biases = tf.Variable(tf.constant(0.1, shape=[64], dtype=data_type()))
        # 全连接层 fc1 权值,神经元数目为512
        fc1_weights = tf.Variable(  # fully connected, depth 512.
            tf.truncated_normal([IMAGE_SIZE // 4 * IMAGE_SIZE // 4 * 64, 512],
                                stddev=0.1,
                                seed=SEED,
                                dtype=data_type()))
        fc1_biases = tf.Variable(tf.constant(0.1, shape=[512], dtype=data_type()))
        # fc2 权值,维度与标签类数目一致
        fc2_weights = tf.Variable(tf.truncated_normal([512, NUM_LABELS],
                                                      stddev=0.1,
                                                      seed=SEED,
                                                      dtype=data_type()))
        fc2_biases = tf.Variable(tf.constant(
            0.1, shape=[NUM_LABELS], dtype=data_type()))
    
        # 两个网络:训练网络和评测网络
        # 它们共享权值
        # 实现 LeNet-5 模型,该函数输入为数据,输出为fc2的响应
        # 第二个参数区分训练网络还是评测网络
        def model(data, train=False):
            # 二维卷积,使用“不变形”补零(即输出特征图与输入尺寸一致)。
            conv = tf.nn.conv2d(data,
                                conv1_weights,
                                strides=[1, 1, 1, 1],
                                padding='SAME')
            # 加偏置、过激活函数一块完成
            relu = tf.nn.relu(tf.nn.bias_add(conv, conv1_biases))
            # 最大值下采样
            pool = tf.nn.max_pool(relu,
                                  ksize=[1, 2, 2, 1],
                                  strides=[1, 2, 2, 1],
                                  padding='SAME')
            # 第二个卷积层,步长为1
            conv = tf.nn.conv2d(pool,
                                conv2_weights,
                                strides=[1, 1, 1, 1],
                                padding='SAME')
            relu = tf.nn.relu(tf.nn.bias_add(conv, conv2_biases))
    
            pool = tf.nn.max_pool(relu,
                                  ksize=[1, 2, 2, 1],
                                  strides=[1, 2, 2, 1],
                                  padding='SAME')
            # 特征图变形为2维矩阵,便于送入全连接层
            pool_shape = pool.get_shape().as_list()
            reshape = tf.reshape(
                pool,
                [pool_shape[0], pool_shape[1] * pool_shape[2] * pool_shape[3]])
            # 全连接层,注意“+”运算自动广播偏置
            hidden = tf.nn.relu(tf.matmul(reshape, fc1_weights) + fc1_biases)
            # 训练阶段,增加 50% dropout;而评测阶段无需该操作
            if train:
                hidden = tf.nn.dropout(hidden, 0.5, seed=SEED)
            return tf.matmul(hidden, fc2_weights) + fc2_biases
    
    
            # 训练阶段计算: 对数+交叉熵 损失函数
    
        logits = model(train_data_node, True)
        loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
            logits, train_labels_node))
    
        # 全连接层参数进行 L2 正则化
        regularizers = (tf.nn.l2_loss(fc1_weights) + tf.nn.l2_loss(fc1_biases) +
                        tf.nn.l2_loss(fc2_weights) + tf.nn.l2_loss(fc2_biases))
        # 将正则项加入损失函数
        loss += 5e-4 * regularizers
    
        # 优化器: 设置一个变量,每个批处理递增,控制学习速率衰减
        batch = tf.Variable(0, dtype=data_type())
        # Decay once per epoch, using an exponential schedule starting at 0.01.
        #  指数衰减
        learning_rate = tf.train.exponential_decay(
            0.01,  # 基本学习速率
            batch * BATCH_SIZE,  # 当前批处理在数据全集中的位置
            train_size,  # Decay step.
            0.95,  # 衰减率
            staircase=True)
        # Use simple momentum for the optimization.
        optimizer = tf.train.MomentumOptimizer(learning_rate,
                                               0.9).minimize(loss,
                                                             global_step=batch)
    
        # 用softmax 计算训练批处理的预测概率
        train_prediction = tf.nn.softmax(logits)
    
        # 用 softmax 计算评测批处理的预测概率
        eval_prediction = tf.nn.softmax(model(eval_data))
    
        # Small utility function to evaluate a dataset by feeding batches of data to
        # {eval_data} and pulling the results from {eval_predictions}.
        # Saves memory and enables this to run on smaller GPUs.
        def eval_in_batches(data, sess):
            """通过运行在小批量数据,得到所有预测结果."""
            size = data.shape[0]
            if size < EVAL_BATCH_SIZE:
                raise ValueError("batch size for evals larger than dataset: %d" % size)
            predictions = numpy.ndarray(shape=(size, NUM_LABELS), dtype=numpy.float32)
            for begin in xrange(0, size, EVAL_BATCH_SIZE):
                end = begin + EVAL_BATCH_SIZE
                if end <= size:
                    predictions[begin:end, :] = sess.run(
                        eval_prediction,
                        feed_dict={eval_data: data[begin:end, ...]})
                else:
                    batch_predictions = sess.run(
                        eval_prediction,
                        feed_dict={eval_data: data[-EVAL_BATCH_SIZE:, ...]})
                    predictions[begin:, :] = batch_predictions[begin - size:, :]
            return predictions
    
        # Create a local session to run the training.
        start_time = time.time()
        with tf.Session() as sess:
            # 初始化操作准备参数
            tf.global_variables_initializer().run()
            print('Initialized!')
            # 循环训练
            for step in xrange(int(num_epochs * train_size) // BATCH_SIZE):
                # 计算当前minibatch的offset
                # Note that we could use better randomization across epochs.
                offset = (step * BATCH_SIZE) % (train_size - BATCH_SIZE)
                batch_data = train_data[offset:(offset + BATCH_SIZE), ...]
                batch_labels = train_labels[offset:(offset + BATCH_SIZE)]
                # This dictionary maps the batch data (as a numpy array) to the
                # node in the graph it should be fed to.
                feed_dict = {train_data_node: batch_data,
                             train_labels_node: batch_labels}
                # 运行优化器更新权重
                sess.run(optimizer, feed_dict=feed_dict)
                # print some extra information once reach the evaluation frequency
                if step % EVAL_FREQUENCY == 0:
                    # fetch some extra nodes' data
                    l, lr, predictions = sess.run([loss, learning_rate, train_prediction],
                                                  feed_dict=feed_dict)
                    elapsed_time = time.time() - start_time
                    start_time = time.time()
                    print('Step %d (epoch %.2f), %.1f ms' %
                          (step, float(step) * BATCH_SIZE / train_size,
                           1000 * elapsed_time / EVAL_FREQUENCY))
                    print('Minibatch loss: %.3f, learning rate: %.6f' % (l, lr))
                    print('Minibatch error: %.1f%%' % error_rate(predictions, batch_labels))
                    print('Validation error: %.1f%%' % error_rate(
                        eval_in_batches(validation_data, sess), validation_labels))
                    sys.stdout.flush()
            # Finally print the result!
            test_error = error_rate(eval_in_batches(test_data, sess), test_labels)
            print('Test error: %.1f%%' % test_error)
            if FLAGS.self_test:
                print('test_error', test_error)
                assert test_error == 0.0, 'expected 0.0 test_error, got %.2f' % (
                    test_error,)
    
    
    if __name__ == '__main__':
        parser = argparse.ArgumentParser()
        parser.add_argument(
            '--use_fp16',
            default=False,
            help='Use half floats instead of full floats if True.',
            action='store_true')
        parser.add_argument(
            '--self_test',
            default=False,
            action='store_true',
            help='True if running a self test.')
    
        FLAGS, unparsed = parser.parse_known_args()
        tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)
    
    展开全文
  • 根据上一篇文章实现的代码的基础上,这篇文章将继续学习TensorFlow手写数字识别,这篇文章的目的是:把手写数字预测错误的图片输出,文件名“&lt;序号&gt;-&lt;原本数字&gt;-predict&lt;预测...
    • 根据上一篇文章实现的代码的基础上,这篇文章将继续学习TensorFlow手写数字识别,这篇文章的目的是:把手写数字预测错误的图片输出,文件名“<序号>-<原本数字>-predict<预测数字>”
    import tensorflow as tf
    import input_data
    import numpy as np
    import cv2
    #读取数据
    mnist = input_data.read_data_sets("MNIST_data",one_hot=True)
    #创建可交互的操作单元
    x = tf.placeholder("float",[None,784])
    w = tf.Variable(tf.zeros([784,10]))
    b = tf.Variable(tf.zeros([10]))
    
    #实现回归模型,其中y是预测值,并且y是一个m*10的矩阵
    y = tf.nn.softmax(tf.matmul(x,w) + b)
    
    ##训练模型
    #为了计算交叉熵,首先添加一个新的占位符用于输入正确值,并且y_是一个m*10的矩阵
    y_ = tf.placeholder("float",[None,10])
    
    #使用公式  -Σy'log(y)  计算交叉熵
    cross_entropy = -tf.reduce_sum(y_*tf.log(y))
    
    #梯度下降
    train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
    
    #上面已经把模型设置好了,在运行计算之前,下面先初始化创建的变量
    init = tf.initialize_all_variables()
    
    #现在我们可以在一个session里面启动模型,并且初始化向量
    sess = tf.Session()
    sess.run(init)
    
    #下面开始训练模型,这里我们让模型循环1000次
    #在循环的每个步骤中,都会随机抓取训练数据中的100个批处理数据点作为参数替换之前的占位符来运行train_step
    for i in range(1000):
    	#batch_xs是样本图片,batch_ys是样本的标签
    	batch_xs, batch_ys = mnist.train.next_batch(100)
    	sess.run(train_step, feed_dict = {x: batch_xs, y_: batch_ys})
    
    #模型评估
    #argmax(y,1)得到的是每个预测值所表示的one-hot向量中最大的数的下标
    #首先找出预测正确的标签,argmax(y,1)是一个m*1的矩阵,argmax(y_,1)也是m*1的矩阵
    #得到的correct_prediction也是一个m*1的矩阵,这只是理论上而已,但是实际运行时已经变成1*m的向量了
    #并且corr_prediction是一个[True,False,True,.....]
    correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
    
    
    
    #print(sess.run(correct_prediction, feed_dict = {x:mnist.test.images, y_:mnist.test.labels}))
    
    #下面对测试数据集进行预测,得到的result是一个1*m的张量,得到的predict是一个m*10的张量,下面的x是一个m*784的张量
    result,predict = sess.run((correct_prediction,y), feed_dict = {x:mnist.test.images, y_:mnist.test.labels})
    
    #对该张量进行遍历,由于result是一个张量,所以用shape来获取其形状,应为(m,)再取其[0]得到该张量的个数
    for i in range(result.shape[0]):
    	if(result[i]==False):
    		img = mnist.test.images[i].reshape((28,28))
    		#输入样本是灰度图像,范围是0~1,现在变成0~255的uint8类型才能正常显示,用255-是为了反色
    		img = 255-img*255
    		img = img.astype(np.uint8)
    		cv2.imwrite("incorrect_image/%d-%d-predict%d.png" %(i, np.argmax(mnist.test.labels[i]), np.argmax(predict[i])),img)
    
    • 下面是输出结果图片

    在这里插入图片描述

    展开全文
  • 使用tensorflow 手写数字识别 报错:No module named ‘tensorflow.examples.tutorials’,这是由于缺少tutorials文件。 1、到python安装文件夹下“Python36\Lib\site-packages\tensorflow”找看有没有examples...

    使用tensorflow 手写数字识别 报错:No module named ‘tensorflow.examples.tutorials’,这是由于缺少tutorials文件。
    1、到python安装文件夹下“Python36\Lib\site-packages\tensorflow”找看有没有examples文件夹,在该文件夹下寻找tutorials文件夹,如果没有就从[https://github.com/tensorflow/tensorflow]下载。
    在这里插入图片描述

    在这里插入图片描述
    寻找你下载tensorflow的版本
    2、从下载好的tensorflow里找到tutorials复制到examples文件夹下。
    3、查看Python36\Lib\site-packages\tensorflow_core文件夹下的examples文件夹下是否有tutorials文件夹,如果没有,就将第2步中的tutorials文件夹复制进来(提示如果第1步中有tutorials文件夹,那就将第1步里的tutorials文件夹复制进来就行)。
    4、如果可以运行但报“连接不到远程主机”就是网络问题。

    展开全文
  • 上一篇文章完成了简陋版的tensorflow手写数字实现(tensorflow自主学习入门-从零开始篇(二)tensorflow手写数字识别),虽然简陋,但是总的能从中学到一些东西,现在又赶紧将自己前一段时间学习到的关于tensorflow...

    上一篇文章完成了简陋版的tensorflow手写数字实现(tensorflow自主学习入门-从零开始篇(二)tensorflow手写数字识别),虽然简陋,但是总的能从中学到一些东西,现在又赶紧将自己前一段时间学习到的关于tensorflow手写数字的东西记录分享出来,以防遗忘。

    当然,很大可能你看完上面的一篇文章还是不知所云晕头转向,没关系,接着看下去,这是必须要经过的阶段。当然,开始之前建议你在手机上设置一个30min的闹铃然后全神投入阅读这篇文章之中,相信对你会很有帮助。


    本文我将在上一篇文章实现的基础之上对它进行改进,如果你成功的让上一篇的代码在你的机器上跑了起来,你就会发现,无论你怎样设置你的迭代次数,最后的Testing Accuracy(测试准确率)几乎不会超过93%,这也是简单模型的局限所在,本文我将进一步的优化它的代码以将其准确率提高至95%,但是重要的是借由优化代码我所想要表达与解释的东西。

    将实现准确率提高的方法先提出来:在代码中加入隐藏层(关于隐藏层的定义目前知道即可)


    为了兼顾文章的条理性与易于易理解性,不同于上一篇文章,本文将会分为两个部分,所以希望大家可以在阅读时将思路也分为这两部分作为参考:

    1. 代码部分 相比上篇文章的修改部分
    2. 你需要知道、理解的部分,以及建议你必须完成的部分
    3. 代码汇总

    一 、代码部分

    经过思考最终决定本文的代码部分将被放置于第一部分,因为想要通过本文学习到东西,绝对需要对比上一篇文章的代码与本文代码的异同,甚至如果有必要可以逐行分析,这一点非常重要


    加载MNIST数据,导入所需模块

    不同于上一篇文章,你会发现本次额外导入 time 模块,它将被用于记录我们模型训练最终所用时间,为了方便以后不同策略方法之间的对比,time模块将会是标配。

    本代码其余部分无变化

    from tensorflow.examples.tutorials.mnist import input_data
    import tensorflow as tf
    import time#用于获取迭代运行时间,比较不同方案
    #加载数据
    mnist  = input_data.read_data_sets("MNIST_data",one_hot=True)
    

    构建模型添加隐藏层

    首先,这里的代码分块的非常清晰,认真分析后你会发现,与上一篇文章的这一部分不同的是,我只在这里定义了x 与 y 两个placeholder,这里x用于传mnist.train.images ,而 y 用于传入 mnist.train.labels

    因此在这里的y 相当于上一篇文章的 y_ 理解这一点相当重要,此外这里还有一个kepp_prob,如果你是用的pycharm的话,你就会发现他的最终去向tf.nn.dropout中的一个参数,关于他的作用代码中有解释,详细可以搜索。

    第二点,相比于上一篇文章w 和 两个被定义为tf.Variable ,本文中他们被分解为 (W1 、W2 、W3 )和 (b1 、b2 、b3)并最终转化为W3 、 b3 ,进行运算。

    第三点,关于这里的2000一定需要进行理解,与他相关的数学知识是矩阵乘法,这里是指2000个 神经元,但是过多的神经元也会造成运算时间变慢以及过拟合的情况,这就用到了我们定义的keep_prob,详细代码注释中会解释。

    #定义回归模型
    keep_prob=tf.placeholder(tf.float32)
    x = tf.placeholder(tf.float32,[None,784])
    y = tf.placeholder(tf.float32,[None,10])##输入的真是值的占位符
    #创建一个简单的神经网络
    #输入层
    W1 = tf.Variable(tf.truncated_normal([784,2000],stddev=0.1))#初始化时一个非常重要的环节
    b1 = tf.Variable(tf.zeros([2000])+0.1)
    L1 = tf.nn.tanh(tf.matmul(x,W1)+b1)#使用双曲正切
    L1_drop = tf.nn.dropout(L1,keep_prob) #tensorflow封装好的dropout函数,L1是我们需要控制的神经元,keep_prob是工作的神经元的百分比
    #注意使用dropout后会使模型的训练速度下降
    
    W2 = tf.Variable(tf.truncated_normal([2000,1000],stddev=0.1))#增加隐藏层设置2000个神经元,这里是故意定义一个复杂的神经网络
    b2 = tf.Variable(tf.zeros([1000])+0.1)#期望其出项过度拟合的情况
    L2 = tf.nn.tanh(tf.matmul(L1_drop,W2)+b2)
    L2_drop = tf.nn.dropout(L2,keep_prob)
    #输出层
    W3 = tf.Variable(tf.truncated_normal([1000,10],stddev=0.1))
    b3 = tf.Variable(tf.zeros([10])+0.1)
    #注意这里的知识点是tensorflow中矩阵相乘的规则
    prediction = tf.nn.softmax(tf.matmul(L2_drop,W3)+b3)
    
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))#损失函数
    #tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)
    #除去name参数用以指定该操作的name,与方法有关的一共两个参数:
    #第一个参数logits:就是神经网络最后一层的输出,未经过soft_max
    #第二个参数labels:实际的标签,需要是one-hot格式
    

    构建评估模型

    这一部分没有变化,我只是将它做的更加的精简,这里的优化器依然使用
    tf.train.GradientDescentOptimizer梯度下降法,设置学习率为0.01让loss损失函数最小化

    
    #定义损失函数和优化器
    train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
    #评估训练好的模型
    correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#计算预测值和真实值
    #计算模型在测试集上的准确率
    #tf.cast作用:布尔型转化为浮点数,并且取平均值,得到准确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    init = tf.global_variables_initializer()
    

    构建评估模型

    这里有两点与上一篇文章不同

    1. 加入time.clock()用于记录程序运行时间
    2. 迭代次数降低至100次,但是准确率大幅上升
    start = time.clock()
    with tf.Session() as sess:
        sess.run(init)
        for i in range(101):
            bath_xs, bath_ys = mnist.train.next_batch(100)
            #注意这里不同于上一部分的是模型需要传入的参数增加了keep_prob(需要运行的神经元的数量)
            sess.run(train_step, feed_dict={x:bath_xs,y:bath_ys,keep_prob:0.7})
            if i % 10 == 0:
                acc = sess.run(accuracy, feed_dict={x:mnist.test.images, y: mnist.test.labels,keep_prob:1})
                print("Iter " + str(i) + ",Testing Accuracy " + str(acc))
    end = time.clock()
    print('Running time: %s Seconds'%int(end-start))
    print('训练完成')
    

    二 、建议你必须完成的部分

    • 认真读完本文文章后返回上一篇文章再读一遍
    • 将两次的代码分别打开,对比每一部分(建议使用pycharm)
    • 用一张纸列下两次代码的不同点(不是很多,难度不大,但是需要形成自己的思考)
    • 使本文的代码再自己的机器上跑起来
    • 推荐去看看优化器相关知识,学有余力可以开始尝试使用自己的方法提高准确率(Test accuracy)

    三 、代码汇总

    上代码:


    from tensorflow.examples.tutorials.mnist import input_data
    import tensorflow as tf
    import time#用于获取迭代运行时间,比较不同方案
    #加载数据
    mnist  = input_data.read_data_sets("MNIST_data",one_hot=True)
    #定义回归模型
    keep_prob=tf.placeholder(tf.float32)
    x = tf.placeholder(tf.float32,[None,784])
    y = tf.placeholder(tf.float32,[None,10])##输入的真是值的占位符
    #创建一个简单的神经网络
    
    W1 = tf.Variable(tf.truncated_normal([784,2000],stddev=0.1))#初始化时一个非常重要的环节
    b1 = tf.Variable(tf.zeros([2000])+0.1)
    L1 = tf.nn.tanh(tf.matmul(x,W1)+b1)#使用双曲正切
    L1_drop = tf.nn.dropout(L1,keep_prob) #tensorflow封装好的dropout函数,L1是我们需要控制的神经元,keep_prob是工作的神经元的百分比
    #注意使用dropout后会使模型的训练速度下降
    
    W2 = tf.Variable(tf.truncated_normal([2000,1000],stddev=0.1))#增加隐藏层设置2000个神经元,这里是故意定义一个复杂的神经网络
    b2 = tf.Variable(tf.zeros([1000])+0.1)#期望其出项过度拟合的情况
    L2 = tf.nn.tanh(tf.matmul(L1_drop,W2)+b2)
    L2_drop = tf.nn.dropout(L2,keep_prob)
    
    W3 = tf.Variable(tf.truncated_normal([1000,10],stddev=0.1))
    b3 = tf.Variable(tf.zeros([10])+0.1)
    #注意这里的知识点是tensorflow中矩阵相乘的规则
    prediction = tf.nn.softmax(tf.matmul(L2_drop,W3)+b3)
    
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))#损失函数
    #tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)
    #除去name参数用以指定该操作的name,与方法有关的一共两个参数:
    #第一个参数logits:就是神经网络最后一层的输出,未经过soft_max
    #第二个参数labels:实际的标签,需要是one-hot格式
    
    #定义损失函数和优化器
    train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
    #评估训练好的模型
    correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#计算预测值和真实值
    #计算模型在测试集上的准确率
    #tf.cast作用:布尔型转化为浮点数,并且取平均值,得到准确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    
    
    init = tf.global_variables_initializer()
    
    #Train开始训练
    start = time.clock()
    with tf.Session() as sess:
        sess.run(init)
        for i in range(51):
            bath_xs, bath_ys = mnist.train.next_batch(100)
            #注意这里不同于上一部分的是模型需要传入的参数增加了keep_prob(需要运行的神经元的数量)
            sess.run(train_step, feed_dict={x:bath_xs,y:bath_ys,keep_prob:0.7})
            if i % 10 == 0:
                acc = sess.run(accuracy, feed_dict={x:mnist.test.images, y: mnist.test.labels,keep_prob:1})
                print("Iter " + str(i) + ",Testing Accuracy " + str(acc))
    end = time.clock()
    print('Running time: %s Seconds'%int(end-start))
    print('训练完成')
    
    

    最后,我希望大家有问题可以私信问我,我会很愿意帮你解答,毕竟,这就是在以一种很有效率的方式帮助我的学习,加深我对它的理解,需要加好友提问的朋友可以留言QQ。

    希望本文对你有所帮助,接下来我会更新进一步优化将识别准确率提升到99%以上的文章,以及加入tensorboard可视化的文章,希望对你有所帮助。

    展开全文
  • Tensorflow手写数字识别

    2020-08-04 19:16:27
    MNIST是一个入门级的计算机视觉数据集,它包含各种手写数字图片: 它也包含每一张图片对应的标签,告诉我们这个是数字几。比如,上面这四张图片的标签分别是5,0,4,1。 为了便于下载MNIST数据集,执行下面的...
  • 用python编写的,基于tensorflow深度学习的框架的手写数字识别的完整代码,有注释,可运行,无bug
  • 刚接触神经网络的可以参考参考,网络结构是全连接的,代码流程也比较清晰,用的MNIST数据集,运行起来也很快。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,386
精华内容 2,154
关键字:

tensorflow手写数字