21个项目玩转深度学习：基于TensorFlow的实践详解01

数据集

由Yann Le Cun建立，训练集55000，验证集5000，测试集10000，图片大小均为28*28

下载

# coding:utf-8

# 从tensorflow.examples.tutorials.mnist引入模块。这是TensorFlow为了教学MNIST而提前编制的程序

from tensorflow.examples.tutorials.mnist import input_data

# 从MNIST_data/中读取MNIST数据。这条语句在数据不存在时，会自动执行下载

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

# 查看训练数据的大小

print(mnist.train.images.shape)  # (55000, 784)

print(mnist.train.labels.shape)  # (55000, 10)

# 查看验证数据的大小

print(mnist.validation.images.shape)  # (5000, 784)

print(mnist.validation.labels.shape)  # (5000, 10)

# 查看测试数据的大小

print(mnist.test.images.shape)  # (10000, 784)

print(mnist.test.labels.shape)  # (10000, 10)

# 打印出第0幅图片的向量表示

print(mnist.train.images[0, :])

# 打印出第0幅图片的标签

print(mnist.train.labels[0, :])

train-images-idx3-ubyte.gz	9.45 MB	训练图像数据
train-labels-idx1-ubyte.gz	0.03MB	训练图像的标签
t10k-images-idx3-ubyte.gz	1.57MB	测试图像数据
t10k-labels-idxl-ubyte.gz	4.4KB	测试图像的标签

存成图片

#coding: utf-8

from tensorflow.examples.tutorials.mnist import input_data

import scipy.misc

import os

# 读取MNIST数据集。如果不存在会事先下载。

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

# 我们把原始图片保存在MNIST_data/raw/文件夹下

# 如果没有这个文件夹会自动创建

save_dir = 'MNIST_data/raw/'

if os.path.exists(save_dir) is False:

    os.makedirs(save_dir)

# 保存前20张图片

for i in range(20):

    # 请注意，mnist.train.images[i, :]就表示第i张图片（序号从0开始）

    image_array = mnist.train.images[i, :]

    # TensorFlow中的MNIST图片是一个784维的向量，我们重新把它还原为28x28维的图像。

    image_array = image_array.reshape(28, 28)

    # 保存文件的格式为 mnist_train_0.jpg, mnist_train_1.jpg, ... ,mnist_train_19.jpg

    filename = save_dir + 'mnist_train_%d.jpg' % i

    # 将image_array保存为图片

    # 先用scipy.misc.toimage转换为图像，再调用save直接保存。

    scipy.misc.toimage(image_array, cmin=0.0, cmax=1.0).save(filename)

print('Please check: %s ' % save_dir)

识别

softmax回归

简单的把图像flatten了，没考虑位置等信息，代码如下（熟悉一下tensorflow的使用流程）：

# coding:utf-8

# 导入tensorflow

# 这句import tensorflow as tf是导入TensorFlow约定俗成的做法，请大家记住。

import tensorflow as tf

# 导入MNIST教学的模块

from tensorflow.examples.tutorials.mnist import input_data

# 与之前一样，读入MNIST数据

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

# 创建x，x是一个占位符（placeholder），代表待识别的图片

x = tf.placeholder(tf.float32, [None, 784])

# W是Softmax模型的参数，将一个784维的输入转换为一个10维的输出

# 在TensorFlow中，变量的参数用tf.Variable表示

W = tf.Variable(tf.zeros([784, 10]))

# b是又一个Softmax模型的参数，我们一般叫做“偏置项”（bias）。

b = tf.Variable(tf.zeros([10]))

# y=softmax(Wx + b)，y表示模型的输出

y = tf.nn.softmax(tf.matmul(x, W) + b)

# y_是实际的图像标签，同样以占位符表示。

y_ = tf.placeholder(tf.float32, [None, 10])

# 至此，我们得到了两个重要的Tensor：y和y_。

# y是模型的输出，y_是实际的图像标签，不要忘了y_是独热表示的

# 下面我们就会根据y和y_构造损失

# 根据y, y_构造交叉熵损失

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y)))

# 有了损失，我们就可以用随机梯度下降针对模型的参数（W和b）进行优化

train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

# 创建一个Session。只有在Session中才能运行优化步骤train_step。

sess = tf.InteractiveSession()

# 运行之前必须要初始化所有变量，分配内存。

tf.global_variables_initializer().run()

print('start training...')

# 进行1000步梯度下降

for _ in range(1000):

    # 在mnist.train中取100个训练数据

    # batch_xs是形状为(100, 784)的图像数据，batch_ys是形如(100, 10)的实际标签

    # batch_xs, batch_ys对应着两个占位符x和y_

    batch_xs, batch_ys = mnist.train.next_batch(100)

    # 在Session中运行train_step，运行时要传入占位符的值

    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

# 正确的预测结果

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))

# 计算预测准确率，它们都是Tensor

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 在Session中运行Tensor可以得到Tensor的值

