posts - 109,  comments - 12,  trackbacks - 0

图片样本可视化

原文第四篇中,我们介绍了官方的入门案例MNIST,功能是识别手写的数字0-9。这是一个非常基础的TensorFlow应用,地位相当于通常语言学习的"Hello World!"。
我们先不进入TensorFlow 2.0中的MNIST代码讲解,因为TensorFlow 2.0在Keras的帮助下抽象度比较高,代码非常简单。但这也使得大量的工作被隐藏掉,反而让人难以真正理解来龙去脉。特别是其中所使用的样本数据也已经不同,而这对于学习者,是非常重要的部分。模型可以看论文、在网上找成熟的成果,数据的收集和处理,可不会有人帮忙。
在原文中,我们首先介绍了MNIST的数据结构,并且用一个小程序,把样本中的数组数据转换为JPG图片,来帮助读者理解原始数据的组织方式。
这里我们把小程序也升级一下,直接把图片显示在屏幕上,不再另外保存JPG文件。这样图片看起来更快更直观。
在TensorFlow 1.x中,是使用程序input_data.py来下载和管理MNIST的样本数据集。当前官方仓库的master分支中已经取消了这个代码,为了不去翻仓库,你可以在这里下载,放置到你的工作目录。
在TensorFlow 2.0中,会有keras.datasets类来管理大部分的演示和模型中需要使用的数据集,这个我们后面再讲。
MNIST的样本数据来自Yann LeCun的项目网站。如果网速比较慢的话,可以先用下载工具下载,然后放置到自己设置的数据目录,比如工作目录下的data文件夹,input_data检测到已有数据的话,不会重复下载。
下面是我们升级后显示训练样本集的源码,代码的讲解保留在注释中。如果阅读有疑问的,建议先去原文中看一下样本集数据结构的图示部分:

#!/usr/bin/env python3

# 引入mnist数据预读准备库
# 2.0之后建议直接使用官方的keras.datasets.mnist.load_data
# 此处为了同以前的讲解对比,沿用之前的引用文件
import input_data
# tensorflow 2.0库
import tensorflow as tf
# 引入绘图库
import matplotlib.pyplot as plt

# 这里使用mnist数据预读准备库检查给定路径是已经有样本数据,
# 没有的话去网上下载,并保存在指定目录
# 已经下载了数据的话,将数据读入内存,保存到mnist对象中
mnist = input_data.read_data_sets("data/", one_hot=True)

# 样本集的结构如下:
# mnist.train 训练数据集
# mnist.validation 验证数据集
# mnist.test 测试数据集
# len(mnist.train.images)=55000
# len(mnist.train.images[0])=784
# len(mnist.train.labels[0])=10


def plot_image(i, imgs, labels):
    # 将1维的0-1的数据转换为标准的0-255的整数数据,2维28x28的图片
    image = tf.floor(256.0 * tf.reshape(imgs[i], [28, 28]))
    # 原数据为float,转换为uint8字节数据
    image = tf.cast(image, dtype=tf.uint8)
    # 标签样本为10个字节的数组,为1的元素下标就是样本的标签值
    # 这里使用argmax方法直接转换为0-9的整数
    label = tf.argmax(labels[i])
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])
    # 绘制样本图
    plt.imshow(image)
    # 显示标签值
    plt.xlabel("{}".format(label))


def show_images(num_rows, num_cols, images, labels):
    num_images = num_rows*num_cols
    plt.figure('Train Samples', figsize=(2*num_cols, 2*num_rows))
    # 循环显示前num_rows*num_cols副样本图片
    for i in range(num_images):
        plt.subplot(num_rows, num_cols, i+1)
        plot_image(i, images, labels)
    plt.show()

# 显示前4*6=24副训练集样本
show_images(4, 6, mnist.train.images, mnist.train.labels)

注意这个代码只是用来把样本集可视化。TensorFlow 2.0新特征,在这里只体现了取消Session和Session.run()。目的只是为了延续原来的讲解,让图片直接显示而不是保存为图像文件,以及升级到Python3和TensorFlow 2.0的执行环境。
样本集显示出来效果是这样的:

TensorFlow 2.0中的模型构建

原文第四篇中,我们使用了一个并不实用的线性回归模型来做手写数字识别。这样做可以简化中间层,从而能够使用可视化的手段来讲解机器视觉在数学上的基本原理。因为线性回归模型我们在本系列第一篇中讲过了,这里就跳过,直接说使用神经网络来解决MNIST问题。
神经网络模型的构建在TensorFlow 1.0中是最繁琐的工作。我们曾经为了讲解vgg-19神经网络的使用,首先编写了一个复杂的辅助类,用于从字符串数组的遍历中自动构建复杂的神经网络模型。
而在TensorFlow 2.0中,通过高度抽象的keras,可以非常容易的构建神经网络模型。
为了帮助理解,我们先把TensorFlow 1.0中使用神经网络解决MNIST问题的代码原文粘贴如下:

