如何用TensorFlow导入MNIST数据集？

简介MNIST

TensorFlow编程学习的入门一般都是基于MNIST手写数字数据集和Cifar(包括cifar-10和cifar-100)数据集，因为它们都比较小，一般的设备即可进行训练和测试。而相比之下虽然基于ImageNet分类数据集的实验更具有意义，更加权威，但由于ImageNet数据集实在太大，不便于入门的童靴直接上手操作。

　　MNIST数据集简介
　　MNIST 数据集的官网是 Yann LeCun‘s website。下载下来的数据集被分成两部分：60000行的训练数据集（mnist.train）和10000行的测试数据集（mnist.test）。这样的切分很重要，在机器学习模型设计时必须有一个单独的测试数据集不用于训练而是用来评估这个模型的性能，从而更加容易把设计的模型推广到其他数据集上（泛化）。

　　我们把这个数组展开成一个向量，长度是 28x28 = 784.如何展开这个数组（数字间的顺序）不重要，只要保持各个图片采用相同的方式展开。从这个角度来看，MNIST数据集的图片就是在784维向量空间里面的点， 并且拥有比较复杂的结构 （提醒： 此类数据的可视化是计算密集型的）。每一张图片包含28像素X28像素。我们可以用一个数字数组来表示这张图片：

　　因此，在MNIST训练数据集中，mnist.train.images 是一个形状为 ［60000， 784］ 的张量，第一个维度数字用来索引图片，第二个维度数字用来索引每张图片中的像素点。在此张量里的每一个元素，都表示某张图片里的某个像素的强度值，值介于0和1之间。

　　相对应的 MNIST 数据集的标签是介于0到9的数字，用来描述给定图片里表示的数字。为了用于这个教程，我们使标签数据是“one-hot vectors”。 一个 one-hot 向量除了某一位的数字是1以外其余各维度数字都是0.所以在此教程中，数字n将表示成一个只有在第n维度（从0开始）数字为1的10维向量。比如，标签0将表示成（［1，0，0，0，0，0，0，0，0，0，0］）。因此， mnist.train.labels 是一个 ［60000， 10］ 的数字矩阵。

　　使用tensorflow导入已经下载好的mnist数据集
　　导入相应的库，并且导入数据（当前文件夹下没有MNIST库的话会自动下载）；
　　fromtensorflow.examples.tutorials.mnistimportinput_data
　　#读取数据
　　mnist=input_data.read_data_sets（‘MNIST_data/’，one_hot=True）
　　运行结果：
　　ExtractingMNIST_datatrain-images-idx3-ubyte.gzExtractingMNIST_datatrain-labels-idx1-ubyte.gzExtractingMNIST_datat10k-images-idx3-ubyte.gzExtractingMNIST_datat10k-labels-idx1-ubyte.gz
　　让我们看一下数据集里面的数据情况：
　　print（“MNIST的数据类型是：”，type（mnist））
　　print（“训练数据集的个数是：”，mnist.train.num_examples）
　　print（“测试数据集的个数是：”，mnist.test.num_examples）
　　运行结果：
　　MNIST的数据类型是：《class‘tensorflow.contrib.learn.python.learn.datasets.base.Datasets’》训练数据集的个数是：55000测试数据集的个数是：10000
　　trainimg=mnist.train.images
　　trainlabel=mnist.train.labels
　　testimg=mnist.test.images
　　testlabel=mnist.test.labels
　　print（“训练数据的类型：”，type（trainimg））
　　print（“训练数据标签的类型：”，type（trainlabel））
　　print（“测试数据的类型：”，type（testimg））
　　print（“测试数据标签的类型：”，type（testlabel））
　　print（“训练数据的形状：”，trainimg.shape）
　　print（“训练数据标签的形状：”，trainlabel.shape）
　　print（“测试数据的形状：”，testimg.shape）
　　print（“测试数据标签的形状：”，testlabel.shape）
　　batch=mnist.train.next_batch（50）
　　print（“batch的数据类型：”，type（batch））
　　print（“batch［0］的形状：”，batch［0］.shape）
　　print（“batch［1］的形状：”，batch［1］.shape）
　　运行结果：
　　训练数据的类型：《class‘numpy.ndarray’》训练数据标签的类型：《class‘numpy.ndarray’》测试数据的类型：《class‘numpy.ndarray’》测试数据标签的类型：《class‘numpy.ndarray’》训练数据的形状：（55000，784）训练数据标签的形状：（55000，10）测试数据的形状：（10000，784）测试数据标签的形状：（10000，10）
　　batch的数据类型：《class‘tuple’》batch［0］的形状：（50，784）batch［1］的形状：（50，10）

