机器学习零基础？手把手教你用TensorFlow搭建图像识别系统

转] http://www.leiphone.com/news/201701/Y4uyEktkkwb5YhJM.html
http://www.leiphone.com/news/201701/2tH3DgLmsGhnDd8D.html
导语：这是Wolfgang Beyer的一篇博文，详细介绍了如何使用TensorFlow搭建一个简单的图像识别系统。本篇主要介绍图像识别和本试验中会遇到的一些概念。



如果你觉得这是一篇简单介绍人工智能、机器学习和深度学习的文章，那就错啦。你可以在网上搜罗到一大堆相关话题的文章，而这篇文章也并不是讨论人工智能是否会奴役人类或抢走人们饭碗之类的话题，毕竟相关的各种推论和谣言已经满天飞了。

这只是一篇详细描述如何开始搭建一个机器学习系统，并让它可以识别所看到图像的文章。

作者Wolfgang Beyer目前现在正在学习人工智能和机器学习的内容。他认为最好的学习方式不是仅仅阅读各类材料，而是要真正地去动手搭建一个系统。这就是雷锋网翻译本文的目的，也是作者要向你介绍的。在这篇文章中Beyer将向你展示如何搭建一个系统，去完成一项简单的计算机视觉任务：识别图像内容。

Beyer强调，他并不是一个专家。“我正在学习，而且还有很多东西需要学习。我只是简单介绍我正在做的事情。如果这对你能有所帮助，或者你也觉得很有趣，就已经很好了。如果你发现了错误或有什么改进建议也请告诉我，你的回复对我也很重要。”

阅读本文前你并不需要具备机器学习的相关经验。示例代码是使用Python写的，如果你有Python的基础知识是最好的。但如果你只是掌握其他的编程语言，那也已经足够了。由于篇幅限制，本系列将分四篇文章发布，雷锋网编译，未经许可不得转载。

为什么让机器学会图像识别？

图像识别是开发和测试机器学习的一项重要任务，因为视觉可能是最重要的一项感知能力。虽然对于人类来说，它是与生俱来的。但它是怎么实现的？大脑是怎样将视网膜上的图像转化成我们对周围环境的心智模式的？我想没人能对此一清二楚。关键是，对我们来说这看起来如此简单——我们不需要有意识地去做这件事，而对于计算机来说却困难重重（事实上，对我们来说也并不是看上去那么简单。只是我们并没有意识到进行了多少工作。有超过一半的大脑区域直接或间接参与了视觉活动）。

在我们甚至都不知道自己怎么看到东西的情况下，怎么让计算机去做到这样的事情呢？这就是机器学习要研究的事情。我们采取的方法是让计算机自己去完成这样的过程，而不是手把手地一步步教会计算机如何解释图像并翻译成计算机程序。我们给计算机提供总体结构，让计算机从经验中学习，就像我们人类做的那样。

但是，在我们开始构想计算机视觉的整体方案之前，让我们把这个任务简化为一个容易掌握的小目标。

图像分类和CIFAR-10数据集

我们尝试解决一个尽可能小而简单的问题，另外也不要期望它能瞬间让我们成为机器学习大师。我们希望计算机能做的包括以下方面：当我们向计算机展示一幅图片（特定尺寸）时，它能够对图片进行分析并打上标签。他可以从固定数量的标签中进行选择，每一类的标签描述了一种图像的内容。我们的目标就是这个模型能够尽可能地挑选出正确的标签。这个任务被称作图像分类。

我们将使用标准的CIFAR-10数据集。CIFAR-10包含了60000幅图片。它有10个不同的分类，每类包含6000幅图片。每幅图片的规格是32x32像素。这么小尺寸的图片对我们人类来说有时很难进行正确的分类，但它却简化了计算机模型的任务，并降低了分析图片的计算负载。



CIFAR-10数据集中10个分类中的随机图片。由于分辨率低，人类很难进行正确的标签。

我们将图片转化为一连串的数字输送给计算模型。每个像素由代表红色，绿色和蓝色的三个浮点数来表示。其结果就是32x32x3=3072个值。