#!/usr/bin/env python
# -*- coding=UTF-8 -*-

import input_data
mnist = input_data.read_data_sets('data/', one_hot=True)

import tensorflow as tf
sess = tf.InteractiveSession()

#对W/b做初始化有利于防止算法陷入局部最优解,
#文档上讲是为了打破对称性和防止0梯度及神经元节点恒为0等问题,数学原理是类似问题
#这两个初始化单独定义成子程序是因为多层神经网络会有多次调用
def weight_variable(shape):
    #填充“权重”矩阵,其中的元素符合截断正态分布
    #可以有参数mean表示指定均值及stddev指定标准差
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)
def bias_variable(shape):
    #用0.1常量填充“偏移量”矩阵
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)


#定义占位符,相当于tensorFlow的运行参数,
#x是输入的图片矩阵,y_是给定的标注标签,有标注一定是监督学习
x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape=[None, 10])

#定义输入层神经网络,有784个节点,1024个输出,
#输出的数量是自己定义的,要跟第二层节点的数量吻合
W1 = weight_variable([784, 1024])
b1 = bias_variable([1024])
#使用relu算法的激活函数,后面的公式跟前一个例子相同
h1 = tf.nn.relu(tf.matmul(x, W1) + b1)

#定义第二层(隐藏层)网络,1024输入,512输出
W2 = weight_variable([1024, 512])
b2 = bias_variable([512])
h2 = tf.nn.relu(tf.matmul(h1, W2) + b2)

#定义第三层(输出层),512输入,10输出,10也是我们希望的分类数量
W3 = weight_variable([512, 10])
b3 = bias_variable([10])
#最后一层的输出同样用softmax分类(也算是激活函数吧)
y3=tf.nn.softmax(tf.matmul(h2, W3) + b3)

#交叉熵代价函数
cross_entropy = -tf.reduce_sum(y_*tf.log(y3))
#这里使用了更加复杂的ADAM优化器来做"梯度最速下降",
#前一个例子中我们使用的是:GradientDescentOptimizer
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#计算正确率以评估效果
correct_prediction = tf.equal(tf.argmax(y3,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#tf初始化及所有变量初始化
sess.run(tf.global_variables_initializer())
#进行20000步的训练
for i in range(20000):
    #每批数据50组
  batch = mnist.train.next_batch(50)
  #每100步进行一次正确率计算并显示中间结果
  if i%100 == 0:
    train_accuracy = accuracy.eval(feed_dict={
        x:batch[0], y_: batch[1]})
    print "step %d, training accuracy %g"%(i, train_accuracy)
    #使用数据集进行训练
  train_step.run(feed_dict={x: batch[0], y_: batch[1]})

#完成模型训练给出最终的评估结果
print "test accuracy %g"%accuracy.eval(feed_dict={
    x: mnist.test.images, y_: mnist.test.labels})

总结一下上面TensorFlow 1.x版本MNIST代码中的工作:

  • 使用了一个三层的神经网络,每一层都使用重复性的代码构建
  • 每一层的代码中,要精心计算输入和输出数据的格式、维度,使得每一层同上、下两层完全吻合
  • 精心设计损失函数(代价函数)和选择回归算法
  • 复杂的训练循环

如果你理解了我总结的这几点,请继续看TensorFlow 2.0的实现:

#!/usr/bin/env python3

# 引入mnist数据预读准备库
# 2.0之后建议直接使用官方的keras.datasets.mnist.load_data
# 此处为了同以前的讲解对比,沿用之前的引用文件
import input_data
# tensorflow库
import tensorflow as tf
# tensorflow 已经内置了keras
from tensorflow import keras
# 引入绘图库
import matplotlib.pyplot as plt

# 这里使用mnist数据预读准备库检查给定路径是已经有样本数据,
# 没有的话去网上下载,并保存在指定目录
# 已经下载了数据的话,将数据读入内存,保存到mnist对象中
mnist = input_data.read_data_sets("data/", one_hot=True)

# 样本集的结构如下:
# mnist.train 训练数据集
# mnist.validation 验证数据集
# mnist.test 测试数据集
# len(mnist.train.images)=55000
# len(mnist.train.images[0])=784
# len(mnist.train.labels[0])=10


def plot_image(i, imgs, labels, predictions):
    # 将1维的0-1的数据转换为标准的0-255的整数数据,2维28x28的图片
    image = tf.floor(256.0 * tf.reshape(imgs[i], [28, 28]))
    # 原数据为float,转换为uint8字节数据
    image = tf.cast(image, dtype=tf.uint8)
    # 标签样本为10个字节的数组,为1的元素下标就是样本的标签值
    # 这里使用argmax方法直接转换为0-9的整数
    label = tf.argmax(labels[i])
    prediction = tf.argmax(predictions[i])
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])
    # 绘制样本图
    plt.imshow(image)
    # 显示标签值,对比显示预测值和实际标签值
    plt.xlabel("predict:{} label:{}".format(prediction, label))