　　Tensorflow实现MNIST的手写数字识别
　　CNN.py
　　importtensorflowastf
　　#定义CNN网络结构
　　defCNN（input_tensor，keep_prob）：
　　#C1是卷积层，Input=［batch，28，28，1］，output=［batch，28，28，32］，W=［3，3，1，32］，S=［1，1，1，1］
　　conv1_w=tf.Variable（tf.truncated_normal（［3，3，1，32］，stddev=0.1））#1
　　conv1_b=tf.Variable（tf.constant（0，1，shape=［32］））#1
　　conv1=tf.nn.conv2d（input_tensor，conv1_w，strides=［1，1，1，1］，padding=‘SAME’）+conv1_b#2
　　conv1=tf.nn.relu（conv1）
　　#S2是池化层，Input=［batch，28，28，32］，output=［batch，14，14，32］，Ksize=［1，2，2，1］，S=［1，2，2，1］
　　pool_1=tf.nn.max_pool（conv1，ksize=［1，2，2，1］，strides=［1，2，2，1］，padding=‘SAME’）#2
　　#C3是卷积层，Input=［batch，14，14，32］，output=［batch，14，14，50］，W=［3，3，32，50］，S=［1，1，1，1］
　　conv2_w=tf.Variable（tf.truncated_normal（［3，3，32，50］，stddev=0.1））
　　conv2_b=tf.Variable（tf.constant（0.1，shape=［50］））
　　conv2=tf.nn.conv2d（pool_1，conv2_w，strides=［1，1，1，1］，padding=‘SAME’）+conv2_b
　　conv2=tf.nn.relu（conv2）
　　#S4是池化层，Input=［batch，14，14，32］，output=［batch，7，7，50］，Ksize=［1，2，2，1］，S=［1，2，2，1］
　　pool_2=tf.nn.max_pool（conv2，ksize=［1，2，2，1］，strides=［1，2，2，1］，padding=‘SAME’）
　　#F5是全连接层，Input=［batch，7，7，50］，output=［batch，1024］
　　fc1_w=tf.Variable（tf.truncated_normal（［7*7*50，1024］，stddev=0.1））
　　fc1_b=tf.Variable（tf.constant（0.1，shape=［1024］））
　　pool_2_flat=tf.reshape（pool_2，［-1，7*7*50］）
　　fc1=tf.nn.relu（tf.matmul（pool_2_flat，fc1_w）+fc1_b）
　　#dropout（随机权重失活）
　　fc1_drop=tf.nn.dropout（fc1，keep_prob=keep_prob）#3
　　#F6是全连接层，Input=［batch，1024］，output=［batch，10］
　　fc2_w=tf.Variable（tf.truncated_normal（［1024，10］，stddev=0.1））
　　fc2_b=tf.Variable（tf.constant（0.1，shape=［10］））
　　y_out=tf.nn.softmax（tf.matmul（fc1_drop，fc2_w）+fc2_b）#4
　　returny_out
　　CNN_main.py
　　importtensorflowastf
　　importnumpyasnp
　　fromtensorflow.examples.tutorials.mnistimportinput_data
　　importCNN
　　#读取数据
　　mnist=input_data.read_data_sets（‘MNIST_data’，one_hot=True）
　　sess=tf.InteractiveSession（）#5
　　#设置占位符，尺寸为样本输入和输出的尺寸
　　x=tf.placeholder（tf.float32，［None，784］）#6
　　y_=tf.placeholder（tf.float32，［None，10］）
　　x_img=tf.reshape（x，［-1，28，28，1］）
　　keep_prob=tf.placeholder（tf.float32）
　　#用自己构建的神经网络得到预测结果
　　y_out=CNN.CNN（x_img，keep_prob）
　　#建立lossfunction，为交叉熵
　　cross_entropy=-tf.reduce_sum（y_*tf.log（y_out））#损失函数#7
　　loss=tf.reduce_mean（cross_entropy，reduction_indices=［1］））
　　#配置Adam优化器，学习速率为0.0001
　　train_step=tf.train.AdamOptimizer（1e-4）.minimize（loss）#8
　　#建立正确率计算表达式
　　correct_prediction=tf.equal（tf.argmax（y_out，1），tf.argmax（y_，1））#9
　　accuracy=tf.reduce_mean（tf.cast（correct_prediction，tf.float32））
　　#开始喂数据，训练
　　tf.global_variables_initializer（）.run（）
　　foriinrange（2000）：
　　batch=mnist.train.next_batch（50）
　　ifi%100==0：
　　train_accurcy=accuracy.eval（feed_dict={x:batch［0］，y_:batch［1］，keep_prob:1}）
　　print（“step%d，train_accurcy=%g”%（i，train_accurcy））
　　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.9707#10