除了CIFAR-10，还有很多其他的图像数据集可以用于计算机视觉的研究。之所以使用标准数据集，有两个目的：

第一，要收集这么多的图片是一项巨大的工作。你需要有大量的图片资源，并根据需要对他们进行分别标签。

第二，使用相同的数据集，可以让我们有目的地比较不同方法的优劣。

另外，使用标准数据集，可以相互比较，在竞赛中排出名次。最有名的比赛是Image-Net图像识别大赛，它需要对1000个不同的种类进行识别。2012年的胜者是来自多伦多大学（University of Toronto）的亚力克斯•克利则夫斯基（Alex Krizhevsky），伊利亚·苏特斯科娃（Ilya Sutskever）和杰夫·辛顿（Geoffrey Hinton）设计的算法（雷锋网注：可点击论文链接查看）。这个系统领跑整个比赛并且以巨大的优势获胜。

这次比赛对整个研究领域产生了巨大的冲击，因为这是第一次使用卷积神经网络的方法获得胜利。卷积神经网络是一种人工神经网络，它大致模拟了动物视觉的皮质行为。这一技术的应用已经有一段时间，但它的潜力还没被多数人认识到。2012
Image-Net竞赛后，这种情况出现了改变。人们突然对神经网络和深度学习（深度学习是使用多层神经网络的方法解决机器学习的问题）产生了巨大兴趣，而这次赛事也极大地推动了以后几年深度学习的快速发展。

监督学习

我们怎么使用图像数据集让计算机自己学习呢？即使计算机自己能够学习，我们也需要告诉它学习什么和怎样学习。所以，我们需要通过制定一个大致的流程让计算机能够对图像进行评估。

我们定义一个通用的数学模型，将输入图像转换为输出标签。这个模型的实际输出不仅仅依赖于图像本身，还依赖模型内建的参数。这些参数并不是由我们提供，而是由计算机通过学习获得。

这样一来，这个过程可以被理解为一个优化问题。我们初始定义一个模型并提供初始的参数值。然后再向模型输入图像数据集和已知的正确标签。这就是训练的过程。在这个阶段模型重复校验，训练数据，持续调整参数值。目标是找到合适的参数使模型输出尽可能多的正确结果。这种同时使用输入数据和正确结果的训练方法叫做监督学习。还有一种叫做非监督学习，这种学习中只使用了输入数据而没有标签，但在这篇文章中我们不做讨论。

当训练完成，模型参数被固定下来，并可以被用于图像集以外的图像分类。



在训练期间，模型的预测结果与真实值进行比较。这些信息被用于更新参数值。在测试过程中就不再有反馈，模型只是产生标签。

TensorFlow

TensorFlow是机器学习的开源软件库，它由Google在2015年发布并很快成为全世界的研究者和学习者中最流行的机器学习库之一。它在图像分类模型中承担重要作用。

接下来，我们就要开始学习如何用TensorFlow搭建一个合适的模型。

建立模型，一个Softmax分类器

Github支持这个模型的完整代码。在使用之前，你需要安装以下软件：

