tensorflow的MNIST教程

(ps:根据自己的理解，提炼了一下官方文档的内容，错误的地方希望大佬们多多指正。。。。。)

0x01：数据集的获取和表示

数据集的获取，可以通过代码自动下载。这里的数据就是各种手写数字图片和图片对应的标签(告诉我们这个数字是几，比如下面的是5，0，4，1)。

下载下来的数据集被分成两部分：60000行的训练数据集（mnist.train）和10000行的测试数据集（mnist.test），而每一个数据集都有两部分组成：一张包含手写数字的图片(xs)和一个对应的标签(ys)。训练数据集和测试数据集都包含xs和ys，比如训练数据集的图片是 mnist.train.images ，训练数据集的标签是 mnist.train.labels。根据图片像素点把图片展开为向量，再进一步操作，识别图片上的数值。那这60000个训练数据集是怎么表示的呢？在MNIST训练数据集中，mnist.train.images 是一个形状为 [60000, 784] 的张量(至于什么是张量，小伙伴们可以手都搜一下，加深一下印象)，第一个维度数字用来索引图片，第二个维度数字用来索引每张图片中的像素点。在此张量里的每一个元素，都表示某张图片里的某个像素的强度值，值介于0和1之间。

0x02：代码运行

代码分为两部分，一个是用于下载数据的 input_data.py， 另一个是主程序 mnist.py，

 # Copyright 2015 Google Inc. 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.
 # ==============================================================================
 """Functions for downloading and reading MNIST data."""
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 import gzip
 import os
 import tensorflow.python.platform
 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/'
 def maybe_download(filename, work_directory):
   """Download the data from Yann's website, unless it's already here."""
   if not os.path.exists(work_directory):
     os.mkdir(work_directory)
   filepath = os.path.join(work_directory, filename)
   if not os.path.exists(filepath):
     filepath, _ = urllib.request.urlretrieve(SOURCE_URL + filename, filepath)
     statinfo = os.stat(filepath)
     print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')
   return filepath
 def _read32(bytestream):
   dt = numpy.dtype(numpy.uint32).newbyteorder('>')
   return numpy.frombuffer(bytestream.read(4), dtype=dt)[0]
 def extract_images(filename):
   """Extract the images into a 4D uint8 numpy array [index, y, x, depth]."""
   print('Extracting', filename)
   with gzip.open(filename) as bytestream:
     magic = _read32(bytestream)
     if magic != 2051:
       raise ValueError(
           'Invalid magic number %d in MNIST image file: %s' %
           (magic, filename))
     num_images = _read32(bytestream)
     rows = _read32(bytestream)
     cols = _read32(bytestream)
     buf = bytestream.read(rows * cols * num_images)
     data = numpy.frombuffer(buf, dtype=numpy.uint8)
     data = data.reshape(num_images, rows, cols, 1)
     return data
 def dense_to_one_hot(labels_dense, num_classes=10):
   """Convert class labels from scalars to one-hot vectors."""
   num_labels = labels_dense.shape[0]
   index_offset = numpy.arange(num_labels) * num_classes
   labels_one_hot = numpy.zeros((num_labels, num_classes))
   labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1
   return labels_one_hot
 def extract_labels(filename, one_hot=False):
   """Extract the labels into a 1D uint8 numpy array [index]."""
   print('Extracting', filename)
   with gzip.open(filename) as bytestream:
     magic = _read32(bytestream)
     if magic != 2049:
       raise ValueError(
           'Invalid magic number %d in MNIST label file: %s' %
           (magic, filename))
     num_items = _read32(bytestream)
     buf = bytestream.read(num_items)
     labels = numpy.frombuffer(buf, dtype=numpy.uint8)
     if one_hot:
       return dense_to_one_hot(labels)
     return labels
 class DataSet(object):
   def __init__(self, images, labels, fake_data=False, one_hot=False,
                dtype=tf.float32):
     """Construct a DataSet.
     one_hot arg is used only if fake_data is true.  `dtype` can be either
     `uint8` to leave the input as `[0, 255]`, or `float32` to rescale into
     `[0, 1]`.
     """
     dtype = tf.as_dtype(dtype).base_dtype
     if dtype not in (tf.uint8, tf.float32):
       raise TypeError('Invalid image dtype %r, expected uint8 or float32' %
                       dtype)
     if fake_data:
       self._num_examples = 10000
       self.one_hot = one_hot
     else:
       assert images.shape[0] == labels.shape[0], (
           'images.shape: %s labels.shape: %s' % (images.shape,
                                                  labels.shape))
       self._num_examples = images.shape[0]
       # Convert shape from [num examples, rows, columns, depth]
       # to [num examples, rows*columns] (assuming depth == 1)
       assert images.shape[3] == 1
       images = images.reshape(images.shape[0],
                               images.shape[1] * images.shape[2])
       if dtype == tf.float32:
         # Convert from [0, 255] -> [0.0, 1.0].
         images = images.astype(numpy.float32)
         images = numpy.multiply(images, 1.0 / 255.0)
     self._images = images
     self._labels = labels
     self._epochs_completed = 0
     self._index_in_epoch = 0
   @property
   def images(self):
     return self._images
   @property
   def labels(self):
     return self._labels
   @property
   def num_examples(self):
     return self._num_examples
   @property
   def epochs_completed(self):
     return self._epochs_completed
   def next_batch(self, batch_size, fake_data=False):
     """Return the next `batch_size` examples from this data set."""
     if fake_data:
       fake_image = [1] * 784
       if self.one_hot:
         fake_label = [1] + [0] * 9
       else:
         fake_label = 0
       return [fake_image for _ in xrange(batch_size)], [
           fake_label for _ in xrange(batch_size)]
     start = self._index_in_epoch
     self._index_in_epoch += batch_size
     if self._index_in_epoch > self._num_examples:
       # Finished epoch
       self._epochs_completed += 1
       # Shuffle the data
       perm = numpy.arange(self._num_examples)
       numpy.random.shuffle(perm)
       self._images = self._images[perm]
       self._labels = self._labels[perm]
       # Start next epoch
       start = 0
       self._index_in_epoch = batch_size
       assert batch_size <= self._num_examples
     end = self._index_in_epoch
     return self._images[start:end], self._labels[start:end]
 def read_data_sets(train_dir, fake_data=False, one_hot=False, dtype=tf.float32):
   class DataSets(object):
     pass
   data_sets = DataSets()
   if fake_data:
     def fake():
       return DataSet([], [], fake_data=True, one_hot=one_hot, dtype=dtype)
     data_sets.train = fake()
     data_sets.validation = fake()
     data_sets.test = fake()
     return data_sets
   TRAIN_IMAGES = 'train-images-idx3-ubyte.gz'
   TRAIN_LABELS = 'train-labels-idx1-ubyte.gz'
   TEST_IMAGES = 't10k-images-idx3-ubyte.gz'
   TEST_LABELS = 't10k-labels-idx1-ubyte.gz'
   VALIDATION_SIZE = 5000
   local_file = maybe_download(TRAIN_IMAGES, train_dir)
   train_images = extract_images(local_file)
   local_file = maybe_download(TRAIN_LABELS, train_dir)
   train_labels = extract_labels(local_file, one_hot=one_hot)
   local_file = maybe_download(TEST_IMAGES, train_dir)
   test_images = extract_images(local_file)
   local_file = maybe_download(TEST_LABELS, train_dir)
   test_labels = extract_labels(local_file, one_hot=one_hot)
   validation_images = train_images[:VALIDATION_SIZE]
   validation_labels = train_labels[:VALIDATION_SIZE]
   train_images = train_images[VALIDATION_SIZE:]
   train_labels = train_labels[VALIDATION_SIZE:]
   data_sets.train = DataSet(train_images, train_labels, dtype=dtype)
   data_sets.validation = DataSet(validation_images, validation_labels,
                                  dtype=dtype)
   data_sets.test = DataSet(test_images, test_labels, dtype=dtype)
   return data_sets