# 这里是获取最终模型的正确率

print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))  # 0.9185

两层卷积网络

# coding: utf-8

import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data

def weight_variable(shape):

    initial = tf.truncated_normal(shape, stddev=0.1)

    return tf.Variable(initial)

def bias_variable(shape):

    initial = tf.constant(0.1, shape=shape)

    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')

if __name__ == '__main__':

    # 读入数据

    mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

    # x为训练图像的占位符、y_为训练图像标签的占位符

    x = tf.placeholder(tf.float32, [None, 784])

    y_ = tf.placeholder(tf.float32, [None, 10])

    # 将单张图片从784维向量重新还原为28x28的矩阵图片

    x_image = tf.reshape(x, [-1, 28, 28, 1])

    # 第一层卷积层

    W_conv1 = weight_variable([5, 5, 1, 32])

    b_conv1 = bias_variable([32])

    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

    h_pool1 = max_pool_2x2(h_conv1)

    print(h_pool1.get_shape())

    # 第二层卷积层

    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)

    print(h_pool2.get_shape())

    # 全连接层，输出为1024维的向量

    W_fc1 = weight_variable([7 * 7 * 64, 1024])

    b_fc1 = bias_variable([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)

    # 使用Dropout，keep_prob是一个占位符，训练时为0.5，测试时为1

    keep_prob = tf.placeholder(tf.float32)

    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    # 把1024维的向量转换成10维，对应10个类别

    W_fc2 = weight_variable([1024, 10])

    b_fc2 = bias_variable([10])

    y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

    # 我们不采用先Softmax再计算交叉熵的方法，而是直接用tf.nn.softmax_cross_entropy_with_logits直接计算

    cross_entropy = tf.reduce_mean(

        tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))

    # 同样定义train_step

    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, tf.float32))

    # 创建Session和变量初始化

    sess = tf.InteractiveSession()

    sess.run(tf.global_variables_initializer())

    # 训练20000步

    for i in range(20000):

        batch = mnist.train.next_batch(50)

        # 每100步报告一次在验证集上的准确度

        if i % 100 == 0:

            train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0})

            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}))

运行结果：

root@node5 chapter_01]# python convolutional.py

Extracting MNIST_data/train-images-idx3-ubyte.gz

Extracting MNIST_data/train-labels-idx1-ubyte.gz

Extracting MNIST_data/t10k-images-idx3-ubyte.gz

Extracting MNIST_data/t10k-labels-idx1-ubyte.gz

(?, 14, 14, 32)

(?, 7, 7, 64)

2018-10-30 12:39:14.394778: I tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supportsinstructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA

step 0, training accuracy 0.06

step 100, training accuracy 0.9

step 200, training accuracy 0.92

step 300, training accuracy 0.96

step 400, training accuracy 0.92

step 500, training accuracy 0.94

step 600, training accuracy 0.9

...

...

step 19300, training accuracy 1

step 19400, training accuracy 1

step 19500, training accuracy 1

step 19600, training accuracy 1

step 19700, training accuracy 1

step 19800, training accuracy 1

step 19900, training accuracy 1

test accuracy 0.9919

拓展阅读

- 本章介绍的MNIST 数据集经常被用来检验机器学习模型的性能，在它的官网（地址：http://yann.lecun.com/exdb/mnist/ ）中，可以找到多达68 种模型在该数据集上的准确率数据，包括相应的论文出处。这些模型包括线性分类器、K 近邻方法、普通的神经网络、卷积神经网络等。
- 本章的两个MNIST 程序实际上来自于TensorFlow 官方的两个新手教程，地址为https://www.tensorflow.org/get_started/mnist/beginners 和 https://www.tensorflow.org/get_started/mnist/pros 。读者可以将本书的内容和官方的教程对照起来进行阅读。这两个新手教程的中文版地址为http://www.tensorfly.cn/tfdoc/tutorials/mnist_beginners.html 和http://www.tensorfly.cn/tfdoc/tutorials/mnist_pros.html。
- 本章简要介绍了TensorFlow 的tf.Tensor 类。tf.Tensor 类是TensorFlow的核心类，常用的占位符（tf.placeholder）、变量（tf.Variable）都可以看作特殊的Tensor。读者可以参阅https://www.tensorflow.org/programmers_guide/tensors来更深入地学习它的原理。
- 常用tf.Variable 类来存储模型的参数，读者可以参阅https://www.tensorflow.org/programmers_guide/variables详细了解它的运行机制，文档的中文版地址为http://www.tensorfly.cn/tfdoc/how_tos/ variables.html。
- 只有通过会话（Session）才能计算出tf.Tensor 的值。强烈建议读者在学习完tf.Tensor 和tf.Variable 后，阅读https://www.tensorflow.org/programmers_guide/graphs 中的内容，该文档描述了TensorFlow 中计算图和会话的基本运行原理，对理解TensorFlow 的底层原理有很大帮助。