· Python(代码经过了Python2.7测试，Python3.3+也应该可以工作，安装链接）

·  TensorFlow（安装指导链接）

·  CIFAR-10数据集：下载Python版本的数据集

 从https://www.cs.toronto.edu/~kriz/cifar.html下载或者使用链接中的压缩文档。请把 cifar-10-batches-py解压到python源代码的目录下，这样图像的路径应该为/Path-to-your-python-source-code-files/cifar-10-batches-py/。

 好了，现在我们可以开始了。让我们先来看看试验的主文件softmax.py，一行一行地来分析：

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import numpy as np

import tensorflow as tf

import time

import data_helpers

根据TensorFlow代码规范，在所有TensorFlow Python文件中为了Python2和3的兼容性，都应该添加future语句。然后导入TensorFlow，numpy用于数值计算和时间模块。data_helper.py包括加载和准备数据集的函数。

beginTime = time.time()

 # Parameter definitions

batch_size = 100

learning_rate = 0.005

max_steps = 1000

 

# Prepare data

data_sets = data_helpers.load_data()

我们启动一个计时器测量运行时间和定义一些参数。稍后在实际使用它们时再进行讨论。然后加载CIFAR-10数据集。因为读取数据并不是我们要做的核心，我把这部分的函数单独放在data_helper.py文件中。它只是负责读取包含数据集的文件，并把数据放入一个方便我们操作的数据结构中。

需要提到的重要的一点是，load_data()是将60000幅图像分为两部分。大的一部分包含50000幅图像。这些数据集用于训练我们的模型。另外的10000幅图像被称作测试集。在训练结束之前，我们的模型将不会看到这些图像。直到模型中的参数不再变换，我们使用测试集作为模型输入来检验模型的性能。

将数据分为训练集和测试集非常重要。我们并不知道我们的模型在遇到训练数据集或测试数据集的时候是否有相同的表现。最糟的情况在于，模型记录下了它看过的所有图像。如果我们使用相同的训练集进行测试，模型通过查找存储下来的正确答案，可能表现得非常完美。但是如果使用它从未见过的图像则原形毕露。这在模型学习中有个专门的概念叫做过度拟合，就是说特定的训练数据可能掩盖一些更为通常的特征。在机器学习中避免过度拟合是一项重大的课题。关于过度拟合和为什么建议将数据分成2个或者3个数据集，可以参考Coursera上吴恩达（Andrew
Ng）机器学习课程的节选视频。

回到我们的代码，load_data()返回一个dictionary类型数据：

images_train：训练集转换为50000x3072（32像素x32像素x3个颜色通道）的数组

labels_train:训练集的50000个标签（每个数字从0到9代表图像训练集的10个分类）

images_test：测试集（10000x3072）

labels_test：测试集的10000个标签

classes：10个文本标签，将数字转换成文字（0代表“飞机”，1代表“车”，等等）

# Define input placeholders

images_placeholder = tf.placeholder(tf.float32, shape=[None, 3072])

labels_placeholder = tf.placeholder(tf.int64, shape=[None])

做好了这些工作后，雷锋网(公众号：雷锋网)在下篇将带大家开始建立这个模型。

雷锋网按：此系列文章主要介绍了不具备机器学习基础的用户如何尝试从零开始在TensorFlow上搭建一个图像识别系统。在文章的第一部分中，作者Woflgang
Beyer向读者们介绍了一些简单的概念。本文为系列的第二部分，主要介绍了如何实现简单的图像识别功能。雷锋网(公众号：雷锋网)编译，未经许可不得转载。 

现在，我们可以开始建立我们的模型啦。实际上数值计算都是由TensorFlow来完成，它使用了一个快速并高效的C++后台程序。TensorFlow希望避免频繁地在Python和C++之间切换，因为那样会降低计算速度。一般的工作流程是，首先为了定义所有的运算，先建立一个TensorFlow图表。在这个过程中没有计算，我们只是进行设置操作。之后，我们才针对输入数据运行计算操作并记录结果。

让我们开始定义我们的图表。首先通过创建占位符来描述TensorFlow输入数据的形式。占位符不包括任何实际数据，它们只是定义了数据的类型和形状。

在我们的模型中，我们首先为图像数据定义了占位符，它们包括浮点数据（tf.float32）。shape参数定义了输入数据的大小。我们将同时输入多幅图像（稍后我们将谈到这些处理），但是我们希望可以随时改变实际输入图像的个数。所以第一项shape参数为none，这代表大小可以是任何长度。第二项参数是3072，这是每幅图像的浮点值。

分类标签的占位符包括整型数据（tf.int64）,每幅图像都有0到9的一个值。因为我们没有指定输入图像的个数，所以shape参数为[none]。

# Define variables (these are the values we want to optimize)

weights = tf.Variable(tf.zeros([3072, 10]))

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

weights和biases是我们希望优化的变量。但现在还是先谈谈我们的模型吧。

我们的输入包括3072个浮点数据，而希望实现的输出是10个整型数据中的一个。我们怎么把3072个值变成一个呢？让我们退后一步，如果不是输出0到9中的一个数字，而是进行打分，得到10个数字-每个种类一个分数-我们挑选出得分最高的一个种类。所以我们最初的问题就变成了：如何从将3072个值变成10个值。

我们所采取的一种简单的方法是单独查询每个像素。对每一个像素（或更准确点，每个像素的颜色通道）和每个可能的种类，我们问自己是否这个像素的颜色增加或减少了它属于某个种类的可能性。比如说像素颜色是红色。如果汽车图片的像素通常是红色，我们希望增加“汽车”这一种类的得分。我们将像素是红色通道的值乘以一个正数加到“汽车”这一类的的得分里。同样，如果在位置1的地方，马的图像从来不或很少出现红色像素，我们希望将分类为“马”的分数维持在低分或再降低一些。也就是说乘以一个较小的数或者负数后加到分类为“马”的分数里。对所有的10个分类我们都重复这样的操作，对每一个像素重复计算，3072个值进行相加得到一个总和。3072个像素的值乘以3072个加权参数值得到这一分类的得分。最后我们得到10个分类的10个分数。然后我们挑选出得分最高的，将图像打上这一类型的标签。



一幅图像通过一个3072个值的一维数组来表示。每个值乘以一个加权参数，将所有值相加得到一个数值-特定种类的分值。

我们可以用矩阵的方法，这样使用像素值乘以加权值再相加的过程大大简化。我们的图像通过一个3072维向量表示。如果我们将这个向量乘以一个3072x10的加权矩阵，结果就是一个10维向量。它包括了我们需要的加权和。



通过矩阵乘法计算一个图像在所有10个类别中的分数。

3072x10矩阵中的具体值就是我们模型的参数。如果它没有规律或毫无用处，那我们的输出也是一样。这就需要训练数据参与工作。通过查询训练数据，我们希望模型能自己计算出最后的参数。

上面这两行代码里，我们告诉TensorFlow，加权矩阵的大小是3072x10，初始值都被设置为0。另外，我们定义了第二个参数，一个包含偏差值的10维向量。这个偏差值并不直接作用于图像数据，而仅仅是与加权和相加。这个偏差值可以被看做是最后得分的一个起始点。想象一下，一副全黑的图片，所有像素的只都是0。那么不管加权矩阵的只是多少，所有分类的得分都是0。通过偏差值，我们则可以保证我们的每一分类的起始值不是0。

# Define the classifier's result

logits = tf.matmul(images_placeholder, weights) + biases

下面就要讲到预测。通过这一步，我们已经确定了多幅图像向量和矩阵的维度。这个操作的结果就是每幅输入图像都有一个10维向量。



通过矩阵乘法，计算多幅图像的所有10个分类的分数。

# Define the loss function

loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits,labels_placeholder))