input.py

# 这两行用来下载数据集
import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

import tensorflow as tf

# 设置变量
x = tf.placeholder("float", [None, 784])    # 占位符
w = tf.Variable(tf.zeros([784, 10]))        # 权重值
b = tf.Variable(tf.zeros([10]))             # 偏置值

# 创建模型，用tf.matmul(​​X，W)表示x乘以W
y = tf.nn.softmax(tf.matmul(x,w) + b)

# 用于输入正确值，为了下面计算交叉熵
y_ = tf.placeholder("float", [None,10])

# 计算交叉熵
# 用 tf.log 计算 y 的每个元素的对数,然后把 y_ 的每一个元素和 tf.log(y_) 的对应元素相乘再用 tf.reduce_sum 计算张量的所有元素的总和
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

# 进行训练，以0.01的学习速率最小化交叉熵
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

# 初始化创建的变量
init = tf.initialize_all_variables()

# 在一个Session里面启动模型，并初始化变量
sess = tf.Session()
sess.run(init)

# 开始训练模型，训练1000次
for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step,feed_dict={x:batch_xs, y_:batch_ys})

# 用 tf.equal 来检测我们的预测是否真实标签匹配
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))

# 上一行代码会返回一组布尔2值，为了正确预测，把布尔值转换成浮点数
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