def show_images(num_rows, num_cols, images, labels, predictions):
    num_images = num_rows*num_cols
    plt.figure('Predict Samples', figsize=(2*num_cols, 2*num_rows))
    # 循环显示前num_rows*num_cols副样本图片
    for i in range(num_images):
        plt.subplot(num_rows, num_cols, i+1)
        plot_image(i, images, labels, predictions)
    plt.show()

# 原文中已经说明了,当前是10个元素数组表示一个数字,
# 值为1的那一元素的索引就是代表的数字,这是分类算法决定的
# 下面是直接转换为0-9的正整数,用作训练的标签
train_labels = tf.argmax(mnist.train.labels, 1)

# 定义神经网络模型
model = keras.Sequential([
    # 输入层为28x28共784个元素的数组,节点1024个
    keras.layers.Dense(1024, activation='relu', input_shape=(784,)),
    keras.layers.Dense(512, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])
# 编译模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
# 使用训练集数据训练模型
model.fit(mnist.train.images, train_labels, epochs=3)

# 测试集的标签同样转成0-9数字
test_labels = tf.argmax(mnist.test.labels, 1)
# 使用测试集样本验证识别准确率
test_loss, test_acc = model.evaluate(mnist.test.images, test_labels)
print('\nTest accuracy:', test_acc)

# 完整预测测试集样本
predictions = model.predict(mnist.test.images)
# 图示结果的前4*6个样本
show_images(4, 6, mnist.test.images, mnist.test.labels, predictions)

代码讲解

通常我都是直接在注释中对程序做仔细的讲解,这次例外一下,因为我们需要从大局观上看清楚代码的结构。
这几行代码是定义神经网络模型:

# 定义神经网络模型
model = keras.Sequential([
    # 输入层为28x28共784个元素的数组,节点1024个
    keras.layers.Dense(1024, activation='relu', input_shape=(784,)),
    keras.layers.Dense(512, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

每一行实际就代表一层神经网络的节点。在第一行中特别指明了输入数据的形式,即可以有未知数量的样本,每一个样本784个字节(28x28)。实际上这个输入样本可以不指定形状,在没有指定的情况下,Keras会自动识别训练数据集的形状,并自动将模型输入匹配到训练集形状。只是这种习惯并不一定好,除了效率问题,当样本集出错的时候,模型的定义也无法帮助开发者提前发现问题。所以建议产品化的模型,应当在模型中指定输入数据类型。
除了第一层之外,之后的每一层都无需指定输入样本形状。Keras会自动匹配相邻两个层的数据。这节省了开发人员大量的手工计算也不易出错。
最后,激活函数的选择成为一个参数。整体代码看上去简洁的令人惊讶。

接着在编译模型的代码中,直接指定Keras中预定义的“sparse_categorical_crossentropy”损失函数和“adam”优化算法。一个函数配合几个参数选择就完成了这部分工作:

# 编译模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

对原本复杂的训练循环部分,TensorFlow 2.0优化的最为彻底,只有一行代码:

# 使用训练集数据训练模型
model.fit(mnist.train.images, train_labels, epochs=3)

使用测试集数据对模型进行评估同样只需要一行代码,这里就不摘出来了,在上面完整代码中能看到。
可以想象,TensorFlow 2.0正式发布后,模型搭建、训练、评估的工作量大幅减少,会催生很多由实验性模型创新而出现的新算法。机器学习领域会再次涌现普及化浪潮。
这一版代码中,我们还细微修改了样本可视化部分的程序,将原来显示训练集样本,改为显示测试集样本。主要是增加了一个图片识别结果的参数。将图片的识别结果同数据集的标注一同显示在图片的下面作为对比。
程序运行的时候,控制台输出如下:

$ python3 mnist-show-predict-pic-v1.py 
Extracting data/train-images-idx3-ubyte.gz
Extracting data/train-labels-idx1-ubyte.gz
Extracting data/t10k-images-idx3-ubyte.gz
Extracting data/t10k-labels-idx1-ubyte.gz
Epoch 1/3
55000/55000 [==============================] - 17s 307us/sample - loss: 0.1869 - accuracy: 0.9420
Epoch 2/3
55000/55000 [==============================] - 17s 304us/sample - loss: 0.0816 - accuracy: 0.9740
Epoch 3/3
55000/55000 [==============================] - 16s 298us/sample - loss: 0.0557 - accuracy: 0.9821
10000/10000 [==============================] - 1s 98us/sample - loss: 0.0890 - accuracy: 0.9743

Test accuracy: 0.9743

最终的结果表示,模型通过3次的训练迭代之后。使用测试集数据进行验证,手写体数字识别正确率为97.43%。
程序最终会显示测试集前24个图片及预测结果和标注信息的对比:

(待续...)

posted on 2019-04-10 12:49 俺踏月色而来 阅读(...) 评论(...) 编辑 收藏