weights和bias参数逐渐优化的过程叫做训练，它包括以下步骤：第一，我们输入训练数据让模型根据当前参数进行预测。将预测值与正确的分类标签进行比较。比较的数值结果被叫做损失。越小的损失值表示预测值与正确标签越接近，反之亦然。我们希望将模型的损失值降到最小，让预测值与真实标签更接近。但是在我们将损失最小化之前，先来看看损失是怎么计算出来的。

前一步计算出来的分数被存储在logits变量里，包含任意实数。我们可以调用softmax函数将这些值转化成概率值（0到1之间的实数，总和为1），这样将输入转变成能表示其特征的输出。相对应的输入排列保持不变，原本得分最好的分类拥有最大的概率。softmax函数输出的概率分布与真实的概率分布相比较。在真实的概率分布中正确的类别概率为1，其他类别的概率为0。我们使用交叉熵来比较两种概率分布（更多技术性的解释可以在这里找到）。交叉熵越小，预测值的概率分布与正确值的概率分布的差别就越小。这个值代表了我们模型的损失。

幸运的是TensorFlow提供了一个函数帮我们完成了这一系列的操作。我们比较模型预测值logits和正确分类值labels_placeholder。sparse_softmax_cross_entropy_with_logits()函数的输出就是每幅输入图像的损失值。然后我们只需计算输入图像的平均损失值。