# 计算正确率
print(sess.run(accuracy, feed_dict={x:mnist.test.images, y_:mnist.test.labels}))

mnist.py

第一次运行主程序时会有点久，因为需要下载数据。最后，，会输出测试的准确率，大概91%左右。

0x03：图片识别过程

为了得到一张给定图片属于某个特定数字类的证据（evidence），我们对图片像素值进行加权求和。如果这个像素具有很强的证据说明这张图片不属于该类，那么相应的权值为负数，相反如果这个像素拥有有利的证据支持这张图片属于这个类，那么权值是正数。下面的图片显示了一个模型学习到的图片上每个像素对于特定数字类的权值。红色代表负数权值，蓝色代表正数权值。(我的理解是：将0-9抽象成10个数据类，红色的表示不属于这个数据类的“属性”，蓝色的表示属于这个数据类的“属性”，在一张图片中，如果符合蓝色“属性”的多些，则这张图片符合这个数据类的概率就高些(下面的softmax函数计算概率)，个人理解，希望大佬们指正错误。。。)

我们也需要加入一个额外的偏置量（bias），因为输入往往会带有一些无关的干扰量。因此对于给定的输入图片 x 它代表的是数字 i 的证据可以表示为(这句比较重要)：

(这个公式结合下面第一个彩色图一起看比较容易理解些。)

其中  代表权重， 代表数字 i 类的偏置量，j 代表给定图片 x 的像素索引用于像素求和(还记得前面那个[60000, 784]的张量嘛)。然后用softmax函数可以把这些证据转换成概率 y(这句也是是关键)：

这里的softmax可以看成是一个激励（activation）函数或者链接（link）函数，把我们定义的线性函数的输出转换成我们想要的格式，也就是关于10个数字类的概率分布。因此，给定一张图片，它对于每一个数字的吻合度可以被softmax函数转换成为一个概率值。softmax函数可以定义为：

展开等式右边的子式，可以得到：

但是更多的时候把softmax模型函数定义为前一种形式：把输入值当成幂指数求值，再正则化这些结果值。这个幂运算表示，更大的证据对应更大的假设模型（hypothesis）里面的乘数权重值。反之，拥有更少的证据意味着在假设模型里面拥有更小的乘数系数。假设模型里的权值不可以是0值或者负值。Softmax然后会正则化这些权重值，使它们的总和等于1，以此构造一个有效的概率分布。（更多的关于Softmax函数的信息，可以参考Michael Nieslen的书里面的这个部分，其中有关于softmax的可交互式的可视化解释。）

对于softmax回归模型可以用下面的图解释，对于输入的xs加权求和，再分别加上一个偏置量，最后再输入到softmax函数中：

如果把它写成一个等式，我们可以得到：

我们也可以用向量表示这个计算过程：用矩阵乘法和向量相加。这有助于提高计算效率。（也是一种更有效的思考方式）

更进一步，可以写成更加紧凑的方式：

参考文章:http://www.tensorfly.cn/tfdoc/tutorials/mnist_beginners.html

********************不积跬步无以至千里********************