# Define the training operation

train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

但是我们如何调整参数来将损失最小化呢？TensorFlow这时就大发神威了。通过被称作自动分化（auto-differentiation）的技术，它可以计算出相对于参数值，损失值的梯度。这就是说它可以知道每个参数对总的损失的影响，小幅度的加或减参数是否可以降低损失。然后依此调整所有参数值，增加模型的准确性。在完成参数调整之后，整个过程重新开始，新的一组图片被输入到模型中。

TensorFlow知道不同的优化技术可以将梯度信息用于更新参数值。这里我们使用梯度下降算法。在决定参数是，它只关心模型当前的状态，而不去考虑以前的参数值。参数下降算法只需要一个单一的参数，学习率，它是参数更新的一个比例因子。学习率越大，表示每一步参数值的调整越大。如果学习率过大，参数值可能超过正确值导致模型不能收敛。如果学习率过小，模型的学习速度会非常缓慢，需要花很长时间才能找到一个好的参数值。

输入图像分类，比较预测结果和真实值，计算损失和调整参数的过程需要重复多次。对于更大，更复杂的模型，这个计算量将迅速上升。但是对于我们的简单模型，我们既不需要考验耐心也不需要专门的硬件设备就可以得到结果。

# Operation comparing prediction with true label

correct_prediction = tf.equal(tf.argmax(logits, 1), labels_placeholder)

 

# Operation calculating the accuracy of our predictions

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

这两行代码用于检验模型的精确度。logits的argmax返回分数最高的分类。这就是预测的分类标签。tf.equal()将这个标签与正确的分类标签相比较，然后返回布尔向量。布尔数转换为浮点数（每个值不是0就是1），这些数求平均得到的分数就是正确预测图像的比例。

# -----------------------------------------------------------------------------

# Run the TensorFlow graph

# -----------------------------------------------------------------------------

 

with tf.Session() as sess:

  # Initialize variables

  sess.run(tf.initialize_all_variables())

 

  # Repeat max_steps times

  for i in range(max_steps):

最后，我们定义了TensorFlow图表并准备好运行它。在一个会话控制中运行这个图表，可以通过sess变量对它进行访问。运行这个会话控制的第一步就是初始化我们早先创建的变量。在变量定义中我们指定了初始值，这时就需要把这些初始值赋给变量。

然后我们开始迭代训练过程。它会重复进行max_steps次。

# Generate input data batch

indices = np.random.choice(data_sets['images_train'].shape[0], batch_size)

images_batch = data_sets['images_train'][indices]

labels_batch = data_sets['labels_train'][indices]

这几行代码随机抽取了训练数据的几幅图像。从训练数据中抽取的几幅图像和标签被称作批。批的大小（单个批中图像的数量）告诉我们参数更新的频率。我们首先对批中所有图像的损失值求平均。然后根据梯度下降算法更新参数。

如果我们先就对训练集中的所有图像进行分类，而不是在批处理完之后这样做，我们能够计算出初始平均损失和初始梯度，用它们来取代批运行时使用的估计值。但是这样的话，对每个迭代参数的更新都需要进行更多的计算。在另一种极端情况下，我们可以设置批的大小为1，然后更新单幅图像的参数。这会造成更高频率的参数更新，但是更有可能出现错误。从而向错误的方向频繁修正。

通常在这两种极端情况的中间位置我们能得到最快的改进结果。对于更大的模型，对内存的考虑也至关重要。批的大小最好尽可能大，同时又能使所有变量和中间结果能写入内存。

这里第一行代码batch_size在从0到整个训练集的大小之间随机指定一个值。然后根据这个值，批处理选取相应个数的图像和标签。

# Periodically print out the model's current accuracy

if i % 100 == 0:

  train_accuracy = sess.run(accuracy, feed_dict={

    images_placeholder: images_batch, labels_placeholder: labels_batch})

  print('Step {:5d}: training accuracy {:g}'.format(i, train_accuracy))

每100次迭代，我们对模型训练数据批的当前精确率进行检查。我们只需要调用我们之前定义的精确率操作来完成。

# Perform a single training step

sess.run(train_step, feed_dict={images_placeholder: images_batch,labels_placeholder: labels_batch})

这是整个训练循环中最重要的一行代码。我们告诉模型执行一个单独的训练步骤。我们没有必要为了参数更新再次声明模型需要做什么。所有的信息都是由TensorFlow图表中的定义提供的。TensorFlow知道根据损失使用梯度下降算法更新参数。而损失依赖logits。Logits又依靠weights，biases和具体的输入批。

因此我们只需要向模型输入训练数据批。这些通过提供查找表来完成。训练数据批已经在我们早先定义的占位符中完成了赋值。

# After finishing the training, evaluate on the test set

test_accuracy = sess.run(accuracy, feed_dict={

  images_placeholder: data_sets['images_test'],

  labels_placeholder: data_sets['labels_test']})

print('Test accuracy {:g}'.format(test_accuracy))

训练结束后，我们用测试集对模型进行评估。这是模型第一次见到测试集。所以测试集中的图像对模型来时是全新的。我们会评估训练后的模型在处理从未见过的数据时表现如何。

endTime = time.time()

print('Total time: {:5.2f}s'.format(endTime - beginTime))

最后一行代码打印出训练和运行模型用了多长时间。

结果

让我们用“python softmax.py”命令运行这个模型。这里是我得到的输出：

Step     0: training accuracy 0.14

Step   100: training accuracy 0.32

Step   200: training accuracy 0.3

Step   300: training accuracy 0.23

Step   400: training accuracy 0.26

Step   500: training accuracy 0.31

Step   600: training accuracy 0.44

Step   700: training accuracy 0.33

Step   800: training accuracy 0.23

Step   900: training accuracy 0.31

Test accuracy 0.3066

Total time: 12.42s

这意味着什么？在这个测试集中训练模型的估计精度为31%左右。如果你运行自己的代码，你的结果可能在25-30%。所以我们的模型能够对从未见过的图像正确标签的比率为25%-30%。还不算坏！这里有10个不同的标签，如果随机猜测，结果的准确率只有10%。我们这个非常简单的方法已经优于随机猜测。如果你觉得25%仍然有点低，别忘了这个模型其实还比较原始。它对具体图像的比如线和形状等特征毫无概念。它只是单独检测每个像素的颜色，完全不考虑与其他像素的关联。对一幅图像某一个像素的修改对模型来说意味着完全不同的输入。考虑到这些，25%的准确率看起来也不是那么差劲了。

如果我们多进行几次迭代，结果又会如何呢？这可能并不会改善模型的准确率。如果看看结果，你就会发现，训练的准确率并不是稳定上升的，而是在0.23至0.44之间波动。看起来我们已经到达了模型的极限，再进行更多的训练于事无补。这个模型无法再提供更好的结果。事实上，比起进行1000次迭代的训练，我们进行少得多的迭代次数也能得到相似的准确率。

你可能注意到的最后一件事就是：测试的精确度大大低于训练的精确度。如果这个差距非常巨大，这也意味着过度拟合。模型针对已经见过的训练数据进行了精细的调整，而对于以前从未见过的数据则无法做到这点。

这篇文章已经写了很长时间了。很感谢你看完了全文（或直接跳到了文末）！无论是对机器学习分类器如何工作或是如何使用TensorFlow建立和运行简单的图表，我希望你找到了一些你感兴趣的东西。当然，我还有很多材料希望添加进来。目前为止，我们只是用到了softmax分类器，它甚至都没应用任何一种神经网络。我的下一篇博文进行完善：一个小型神经网络模型能够怎样最大程度地改进结果。雷锋网将继续对下一篇文章进行编译，敬请期待