TensorFlow入门学习(让机器/算法帮助我们作出选择)

catalogue

. 个人理解
. 基本使用
. MNIST(multiclass classification)入门
. 深入MNIST
. 卷积神经网络：CIFAR- 数据集分类
. 单词的向量表示(Vector Representations of Words)
. 循环神经网络(RNN)、LSTM(Long-Short Term Memory, LSTM)
. 用深度学习网络搭建一个聊天机器人 

0. 个人理解

在学习的最开始，我在这里写一个个人对deep leanring和神经网络的粗略理解，不对的地方请多指教

. deep learning神经网络本质是在lean什么，我觉得是在learn一个一组参数，或者说是选择模式，也就是我们常说的分类器，这个分类器可能是一个高维度分类器，由一组参数组成
. 拿图像验证码识别来说，这里的参数就是指图像区域中的权重分布情况(数字1和数字2的权重像素空间分布是不同的)，如果我们选定图像的像素空间(例如32 * ) + RGB色彩通道()作为输入特征(本质上这就是特征工程)，这些特征会被tensorflow当成神经元，并在每一层对这些神经元进行组合，并计算出结果，而下一层神经网络的神经元，会把这一层的输出再进行组合，组合时，根据上一次预测的准确性，会自动通过back propogation给每个组合不同的weight(比重)，这个过程会一直进行，直到调整出一个最佳拟合的weight，这个weight往往就是最贴近真实图像的像素空间权重
. . 世界上的所有事物，都可以抽象为一个高维度矩阵，这个过程在不同的领域会有不同的提取抽象方式，即特征工程，值得注意的是，拥有对应领域的专业知识，非常有助于特征工程的实施
. 我们将特定领域的、需要分类/识别的对象抽象为高维度矩阵后，进入deep learn算法模型中就成为了神经元(节点)，deep learn模型接下来要做的事称之为"拟合"
. 要完成分类和识别，deep learn的目标是找到一个拟合矩阵(具象来说就是"高维度-1分类切面")，要达到这个目的，需要3个元素
　　) 拟合函数(activation 激活函数): 用于生成拟合切面
　　) 误差函数(Loss Function): 用于在网络计算的过程中计算当前拟合参数得到的拟合切面离最优值的距离，以便随时调整参数
　　) 神经网络结构: deep learn深度学习和普通神经网络的区别就在于"层数"的不同，深度神经网络往往有3层以上(输入层、隐层、输出层)，当层数增加后，在每一层选择怎样的组合的交叉结构就成了一个很难的事情，当前还没有完善的理论支撑能精确地计算出什么样的网络结构能输出最好的结果，通常的做法是根据不认同的业务场景去不断尝试不同的网络结构，直到"试出"一个相对较好的网络结构，然后再在这个网络结构的基础之上进行参数调整

值得注意的是，神经网络最大的魔力在于，就在于即使我们无法准确地提取出各种各样很多的特征，而只要给与足够多层的神经网络和神经元，神经网络自己会组合出有用的特征。之所以可以做到这点，我么可以来看一个实验

http://playground.tensorflow.org/#activation=tanh&batchSize=10&dataset=spiral&regDataset=reg-plane&learningRate=0.03&regularizationRate=0&noise=0&networkShape=8,8,8,8,8,8&seed=0.33671&showTestData=false&discretize=false&percTrainData=50&x=true&y=true&xTimesY=false&xSquared=false&ySquared=false&cosX=false&sinX=false&cosY=false&sinY=false&collectStats=false&problem=classification&initZero=false&hideText=false

对于输入来说，我们只给出2个维度的特征x1、x2，而选择1个6层的，每层有8个神经元的神经网络，在每层网络中，维度被扩展到了8，神经网络会自动在训练过程中，寻找对它有价值的维度，并给与一定的weight权重，根据loss函数来不断递归下降，直到找到一个最好的拟合权重参数。DL大大降低了特征工程的难度

0x1: 神经网络到底理解了什么

其一，神经网络理解了如何将输入空间解耦为分层次的卷积滤波器组
其二，神经网络理解了从一系列滤波器的组合到一系列特定标签的概率映射。神经网络学习到的东西完全达不到人类的“看见”的意义，从科学的的角度讲，这当然也不意味着我们已经解决了计算机视觉的问题

有些人说，卷积神经网络学习到的对输入空间的分层次解耦模拟了人类视觉皮层的行为。这种说法可能对也可能不对，但目前未知我们还没有比较强的证据来承认或否认它。当然，有些人可以期望人类的视觉皮层就是以类似的方式学东西的，某种程度上讲，这是对我们视觉世界的自然解耦（就像傅里叶变换是对周期声音信号的一种解耦一样自然）【这里是说，就像声音信号的傅里叶变换表达了不同频率的声音信号这种很自然很物理的理解一样，我们可能会认为我们对视觉信息的识别就是分层来完成的，圆的是轮子，有四个轮子的是汽车，造型炫酷的汽车是跑车，像这样】。但是，人类对视觉信号的滤波、分层次、处理的本质很可能和我们弱鸡的卷积网络完全不是一回事。视觉皮层不是卷积的，尽管它们也分层，但那些层具有皮质列的结构，而这些结构的真正目的目前还不得而知，这种结构在我们的人工神经网络中还没有出现（尽管乔大帝Geoff Hinton正在在这个方面努力）。此外，人类有比给静态图像分类的感知器多得多的视觉感知器，这些感知器是连续而主动的，不是静态而被动的，这些感受器还被如眼动等多种机制复杂控制

Relevant Link:

https://groups.google.com/a/tensorflow.org/forum/#!forum/discuss
https://stackoverflow.com/questions/tagged/tensorflow
http://www.tensorfly.cn/tfdoc/resources/overview.html
https://www.zhihu.com/question/41667903
http://playground.tensorflow.org/#activation=tanh&batchSize=10&dataset=spiral&regDataset=reg-plane&learningRate=0.03&regularizationRate=0&noise=0&networkShape=8,8,8,8,8,8&seed=0.33671&showTestData=false&discretize=false&percTrainData=50&x=true&y=true&xTimesY=false&xSquared=false&ySquared=false&cosX=false&sinX=false&cosY=false&sinY=false&collectStats=false&problem=classification&initZero=false&hideText=false

1. 基本使用

0x1: 综述

. 使用图 (graph) 来表示计算任务.
. 在被称之为 会话 (Session) 的上下文 (context) 中执行图.
. 使用 tensor 表示数据.
. 通过 变量 (Variable) 维护状态.
. 使用 feed 和 fetch 可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据.

TensorFlow 是一个编程系统, 使用图来表示计算任务. 图中的节点被称之为 op (operation 的缩写). 一个 op 获得 0 个或多个 Tensor, 执行计算, 产生 0 个或多个 Tensor. 每个 Tensor 是一个类型化的多维数组. 例如, 你可以将一小组图像集表示为一个四维浮点数数组, 这四个维度分别是 [batch, height, width, channels].
一个 TensorFlow 图描述了计算的过程. 为了进行计算, 图必须在 会话 里被启动. 会话 将图的 op 分发到诸如 CPU 或 GPU 之类的 设备 上, 同时提供执行 op 的方法. 这些方法执行后, 将产生的 tensor 返回. 在 Python 语言中, 返回的 tensor 是 numpy ndarray 对象; 在 C 和 C++ 语言中, 返回的 tensor 是 tensorflow::Tensor 实例.

0x2: 计算图

TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段. 在构建阶段, op 的执行步骤 被描述成一个图. 在执行阶段, 使用会话执行执行图中的 op.
例如, 通常在构建阶段创建一个图来表示和训练神经网络, 然后在执行阶段反复执行图中的训练 op.

1. 构建图(将待分类对象抽象为高维矩阵)

构建图的第一步, 是创建源 op (source op). 源 op 不需要任何输入, 例如 常量 (Constant). 源 op 的输出被传递给其它 op 做运算.
Python 库中, op 构造器的返回值代表被构造出的 op 的输出, 这些返回值可以传递给其它 op 构造器作为输入.

# -*- coding:utf- -*-

import tensorflow as tf

if __name__ == "__main__":
    # 创建一个常量 op, 产生一个 1x2 矩阵. 这个 op 被作为一个节点
    # 加到默认图中.
    #
    # 构造器的返回值代表该常量 op 的返回值.
    matrix1 = tf.constant([[., .]])

    # 创建另外一个常量 op, 产生一个 2x1 矩阵.
    matrix2 = tf.constant([[.],[.]])

    # 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入.
    # 返回值 'product' 代表矩阵乘法的结果.
    product = tf.matmul(matrix1, matrix2)

默认图现在有三个节点, 两个 constant() op, 和一个matmul() op. 为了真正进行矩阵相乘运算, 并得到矩阵乘法的 结果, 必须在会话里启动这个图.

2. 在一个会话中启动图

构造阶段完成后, 才能启动图. 启动图的第一步是创建一个 Session 对象, 如果无任何创建参数, 会话构造器将启动默认图.

# -*- coding:utf- -*-

import tensorflow as tf

if __name__ == "__main__":
    # 创建一个常量 op, 产生一个 1x2 矩阵. 这个 op 被作为一个节点
    # 加到默认图中.
    #
    # 构造器的返回值代表该常量 op 的返回值.
    matrix1 = tf.constant([[., .]])

    # 创建另外一个常量 op, 产生一个 2x1 矩阵.
    matrix2 = tf.constant([[.],[.]])

    # 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入.
    # 返回值 'product' 代表矩阵乘法的结果.
    product = tf.matmul(matrix1, matrix2)

    # 默认图现在有三个节点, 两个 constant() op, 和一个matmul() op. 为了真正进行矩阵相乘运算, 并得到矩阵乘法的 结果, 你必须在会话里启动这个图.

    # 启动默认图.
    sess = tf.Session()

    # 调用 sess 的 'run()' 方法来执行矩阵乘法 op, 传入 'product' 作为该方法的参数.
    # 上面提到, 'product' 代表了矩阵乘法 op 的输出, 传入它是向方法表明, 我们希望取回
    # 矩阵乘法 op 的输出.
    #
    # 整个执行过程是自动化的, 会话负责传递 op 所需的全部输入. op 通常是并发执行的.
    #
    # 函数调用 'run(product)' 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op) 的执行.
    #
    # 返回值 'result' 是一个 numpy `ndarray` 对象.
    result = sess.run(product)
    print result
    # ==> [[ .]]

    # 任务完成, 关闭会话.
    sess.close()

在实现上, TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU 或 GPU). 一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测. 如果检测到 GPU, TensorFlow 会尽可能地利用找到的第一个 GPU 来执行操作

0x3: Tensor

TensorFlow 程序使用 tensor 数据结构来代表所有的数据, 计算图中, 操作间传递的数据都是 tensor. 你可以把 TensorFlow tensor 看作是一个 n 维的数组或列表. 一个 tensor 包含一个静态类型 rank, 和 一个 shape.

0x4: 变量

变量维护图执行过程中的状态信息. 下面的例子演示了如何使用变量实现一个简单的计数器

# -*- coding:utf- -*-

import tensorflow as tf

if __name__ == "__main__":
    # 创建一个变量, 初始化为标量 .
    state = tf.Variable(, name="counter")

    # 创建一个 op, 其作用是使 state 增加
    one = tf.constant()
    new_value = tf.add(state, one)
    update = tf.assign(state, new_value)

    # 启动图后, 变量必须先经过`初始化` (init) op 初始化,
    # 首先必须增加一个`初始化` op 到图中.
    init_op = tf.initialize_all_variables()

    # 启动图, 运行 op
    with tf.Session() as sess:
      # 运行 'init' op
      sess.run(init_op)
      # 打印 'state' 的初始值
      print sess.run(state)
      # 运行 op, 更新 'state', 并打印 'state'
      for _ in range():
        sess.run(update)
        print sess.run(state)

代码中 assign() 操作是图所描绘的表达式的一部分, 正如 add() 操作一样. 所以在调用 run() 执行表达式之前, 它并不会真正执行赋值操作.
通常会将一个统计模型中的参数表示为一组变量. 例如, 你可以将一个神经网络的权重作为某个变量存储在一个 tensor 中. 在训练过程中, 通过重复运行训练图, 更新这个 tensor.

0x5: Fetch

为了取回操作的输出内容, 可以在使用 Session 对象的 run() 调用 执行图时, 传入一些 tensor, 这些 tensor
会帮助你取回结果. 在之前的例子里, 我们只取回了单个节点 state, 但是你也可以取回多个 tensor:

# -*- coding:utf- -*-

import tensorflow as tf

if __name__ == "__main__":
    # 启动默认图.
    sess = tf.Session()

    input1 = tf.constant(3.0)
    input2 = tf.constant(2.0)
    input3 = tf.constant(5.0)
    intermed = tf.add(input2, input3)
    mul = tf.multiply(input1, intermed)

    with tf.Session():
      result = sess.run([mul, intermed])
      print result

0x6: Feed

上述示例在计算图中引入了 tensor, 以常量或变量的形式存储. TensorFlow 还提供了 feed 机制, 该机制 可以临时替代图中的任意操作中的 tensor 可以对图中任何操作提交补丁, 直接插入一个 tensor.
feed 使用一个 tensor 值临时替换一个操作的输出结果. 你可以提供 feed 数据作为 run() 调用的参数. feed 只在调用它的方法内有效, 方法结束, feed 就会消失. 最常见的用例是将某些特殊的操作指定为 "feed" 操作, 标记的方法是使用 tf.placeholder() 为这些操作创建占位符.

# -*- coding:utf- -*-

import tensorflow as tf

if __name__ == "__main__":
    input1 = tf.placeholder(tf.types.float32)
    input2 = tf.placeholder(tf.types.float32)
    output = tf.multiply(input1, input2)

    with tf.Session() as sess:
        print sess.run([output])
        print sess.run([output], feed_dict={input1:[.], input2:[.]})

0x7: batch

深度学习的优化算法，说白了就是梯度下降。每次的参数更新有两种方式

. 第一种，遍历全部数据集算一次损失函数，然后算函数对各个参数的梯度，更新梯度。这种方法每更新一次参数都要把数据集里的所有样本都看一遍，计算量开销大，计算速度慢，不支持在线学习，这称为Batch gradient descent，批梯度下降。
. 另一种，每看一个数据就算一下损失函数，然后求梯度更新参数，这个称为随机梯度下降，stochastic gradient descent。这个方法速度比较快，但是收敛性能不太好，可能在最优点附近晃来晃去，hit不到最优点。两次参数的更新也有可能互相抵消掉，造成目标函数震荡的比较剧烈 

为了克服两种方法的缺点，现在一般采用的是一种折中手段，mini-batch gradient decent，小批的梯度下降，这种方法把数据分为若干个批，按批来更新参数，这样，一个批中的一组数据共同决定了本次梯度的方向，下降起来就不容易跑偏，减少了随机性。另一方面因为批的样本数与整个数据集相比小了很多，计算量也不是很大
基本上现在的梯度下降都是基于mini-batch的，模块中经常会出现batch_size，就是指这个。
我们在代码中常见的优化器SGD是stochastic gradient descent的缩写，但不代表是一个样本就更新一回，还是基于mini-batch的

Relevant Link:

http://www.tensorfly.cn/tfdoc/get_started/os_setup.html
http://keras-cn.readthedocs.io/en/latest/getting_started/concepts/#batch

2. MNIST(multiclass classification)入门

0x1: MNIST数据集

https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/examples/tutorials/mnist/input_data.py#

下载下来的数据集被分成两部分：60000行的训练数据集（mnist.train）和10000行的测试数据集（mnist.test）。这样的切分很重要，在机器学习模型设计时必须有一个单独的测试数据集不用于训练而是用来评估这个模型的性能，从而更加容易把设计的模型推广到其他数据集上（泛化）。
正如前面提到的一样，每一个MNIST数据单元有两部分组成：一张包含手写数字的图片和一个对应的标签(监督学习中，正确打标的样本特别重要)。我们把这些图片设为“xs”，把这些标签设为“ys”。训练数据集和测试数据集都包含xs和ys，比如训练数据集的图片是 mnist.train.images ，训练数据集的标签是 mnist.train.labels。
每一张图片包含28像素X28像素。我们可以用一个数字数组来表示这张图片：

我们把这个数组展开成一个向量，长度是 28x28 = 784。如何展开这个数组（数字间的顺序）不重要，只要保持各个图片采用相同的方式展开。从这个角度来看，MNIST数据集的图片就是在784维向量空间里面的点, 并且拥有比较复杂的结构 (提醒: 此类数据的可视化是计算密集型的)。
展平图片的数字数组会丢失图片的二维结构信息。这显然是不理想的，最优秀的计算机视觉方法会挖掘并利用这些结构信息，但在当前锁学习的简单数学模型，softmax回归(softmax regression)，不会利用这些结构信息。
因此，在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] 的数字矩阵。

0x2: Softmax回归

我们知道MNIST的每一张图片都表示一个数字，从0到9。我们希望得到给定图片代表每个数字的概率。比如说，我们的模型可能推测一张包含9的图片代表数字9的概率是80%但是判断它是8的概率是5%（因为8和9都有上半部分的小圆），然后给予它代表其他数字的概率更小的值。
这是一个使用softmax回归（softmax regression）模型的经典案例。softmax模型可以用来给不同的对象分配概率。即使在之后，我们训练更加精细的模型时，最后一步也需要用softmax来分配概率。
softmax回归（softmax regression）分两步

1. 第一步

为了得到一张给定图片属于某个特定数字类的证据（evidence），我们对图片像素值进行加权求和。如果这个像素具有很强的证据说明这张图片不属于该类，那么相应的权值为负数，相反如果这个像素拥有有利的证据支持这张图片属于这个类，那么权值是正数。
下面的图片显示了一个模型学习到的图片上每个像素对于特定数字类的权值。红色代表负数权值，蓝色代表正数权值。

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

其中  代表权重， 代表数字 i 类的偏置量，j 代表给定图片 x 的像素索引用于像素求和。然后用softmax函数可以把这些证据转换成概率 y：

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

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

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

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

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

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

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

验证码识别体现了模式识别的一个很朴素的思想，就是人的认字过程是经历了一个"学习过程"，在看过了很多人、各种写法、各种字体的字后，人脑中对某个字应该"长的样子"形成了一个权重认知模型，不管怎么潦草，只要基本形态在那里，人就能认出来。把这个认知过程抽象为数学概念，本质上就是特定像素区域给与较高的权重，根据像素权重划分出区域，只要大体在这个区域中，就应该有更大的概率是这个字

0x3: 实现回归模型

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

TensorFlow不仅仅可以使softmax回归模型计算变得特别简单，它也用这种非常灵活的方式来描述其他各种数值计算，从机器学习模型对物理学模拟仿真模型。一旦被定义好之后，我们的模型就可以在不同的设备上运行：计算机的CPU，GPU，甚至是手机

0x4: 训练模型

为了训练我们的模型，我们首先需要定义一个指标来评估这个模型是好的。其实，在机器学习，我们通常定义指标来表示一个模型是坏的，这个指标称为成本（cost）或损失（loss），然后尽量最小化这个指标。但是，这两种方式是相同的。
一个非常常见的，非常漂亮的成本函数是“交叉熵”（cross-entropy）。交叉熵产生于信息论里面的信息压缩编码技术，但是它后来演变成为从博弈论到机器学习等其他领域里的重要技术手段。它的定义如下：

y 是我们预测的概率分布, y' 是实际的分布（我们输入的one-hot vector)。比较粗糙的理解是，交叉熵是用来衡量我们的预测用于描述真相的低效性。即如果我们的描述越不准确，则不确定性就越高，熵值就越大

TensorFlow拥有一张描述你各个计算单元的图，它可以自动地使用反向传播算法(backpropagation algorithm)来有效地确定你的变量是如何影响你想要最小化的那个成本值的。然后，TensorFlow会用你选择的优化算法来不断地修改变量以降低成本。

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

在这里，我们要求TensorFlow用梯度下降算法（gradient descent algorithm）以0.01的学习速率最小化交叉熵。梯度下降算法（gradient descent algorithm）是一个简单的学习过程，TensorFlow只需将每个变量一点点地往使成本不断降低的方向移动

TensorFlow在这里实际上所做的是，它会在后台给描述你的计算的那张图里面增加一系列新的计算操作单元用于实现反向传播算法和梯度下降算法。然后，它返回给你的只是一个单一的操作，当运行这个操作时，它用梯度下降算法训练你的模型，微调你的变量，不断减少成本。

0x5: 评估我们的模型

首先让我们找出那些预测正确的标签。tf.argmax 是一个非常有用的函数，它能给出某个tensor对象在某一维上的其数据(softmax预测出了一个类似[1,0,0,0,0,0,0,0,0]矩阵，对应为1的那个就是它预测出的最大概率的数字)最大值所在的索引值(对应的数字)。由于标签向量是由0,1组成，因此最大值1所在的索引位置就是类别标签，比如tf.argmax(y,1)返回的是模型对于任一输入x预测到的标签值，而 tf.argmax(y_,1) 代表正确的标签，我们可以用 tf.equal 来检测我们的预测是否真实标签匹配(索引位置一样表示匹配)

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

这行代码会给我们一组布尔值。为了确定正确预测项的比例，我们可以把布尔值转换成浮点数，然后取平均值。例如，[True, False, True, True] 会变成 [1,0,1,1] ，取平均值后得到 0.75.

accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

最后，我们计算所学习到的模型在测试数据集上面的正确率。

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

0x6: mnist_softmax.py

# Copyright  The TensorFlow Authors. 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.
# ==============================================================================

"""A very simple MNIST classifier.
See extensive documentation at
http://tensorflow.org/tutorials/mnist/beginners/index.md
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import argparse
import sys

import input_data
import tensorflow as tf

FLAGS = None

def main(_):
  # Import data
  mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

  # Create the model
  x = tf.placeholder(tf.float32, [None, ])
  W = tf.Variable(tf.zeros([, ]))
  b = tf.Variable(tf.zeros([]))
  y = tf.matmul(x, W) + b

  # Define loss and optimizer
  y_ = tf.placeholder(tf.float32, [None, ])

  # The raw formulation of cross-entropy,
  #
  #   tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.nn.softmax(y)),
  #                                 reduction_indices=[]))
  #
  # can be numerically unstable.
  #
  # So here we use tf.nn.softmax_cross_entropy_with_logits on the raw
  # outputs of 'y', and then average across the batch.
  cross_entropy = tf.reduce_mean(
      tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
  train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

  sess = tf.InteractiveSession()
  tf.global_variables_initializer().run()
  # Train
  for _ in range():
    batch_xs, batch_ys = mnist.train.next_batch()
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

  # Test trained model
  correct_prediction = tf.equal(tf.argmax(y, ), tf.argmax(y_, ))
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
  print(sess.run(accuracy, feed_dict={x: mnist.test.images,
                                      y_: mnist.test.labels}))

if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument('--data_dir', type=str, default='MNIST_data/',
                      help='Directory for storing input data')
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[]] + unparsed)

Relevant Link:

http://yann.lecun.com/exdb/mnist/
https://github.com/tensorflow/tensorflow/tree/master/tensorflow/examples/tutorials/mnist
https://github.com/aymericdamien/TensorFlow-Examples/tree/master/examples
https://www.tensorflow.org/get_started/mnist/pros
https://www.tensorflow.org/get_started/mnist/beginners

3. 深入MNIST

0x1: 构建一个多层卷积网络(多层深度神经网络)

1. 权重初始化

为了创建这个模型，我们需要创建大量的权重和偏置项。这个模型中的权重在初始化时应该加入少量的噪声来打破对称性以及避免0梯度。由于我们使用的是ReLU神经元，因此比较好的做法是用一个较小的正数来初始化偏置项，以避免神经元节点输出恒为0的问题（dead neurons）。为了不在建立模型的时候反复做初始化操作，我们定义两个函数用于初始化

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)

2. 卷积和池化(将低维特征扩展到高维空间)

TensorFlow在卷积和池化上有很强的灵活性。我们怎么处理边界？步长应该设多大？在这个实例里，我们会一直使用vanilla版本。我们的卷积使用1步长（stride size），0边距（padding size）的模板，保证输出和输入是同一个大小。我们的池化用简单传统的2x2大小的模板做max pooling。为了代码更简洁，我们把这部分抽象成一个函数。

def conv2d(x, W):
  return tf.nn.conv2d(x, W, strides=[, , , ], padding='SAME')

def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[, , , ],
                        strides=[, , , ], padding='SAME')

3. 第一层卷积

现在我们可以开始实现第一层了。它由一个卷积接一个max pooling完成。卷积在每个5x5的patch中算出32个特征。卷积的权重张量形状是[5, 5, 1, 32]，前两个维度是patch的大小，接着是输入的通道数目，最后是输出的通道数目。 而对于每一个输出通道都有一个对应的偏置量。

W_conv1 = weight_variable([, , , ])
b_conv1 = bias_variable([])

为了用这一层，我们把x变成一个4d向量，其第2、第3维对应图片的宽、高，最后一维代表图片的颜色通道数(因为是灰度图所以这里的通道数为1，如果是rgb彩色图，则为3)

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

We then convolve x_image with the weight tensor, add the bias, apply the ReLU function, and finally max pool. 我们把x_image和权值向量进行卷积，加上偏置项，然后应用ReLU激活函数，最后进行max pooling。

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

4. 第二层卷积

为了构建一个更深的网络，我们会把几个类似的层堆叠起来。第二层中，每个5x5的patch会得到64个特征(上一层的输出是32个特征，作为下一层的输入)

W_conv2 = weight_variable([, , , ])
b_conv2 = bias_variable([])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

5. 密集连接层

现在，图片尺寸减小到7x7，我们加入一个有1024个神经元的全连接层，用于处理整个图片。我们把池化层输出的张量reshape成一些向量，乘上权重矩阵，加上偏置，然后对其使用ReLU

W_fc1 = weight_variable([ *  * , ])
b_fc1 = bias_variable([])

h_pool2_flat = tf.reshape(h_pool2, [-, **])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

6. Dropout

为了减少过拟合，我们在输出层之前加入dropout。我们用一个placeholder来代表一个神经元的输出在dropout中保持不变的概率。这样我们可以在训练过程中启用dropout，在测试过程中关闭dropout。 TensorFlow的tf.nn.dropout操作除了可以屏蔽神经元的输出外，还会自动处理神经元输出值的scale。所以用dropout的时候可以不用考虑scale。

keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

7. 输出层

最后，我们添加一个softmax层，就像前面的单层softmax regression一样

W_fc2 = weight_variable([, ])
b_fc2 = bias_variable([])

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

注意这里和softmax regression的区别在于，softmax regression的输入维度是图像像素的768维，而该网络的输入是卷积后的1024高维空间，后者抽象度更好

8. 训练和评估模型

为了进行训练和评估，我们使用与之前简单的单层SoftMax神经网络模型几乎相同的一套代码，只是我们会用更加复杂的ADAM优化器来做梯度最速下降，在feed_dict中加入额外的参数keep_prob来控制dropout比例。然后每100次迭代输出一次日志

cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,), tf.argmax(y_,))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
sess.run(tf.initialize_all_variables())
for i in range():
  batch = mnist.train.next_batch()
  if i% == :
    train_accuracy = accuracy.eval(feed_dict={
        x:batch[], y_: batch[], keep_prob: 1.0})
    print "step %d, training accuracy %g"%(i, train_accuracy)
  train_step.run(feed_dict={x: batch[], y_: batch[], keep_prob: 0.5})

print "test accuracy %g"%accuracy.eval(feed_dict={
    x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0})

9. tensorflow-deep_convolution.py

import input_data

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

import tensorflow as tf

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=[, , , ], padding='SAME')

def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[, , , ],
                          strides=[, , , ], padding='SAME')

sess = tf.InteractiveSession()

x = tf.placeholder("float", shape=[None, ])
y_ = tf.placeholder("float", shape=[None, ])

W_conv1 = weight_variable([, , , ])
b_conv1 = bias_variable([])

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

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

W_conv2 = weight_variable([, , , ])
b_conv2 = bias_variable([])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

W_fc1 = weight_variable([ *  * , ])
b_fc1 = bias_variable([])

h_pool2_flat = tf.reshape(h_pool2, [-,  *  * ])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

W_fc2 = weight_variable([, ])
b_fc2 = bias_variable([])

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

cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv, ), tf.argmax(y_, ))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

tf.summary.scalar('Training error', cross_entropy)
tf.summary.scalar('Training accuracy', accuracy)
tf.summary.scalar('sparsity', tf.nn.zero_fraction(h_fc1))

sess.run(tf.global_variables_initializer())

merged_summary_op = tf.summary.merge_all()
print merged_summary_op
summary_writer = tf.summary.FileWriter('./mnist_logs', sess.graph)

for i in range():
    batch = mnist.train.next_batch()
    sess.run(train_step, feed_dict={x: batch[], y_: batch[], keep_prob: 0.5})
    if i %  == :
        train_accuracy = accuracy.eval(feed_dict={
            x: batch[], y_: batch[], keep_prob: 1.0})
        print "step %d, training accuracy %g" % (i, train_accuracy)
        summary_str = sess.run(merged_summary_op, feed_dict={x: batch[], y_: batch[], keep_prob: 0.5})
        summary_writer.add_summary(summary_str, i)

print "test accuracy %g" % accuracy.eval(feed_dict={
    x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0})

aaarticlea/png;base64,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" alt="" />

0x2: 前馈神经网络（feed-forward neural network）：full connected MINST

1. 构建图表 （Build the Graph）

在为数据创建占位符之后，就可以运行mnist.py文件，经过三阶段的模式函数操作：inference()， loss()，和training()。图表就构建完成了

.inference() —— 尽可能地构建好图表，满足促使神经网络向前反馈并做出预测的要求
.loss() —— 往inference图表中添加生成损失（loss）所需要的操作（ops）
.training() —— 往损失图表中添加计算并应用梯度（gradients）所需的操作

推理（Inference）

inference()函数会尽可能地构建图表，做到返回包含了预测结果（output prediction）的Tensor。
它接受图像占位符为输入，在此基础上借助ReLu(Rectified Linear Units)激活函数，构建一对完全连接层（layers），以及一个有着十个节点（node）、指明了输出logtis模型的线性层。
每一层都创建于一个唯一的tf.name_scope之下，创建于该作用域之下的所有元素都将带有其前缀。

with tf.name_scope('hidden1') as scope:

在定义的作用域中，每一层所使用的权重和偏差都在tf.Variable实例中生成，并且包含了各自期望的shape

weights = tf.Variable(
    tf.truncated_normal([IMAGE_PIXELS, hidden1_units],
                        stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),
    name='weights')
biases = tf.Variable(tf.zeros([hidden1_units]),
                     name='biases')

例如，当这些层是在hidden1作用域下生成时，赋予权重变量的独特名称将会是"hidden1/weights"。
每个变量在构建时，都会获得初始化操作（initializer ops）。
在这种最常见的情况下，通过tf.truncated_normal函数初始化权重变量，给赋予的shape则是一个二维tensor，其中第一个维度代表该层中权重变量所连接（connect from）的单元数量，第二个维度代表该层中权重变量所连接到的（connect to）单元数量。对于名叫hidden1的第一层，相应的维度则是[IMAGE_PIXELS, hidden1_units](显然，第一层的输入是图像像素维度)，因为权重变量将图像输入连接到了hidden1层。tf.truncated_normal初始函数将根据所得到的均值和标准差，生成一个随机分布。
然后，通过tf.zeros函数初始化偏差变量（biases），确保所有偏差的起始值都是0，而它们的shape则是其在该层中所接到的（connect to）单元数量。
图表的三个主要操作，分别是两个tf.nn.relu操作，它们中嵌入了隐藏层所需的tf.matmul；以及logits模型所需的另外一个tf.matmul。三者依次生成，各自的tf.Variable实例则与输入占位符或下一层的输出tensor所连接

hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)
hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)
logits = tf.matmul(hidden2, weights) + biases

最后，程序会返回包含了输出结果的logitsTensor

损失（Loss）

loss()函数通过添加所需的损失操作，进一步构建图表。
首先，labels_placeholer中的值，将被编码为一个含有1-hot values的Tensor。例如，如果类标识符为“3”，那么该值就会被转换为：

[, , , , , , , , , ]

code

batch_size = tf.size(labels)
labels = tf.expand_dims(labels, )
indices = tf.expand_dims(tf.range(, batch_size, ), )
concated = tf.concat(, [indices, labels])
onehot_labels = tf.sparse_to_dense(
    concated, tf.pack([batch_size, NUM_CLASSES]), 1.0, 0.0)

之后，又添加一个tf.nn.softmax_cross_entropy_with_logits操作，用来比较inference()函数与1-hot标签所输出的logits Tensor。

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits,
                                                        onehot_labels,
                                                        name='xentropy')

然后，使用tf.reduce_mean函数，计算batch维度（第一维度）下交叉熵（cross entropy）的平均值，将将该值作为总损失。

loss = tf.reduce_mean(cross_entropy, name='xentropy_mean')

最后，程序会返回包含了损失值的Tensor。
注意：交叉熵是信息理论中的概念，可以让我们描述如果基于已有事实，相信神经网络所做的推测最坏会导致什么结果

训练

training()函数添加了通过梯度下降（gradient descent）将损失最小化所需的操作。
首先，该函数从loss()函数中获取损失Tensor，将其交给tf.scalar_summary，后者在与SummaryWriter（见下文）配合使用时，可以向事件文件（events file）中生成汇总值（summary values）。在实验中，每次写入汇总值时，它都会释放损失Tensor的当前值（snapshot value）

tf.scalar_summary(loss.op.name, loss)

接下来，我们实例化一个tf.train.GradientDescentOptimizer，负责按照所要求的学习效率（learning rate）应用梯度下降法（gradients）。

optimizer = tf.train.GradientDescentOptimizer(FLAGS.learning_rate)

之后，我们生成一个变量用于保存全局训练步骤（global training step）的数值，并使用minimize()函数更新系统中的三角权重（triangle weights）、增加全局步骤的操作。根据惯例，这个操作被称为 train_op，是TensorFlow会话（session）诱发一个完整训练步骤所必须运行的操作

global_step = tf.Variable(, name='global_step', trainable=False)
train_op = optimizer.minimize(loss, global_step=global_step)

最后，程序返回包含了训练操作（training op）输出结果的Tensor

2. 训练模型

一旦图表构建完毕，就通过fully_connected_feed.py文件中的用户代码进行循环地迭代式训练和评估

3. 训练循环

完成会话中变量的初始化之后，就可以开始训练了。
训练的每一步都是通过用户代码控制，而能实现有效训练的最简单循环就是：

for step in xrange(max_steps):
    sess.run(train_op)

向图表提供反馈(根据误差逐级传递)

执行每一步时，我们的代码会生成一个反馈字典（feed dictionary），其中包含对应步骤中训练所要使用的例子，这些例子的哈希键就是其所代表的占位符操作。
fill_feed_dict函数会查询给定的DataSet，索要下一批次batch_size的图像和标签，与占位符相匹配的Tensor则会包含下一批次的图像和标签。

images_feed, labels_feed = data_set.next_batch(FLAGS.batch_size)

然后，以占位符为哈希键，创建一个Python字典对象，键值则是其代表的反馈Tensor

feed_dict = {
    images_placeholder: images_feed,
    labels_placeholder: labels_feed,
}

这个字典随后作为feed_dict参数，传入sess.run()函数中，为这一步的训练提供输入样例

这里简单理解一下前向反馈

前馈就是信号向前传递的意思。BP网络的前馈表现为输入信号从输入层（输入层不参加计算）开始，每一层的神经元计算出该层各神经元的输出并向下一层传递直到输出层计算出网络的输出结果，前馈只是用于计算出网络的输出，不对网络的参数进行调整。误差反向传播用于训练时网络权值和阈值的调整。网络前向传播计算出来的结果与实际的结果存在误差，在离线训练时，这时网络采用批量训练方法计算出整个样本数据的总误差，然后从输出层开始向前推，一般采用梯度下降法逐层求出每一层神经元的阈值和权值的调增量，循环迭代到网络参数符合要求停止 

检查状态

在运行sess.run函数时，要在代码中明确其需要获取的两个值：[train_op, loss]

for step in xrange(FLAGS.max_steps):
    feed_dict = fill_feed_dict(data_sets.train,
                               images_placeholder,
                               labels_placeholder)
    _, loss_value = sess.run([train_op, loss],
                             feed_dict=feed_dict)

因为要获取这两个值，sess.run()会返回一个有两个元素的元组。其中每一个Tensor对象，对应了返回的元组中的numpy数组，而这些数组中包含了当前这步训练中对应Tensor的值。由于train_op并不会产生输出，其在返回的元祖中的对应元素就是None，所以会被抛弃。但是，如果模型在训练中出现偏差，loss Tensor的值可能会变成NaN，所以我们要获取它的值，并记录下来。
假设训练一切正常，没有出现NaN，训练循环会每隔100个训练步骤，就打印一行简单的状态文本，告知用户当前的训练状态

if step %  == :
    print 'Step %d: loss = %.2f (%.3f sec)' % (step, loss_value, duration)

状态可视化

为了释放TensorBoard所使用的事件文件（events file），所有的即时数据（在这里只有一个）都要在图表构建阶段合并至一个操作（op）中

summary_op = tf.merge_all_summaries()

在创建好会话（session）之后，可以实例化一个tf.train.SummaryWriter，用于写入包含了图表本身和即时数据具体值的事件文件

summary_writer = tf.train.SummaryWriter(FLAGS.train_dir,
                                        graph_def=sess.graph_def)

最后，每次运行summary_op时，都会往事件文件中写入最新的即时数据，函数的输出会传入事件文件读写器（writer）的add_summary()函数。

summary_str = sess.run(summary_op, feed_dict=feed_dict)
summary_writer.add_summary(summary_str, step)

事件文件写入完毕之后，可以就训练文件夹打开一个TensorBoard，查看即时数据的情况

保存检查点（checkpoint）

为了得到可以用来后续恢复模型以进一步训练或评估的检查点文件（checkpoint file），我们实例化一个tf.train.Saver

saver = tf.train.Saver()

在训练循环中，将定期调用saver.save()方法，向训练文件夹中写入包含了当前所有可训练变量值得检查点文件

saver.save(sess, FLAGS.train_dir, global_step=step)

这样，我们以后就可以使用saver.restore()方法，重载模型的参数，继续训练

saver.restore(sess, FLAGS.train_dir)

4. 评估模型

每隔一千个训练步骤，我们的代码会尝试使用训练数据集与测试数据集，对模型进行评估。do_eval函数会被调用三次，分别使用训练数据集、验证数据集合测试数据集

print 'Training Data Eval:'
do_eval(sess,
        eval_correct,
        images_placeholder,
        labels_placeholder,
        data_sets.train)
print 'Validation Data Eval:'
do_eval(sess,
        eval_correct,
        images_placeholder,
        labels_placeholder,
        data_sets.validation)
print 'Test Data Eval:'
do_eval(sess,
        eval_correct,
        images_placeholder,
        labels_placeholder,
        data_sets.test)

5. fully_connected_feed.py

# Copyright  The TensorFlow Authors. 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.
# ==============================================================================

"""Trains and Evaluates the MNIST network using a feed dictionary."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

# pylint: disable=missing-docstring
import argparse
import os.path
import sys
import time

from six.moves import xrange  # pylint: disable=redefined-builtin
import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.examples.tutorials.mnist import mnist

# Basic model parameters as external flags.
FLAGS = None

def placeholder_inputs(batch_size):
  """Generate placeholder variables to represent the input tensors.
  These placeholders are used as inputs by the rest of the model building
  code and will be fed from the downloaded data in the .run() loop, below.
  Args:
    batch_size: The batch size will be baked into both placeholders.
  Returns:
    images_placeholder: Images placeholder.
    labels_placeholder: Labels placeholder.
  """
  # Note that the shapes of the placeholders match the shapes of the full
  # image and label tensors, except the first dimension is now batch_size
  # rather than the full size of the train or test data sets.
  images_placeholder = tf.placeholder(tf.float32, shape=(batch_size,
                                                         mnist.IMAGE_PIXELS))
  labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size))
  return images_placeholder, labels_placeholder

def fill_feed_dict(data_set, images_pl, labels_pl):
  """Fills the feed_dict for training the given step.
  A feed_dict takes the form of:
  feed_dict = {
      <placeholder>: <tensor of values to be passed for placeholder>,
      ....
  }
  Args:
    data_set: The set of images and labels, from input_data.read_data_sets()
    images_pl: The images placeholder, from placeholder_inputs().
    labels_pl: The labels placeholder, from placeholder_inputs().
  Returns:
    feed_dict: The feed dictionary mapping from placeholders to values.
  """
  # Create the feed_dict for the placeholders filled with the next
  # `batch size` examples.
  images_feed, labels_feed = data_set.next_batch(FLAGS.batch_size,
                                                 FLAGS.fake_data)
  feed_dict = {
      images_pl: images_feed,
      labels_pl: labels_feed,
  }
  return feed_dict

def do_eval(sess,
            eval_correct,
            images_placeholder,
            labels_placeholder,
            data_set):
  """Runs one evaluation against the full epoch of data.
  Args:
    sess: The session in which the model has been trained.
    eval_correct: The Tensor that returns the number of correct predictions.
    images_placeholder: The images placeholder.
    labels_placeholder: The labels placeholder.
    data_set: The set of images and labels to evaluate, from
      input_data.read_data_sets().
  """
  # And run one epoch of eval.
  true_count =   # Counts the number of correct predictions.
  steps_per_epoch = data_set.num_examples // FLAGS.batch_size
  num_examples = steps_per_epoch * FLAGS.batch_size
  for step in xrange(steps_per_epoch):
    feed_dict = fill_feed_dict(data_set,
                               images_placeholder,
                               labels_placeholder)
    true_count += sess.run(eval_correct, feed_dict=feed_dict)
  precision = float(true_count) / num_examples
  print('  Num examples: %d  Num correct: %d  Precision @ 1: %0.04f' %
        (num_examples, true_count, precision))

def run_training():
  """Train MNIST for a number of steps."""
  # Get the sets of images and labels for training, validation, and
  # test on MNIST.
  data_sets = input_data.read_data_sets(FLAGS.input_data_dir, FLAGS.fake_data)

  # Tell TensorFlow that the model will be built into the default Graph.
  with tf.Graph().as_default():
    # Generate placeholders for the images and labels.
    images_placeholder, labels_placeholder = placeholder_inputs(
        FLAGS.batch_size)

    # Build a Graph that computes predictions from the inference model.
    logits = mnist.inference(images_placeholder,
                             FLAGS.hidden1,
                             FLAGS.hidden2)

    # Add to the Graph the Ops for loss calculation.
    loss = mnist.loss(logits, labels_placeholder)

    # Add to the Graph the Ops that calculate and apply gradients.
    train_op = mnist.training(loss, FLAGS.learning_rate)

    # Add the Op to compare the logits to the labels during evaluation.
    eval_correct = mnist.evaluation(logits, labels_placeholder)

    # Build the summary Tensor based on the TF collection of Summaries.
    summary = tf.summary.merge_all()

    # Add the variable initializer Op.
    init = tf.global_variables_initializer()

    # Create a saver for writing training checkpoints.
    saver = tf.train.Saver()

    # Create a session for running Ops on the Graph.
    sess = tf.Session()

    # Instantiate a SummaryWriter to output summaries and the Graph.
    summary_writer = tf.summary.FileWriter(FLAGS.log_dir, sess.graph)

    # And then after everything is built:

    # Run the Op to initialize the variables.
    sess.run(init)

    # Start the training loop.
    for step in xrange(FLAGS.max_steps):
      start_time = time.time()

      # Fill a feed dictionary with the actual set of images and labels
      # for this particular training step.
      feed_dict = fill_feed_dict(data_sets.train,
                                 images_placeholder,
                                 labels_placeholder)

      # Run one step of the model.  The return values are the activations
      # from the `train_op` (which is discarded) and the `loss` Op.  To
      # inspect the values of your Ops or variables, you may include them
      # in the list passed to sess.run() and the value tensors will be
      # returned in the tuple from the call.
      _, loss_value = sess.run([train_op, loss],
                               feed_dict=feed_dict)

      duration = time.time() - start_time

      # Write the summaries and print an overview fairly often.
      if step %  == :
        # Print status to stdout.
        print('Step %d: loss = %.2f (%.3f sec)' % (step, loss_value, duration))
        # Update the events file.
        summary_str = sess.run(summary, feed_dict=feed_dict)
        summary_writer.add_summary(summary_str, step)
        summary_writer.flush()

      # Save a checkpoint and evaluate the model periodically.
      if (step + ) %  ==  or (step + ) == FLAGS.max_steps:
        checkpoint_file = os.path.join(FLAGS.log_dir, 'model.ckpt')
        saver.save(sess, checkpoint_file, global_step=step)
        # Evaluate against the training set.
        print('Training Data Eval:')
        do_eval(sess,
                eval_correct,
                images_placeholder,
                labels_placeholder,
                data_sets.train)
        # Evaluate against the validation set.
        print('Validation Data Eval:')
        do_eval(sess,
                eval_correct,
                images_placeholder,
                labels_placeholder,
                data_sets.validation)
        # Evaluate against the test set.
        print('Test Data Eval:')
        do_eval(sess,
                eval_correct,
                images_placeholder,
                labels_placeholder,
                data_sets.test)

def main(_):
  if tf.gfile.Exists(FLAGS.log_dir):
    tf.gfile.DeleteRecursively(FLAGS.log_dir)
  tf.gfile.MakeDirs(FLAGS.log_dir)
  run_training()

if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument(
      '--learning_rate',
      type=float,
      default=0.01,
      help='Initial learning rate.'
  )
  parser.add_argument(
      '--max_steps',
      type=int,
      default=,
      help='Number of steps to run trainer.'
  )
  parser.add_argument(
      '--hidden1',
      type=int,
      default=,
      help='Number of units in hidden layer 1.'
  )
  parser.add_argument(
      '--hidden2',
      type=int,
      default=,
      help='Number of units in hidden layer 2.'
  )
  parser.add_argument(
      '--batch_size',
      type=int,
      default=,
      help='Batch size.  Must divide evenly into the dataset sizes.'
  )
  parser.add_argument(
      '--input_data_dir',
      type=str,
      default='MNIST_data/',
      help='Directory to put the input data.'
  )
  parser.add_argument(
      '--log_dir',
      type=str,
      default='./mnist_logs',
      help='Directory to put the log data.'
  )
  parser.add_argument(
      '--fake_data',
      default=False,
      help='If true, uses fake data for unit testing.',
      action='store_true'
  )

  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[]] + unparsed)

Relevant Link:

http://www.tensorfly.cn/tfdoc/tutorials/mnist_pros.html
http://www.tensorfly.cn/tfdoc/tutorials/mnist_tf.html

4. 卷积神经网络：CIFAR-10 数据集分类（将像素空间通卷积扩展到高维空间，输入CNN进行计算）

对CIFAR-10 数据集的分类是机器学习中一个公开的基准测试问题，其任务是对一组32x32RGB的图像进行分类，这些图像涵盖了10个类别：

飞机， 汽车， 鸟， 猫， 鹿， 狗， 青蛙， 马， 船以及卡车

0x1: 模型架构

本教程中的模型是一个多层架构，由卷积层和非线性层(nonlinearities)交替多次排列后构成。这些层最终通过全连通层对接到softmax分类器上

1. 模型输入

输入模型是通过 inputs() 和distorted_inputs()函数建立起来的，这2个函数会从CIFAR-10二进制文件中读取图片文件，由于每个图片的存储字节数是固定的，因此可以使用tf.FixedLengthRecordReader函数

图片文件的处理流程如下

图片会被统一裁剪到24x24像素大小，裁剪中央区域用于评估或随机裁剪用于训练；
图片会进行近似的白化处理，使得模型对图片的动态范围变化不敏感(让识别模型对图像的亮度等因素不敏感)

对于训练，我们另外采取了一系列随机变换的方法来人为的增加数据集的大小

对图像进行随机的左右翻转；
随机变换图像的亮度；
随机变换图像的对比度；

2. 模型预测

模型的预测流程由inference()构造，该函数会添加必要的操作步骤用于计算预测值的 logits，其对应的模型组织方式如下所示：

conv1    实现卷积 以及 rectified linear activation.
pool1    max pooling.
norm1    局部响应归一化.
conv2    卷积 and rectified linear activation.
norm2    局部响应归一化.
pool2    max pooling.
local3    基于修正线性激活的全连接层.
local4    基于修正线性激活的全连接层.
softmax_linear    进行线性变换以输出 logits.

0x2: 模型训练

训练一个可进行N维分类的网络的常用方法是使用多项式逻辑回归,又被叫做softmax 回归。Softmax 回归在网络的输出层上附加了一个softmax nonlinearity，并且计算归一化的预测值和label的1-hot encoding的交叉熵。在正则化过程中，我们会对所有学习变量应用权重衰减损失(和手写文字识别类似，图像识别的本质就是对应某个形状的物理对应该区域的权重相应较高，这也是人识别图像甚至畸形图像的本质道理)。模型的目标函数是求交叉熵损失和所有权重衰减项的和，loss()函数的返回值就是这个值。

train() 函数会添加一些操作使得目标函数最小化，这些操作包括计算梯度、更新学习变量(GradientDescentOptimizer)。train() 函数最终会返回一个用以对一批图像执行所有计算的操作步骤，以便训练并更新模型。

0x3: 开始执行并训练模型

cifar10_train.py输出的终端信息中提供了关于模型如何训练的一些信息，比如

损失是真的在减小还是看到的只是噪声数据？
为模型提供的图片是否合适？
梯度、激活、权重的值是否合理？
当前的学习率是多少？

相比于总损失，在训练过程中的单项损失尤其值得人们的注意。但是由于训练中使用的数据批量比较小，损失值中夹杂了相当多的噪声。在实践过程中，我们也发现相比于原始值，损失值的移动平均值显得更为有意义

cifar10.py

# Copyright  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.
# ==============================================================================

"""Builds the CIFAR-10 network.

Summary of available functions:

 # Compute input images and labels for training. If you would like to run
 # evaluations, use inputs() instead.
 inputs, labels = distorted_inputs()

 # Compute inference on the model inputs to make a prediction.
 predictions = inference(inputs)

 # Compute the total loss of the prediction with respect to the labels.
 loss = loss(predictions, labels)

 # Create a graph to run one step of training with respect to the loss.
 train_op = train(loss, global_step)
"""
# pylint: disable=missing-docstring
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import gzip
import os
import re
import sys
import tarfile

from six.moves import urllib
import tensorflow as tf

import cifar10_input

FLAGS = tf.app.flags.FLAGS

# Basic model parameters.
tf.app.flags.DEFINE_integer('batch_size', ,
                            """Number of images to process in a batch.""")
tf.app.flags.DEFINE_string('data_dir', './cifar10_data',
                           """Path to the CIFAR-10 data directory.""")

# Global constants describing the CIFAR- data set.
IMAGE_SIZE = cifar10_input.IMAGE_SIZE
NUM_CLASSES = cifar10_input.NUM_CLASSES
NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN = cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN
NUM_EXAMPLES_PER_EPOCH_FOR_EVAL = cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL

# Constants describing the training process.
MOVING_AVERAGE_DECAY = 0.9999     # The decay to use for the moving average.
NUM_EPOCHS_PER_DECAY = 350.0      # Epochs after which learning rate decays.
LEARNING_RATE_DECAY_FACTOR = 0.1  # Learning rate decay factor.
INITIAL_LEARNING_RATE = 0.1       # Initial learning rate.

# If a model is trained with multiple GPU's prefix all Op names with tower_name
# to differentiate the operations. Note that this prefix is removed from the
# names of the summaries when visualizing a model.
TOWER_NAME = 'tower'

DATA_URL = 'http://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz'

def _activation_summary(x):
  """Helper to create summaries for activations.

  Creates a summary that provides a histogram of activations.
  Creates a summary that measure the sparsity of activations.

  Args:
    x: Tensor
  Returns:
    nothing
  """
  # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training
  # session. This helps the clarity of presentation on tensorboard.
  tensor_name = re.sub('%s_[0-9]*/' % TOWER_NAME, '', x.op.name)
  tf.summary.histogram(tensor_name + '/activations', x)
  tf.summary.scalar(tensor_name + '/sparsity', tf.nn.zero_fraction(x))

def _variable_on_cpu(name, shape, initializer):
  """Helper to create a Variable stored on CPU memory.

  Args:
    name: name of the variable
    shape: list of ints
    initializer: initializer for Variable

  Returns:
    Variable Tensor
  """
  with tf.device('/cpu:0'):
    var = tf.get_variable(name, shape, initializer=initializer)
  return var

def _variable_with_weight_decay(name, shape, stddev, wd):
  """Helper to create an initialized Variable with weight decay.

  Note that the Variable is initialized with a truncated normal distribution.
  A weight decay is added only if one is specified.

  Args:
    name: name of the variable
    shape: list of ints
    stddev: standard deviation of a truncated Gaussian
    wd: add L2Loss weight decay multiplied by this float. If None, weight
        decay is not added for this Variable.

  Returns:
    Variable Tensor
  """
  var = _variable_on_cpu(name, shape,
                         tf.truncated_normal_initializer(stddev=stddev))
  if wd:
    weight_decay = tf.multiply(tf.nn.l2_loss(var), wd, name='weight_loss')
    tf.add_to_collection('losses', weight_decay)
  return var

def distorted_inputs():
  """Construct distorted input for CIFAR training using the Reader ops.

  Returns:
    images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, ] size.
    labels: Labels. 1D tensor of [batch_size] size.

  Raises:
    ValueError: If no data_dir
  """
  if not FLAGS.data_dir:
    raise ValueError('Please supply a data_dir')
  data_dir = os.path.join(FLAGS.data_dir, 'cifar-10-batches-bin')
  return cifar10_input.distorted_inputs(data_dir=data_dir,
                                        batch_size=FLAGS.batch_size)

def inputs(eval_data):
  """Construct input for CIFAR evaluation using the Reader ops.

  Args:
    eval_data: bool, indicating if one should use the train or eval data set.

  Returns:
    images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, ] size.
    labels: Labels. 1D tensor of [batch_size] size.

  Raises:
    ValueError: If no data_dir
  """
  if not FLAGS.data_dir:
    raise ValueError('Please supply a data_dir')
  data_dir = os.path.join(FLAGS.data_dir, 'cifar-10-batches-bin')
  return cifar10_input.inputs(eval_data=eval_data, data_dir=data_dir,
                              batch_size=FLAGS.batch_size)

def inference(images):
  """Build the CIFAR-10 model.

  Args:
    images: Images returned from distorted_inputs() or inputs().

  Returns:
    Logits.
  """
  # We instantiate all variables using tf.get_variable() instead of
  # tf.Variable() in order to share variables across multiple GPU training runs.
  # If we only ran this model on a single GPU, we could simplify this function
  # by replacing all instances of tf.get_variable() with tf.Variable().
  #
  # conv1
  with tf.variable_scope('conv1') as scope:
    kernel = _variable_with_weight_decay('weights', shape=[, , , ],
                                         stddev=1e-, wd=0.0)
    conv = tf.nn.conv2d(images, kernel, [, , , ], padding='SAME')
    biases = _variable_on_cpu('biases', [], tf.constant_initializer(0.0))
    bias = tf.nn.bias_add(conv, biases)
    conv1 = tf.nn.relu(bias, name=scope.name)
    _activation_summary(conv1)

  # pool1
  pool1 = tf.nn.max_pool(conv1, ksize=[, , , ], strides=[, , , ],
                         padding='SAME', name='pool1')
  # norm1
  norm1 = tf.nn.lrn(pool1, , bias=1.0, alpha=0.001 / 9.0, beta=0.75,
                    name='norm1')

  # conv2
  with tf.variable_scope('conv2') as scope:
    kernel = _variable_with_weight_decay('weights', shape=[, , , ],
                                         stddev=1e-, wd=0.0)
    conv = tf.nn.conv2d(norm1, kernel, [, , , ], padding='SAME')
    biases = _variable_on_cpu('biases', [], tf.constant_initializer(0.1))
    bias = tf.nn.bias_add(conv, biases)
    conv2 = tf.nn.relu(bias, name=scope.name)
    _activation_summary(conv2)

  # norm2
  norm2 = tf.nn.lrn(conv2, , bias=1.0, alpha=0.001 / 9.0, beta=0.75,
                    name='norm2')
  # pool2
  pool2 = tf.nn.max_pool(norm2, ksize=[, , , ],
                         strides=[, , , ], padding='SAME', name='pool2')

  # local3
  with tf.variable_scope('local3') as scope:
    # Move everything into depth so we can perform a single matrix multiply.
    dim =
    for d in pool2.get_shape()[:].as_list():
      dim *= d
    reshape = tf.reshape(pool2, [FLAGS.batch_size, dim])

    weights = _variable_with_weight_decay('weights', shape=[dim, ],
                                          stddev=0.04, wd=0.004)
    biases = _variable_on_cpu('biases', [], tf.constant_initializer(0.1))
    local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
    _activation_summary(local3)

  # local4
  with tf.variable_scope('local4') as scope:
    weights = _variable_with_weight_decay('weights', shape=[, ],
                                          stddev=0.04, wd=0.004)
    biases = _variable_on_cpu('biases', [], tf.constant_initializer(0.1))
    local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name=scope.name)
    _activation_summary(local4)

  # softmax, i.e. softmax(WX + b)
  with tf.variable_scope('softmax_linear') as scope:
    weights = _variable_with_weight_decay('weights', [, NUM_CLASSES],
                                          stddev=/192.0, wd=0.0)
    biases = _variable_on_cpu('biases', [NUM_CLASSES],
                              tf.constant_initializer(0.0))
    softmax_linear = tf.add(tf.matmul(local4, weights), biases, name=scope.name)
    _activation_summary(softmax_linear)

  return softmax_linear

def loss(logits, labels):
  """Add L2Loss to all the trainable variables.

  Add summary for for "Loss" and "Loss/avg".
  Args:
    logits: Logits from inference().
    labels: Labels from distorted_inputs or inputs(). -D tensor
            of shape [batch_size]

  Returns:
    Loss tensor of type float.
  """
  # Calculate the average cross entropy loss across the batch.
  labels = tf.cast(labels, tf.int64)
  cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
      logits=logits, labels=labels, name='cross_entropy_per_example')
  cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy')
  tf.add_to_collection('losses', cross_entropy_mean)

  # The total loss is defined as the cross entropy loss plus all of the weight
  # decay terms (L2 loss).
  return tf.add_n(tf.get_collection('losses'), name='total_loss')

def _add_loss_summaries(total_loss):
  """Add summaries for losses in CIFAR-10 model.

  Generates moving average for all losses and associated summaries for
  visualizing the performance of the network.

  Args:
    total_loss: Total loss from loss().
  Returns:
    loss_averages_op: op for generating moving averages of losses.
  """
  # Compute the moving average of all individual losses and the total loss.
  loss_averages = tf.train.ExponentialMovingAverage(0.9, name='avg')
  losses = tf.get_collection('losses')
  loss_averages_op = loss_averages.apply(losses + [total_loss])

  # Attach a scalar summary to all individual losses and the total loss; do the
  # same for the averaged version of the losses.
  for l in losses + [total_loss]:
    # Name each loss as '(raw)' and name the moving average version of the loss
    # as the original loss name.
    tf.summary.scalar(l.op.name +' (raw)', l)
    tf.summary.scalar(l.op.name, loss_averages.average(l))

  return loss_averages_op

def train(total_loss, global_step):
  """Train CIFAR-10 model.

  Create an optimizer and apply to all trainable variables. Add moving
  average for all trainable variables.

  Args:
    total_loss: Total loss from loss().
    global_step: Integer Variable counting the number of training steps
      processed.
  Returns:
    train_op: op for training.
  """
  # Variables that affect learning rate.
  num_batches_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN / FLAGS.batch_size
  decay_steps = int(num_batches_per_epoch * NUM_EPOCHS_PER_DECAY)

  # Decay the learning rate exponentially based on the number of steps.
  lr = tf.train.exponential_decay(INITIAL_LEARNING_RATE,
                                  global_step,
                                  decay_steps,
                                  LEARNING_RATE_DECAY_FACTOR,
                                  staircase=True)
  tf.summary.scalar('learning_rate', lr)

  # Generate moving averages of all losses and associated summaries.
  loss_averages_op = _add_loss_summaries(total_loss)

  # Compute gradients.
  with tf.control_dependencies([loss_averages_op]):
    opt = tf.train.GradientDescentOptimizer(lr)
    grads = opt.compute_gradients(total_loss)

  # Apply gradients.
  apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)

  # Add histograms for trainable variables.
  for var in tf.trainable_variables():
      tf.summary.histogram(var.op.name, var)

  # Add histograms for gradients.
  for grad, var in grads:
    if grad is not None:
        tf.summary.histogram(var.op.name + '/gradients', grad)

  # Track the moving averages of all trainable variables.
  variable_averages = tf.train.ExponentialMovingAverage(
      MOVING_AVERAGE_DECAY, global_step)
  variables_averages_op = variable_averages.apply(tf.trainable_variables())

  with tf.control_dependencies([apply_gradient_op, variables_averages_op]):
    train_op = tf.no_op(name='train')

  return train_op

def maybe_download_and_extract():
  """Download and extract the tarball from Alex's website."""
  dest_directory = FLAGS.data_dir
  if not os.path.exists(dest_directory):
    os.makedirs(dest_directory)
  filename = DATA_URL.split('/')[-]
  filepath = os.path.join(dest_directory, filename)
  if not os.path.exists(filepath):
    def _progress(count, block_size, total_size):
      sys.stdout.write('\r>> Downloading %s %.1f%%' % (filename,
          float(count * block_size) / float(total_size) * 100.0))
      sys.stdout.flush()
    filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath,
                                             reporthook=_progress)
    print()
    statinfo = os.stat(filepath)
    print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')
    tarfile.open(filepath, 'r:gz').extractall(dest_directory)

cifar10_train.py

# Copyright  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.
# ==============================================================================

"""A binary to train CIFAR-10 using a single GPU.

Accuracy:
cifar10_train.py achieves ~% accuracy after 100K steps ( epochs of
data) as judged by cifar10_eval.py.

Speed: With batch_size .

System        | Step Time (sec/batch)  |     Accuracy
------------------------------------------------------------------
 Tesla K20m  | 0.35-0.60              | ~% at 60K steps  ( hours)
 Tesla K40m  | 0.25-0.35              | ~% at 100K steps ( hours)

Usage:
Please see the tutorial and website for how to download the CIFAR-
data set, compile the program and train the model.

http://tensorflow.org/tutorials/deep_cnn/
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from datetime import datetime
import os.path
import time

import numpy as np
from six.moves import xrange  # pylint: disable=redefined-builtin
import tensorflow as tf

import cifar10

FLAGS = tf.app.flags.FLAGS

tf.app.flags.DEFINE_string('train_dir', './cifar10_train',
                           """Directory where to write event logs """
                           """and checkpoint.""")
tf.app.flags.DEFINE_integer('max_steps', ,
                            """Number of batches to run.""")
tf.app.flags.DEFINE_boolean('log_device_placement', False,
                            """Whether to log device placement.""")

def train():
  """Train CIFAR-10 for a number of steps."""
  with tf.Graph().as_default():
    global_step = tf.Variable(, trainable=False)

    # Get images and labels for CIFAR-.
    images, labels = cifar10.distorted_inputs()

    # Build a Graph that computes the logits predictions from the
    # inference model.
    logits = cifar10.inference(images)

    # Calculate loss.
    loss = cifar10.loss(logits, labels)

    # Build a Graph that trains the model with one batch of examples and
    # updates the model parameters.
    train_op = cifar10.train(loss, global_step)

    # Create a saver.
    saver = tf.train.Saver(tf.global_variables())

    # Build the summary operation based on the TF collection of Summaries.
    summary_op = tf.summary.merge_all()

    # Build an initialization operation to run below.
    init = tf.global_variables_initializer()

    # Start running operations on the Graph.
    sess = tf.Session(config=tf.ConfigProto(
        log_device_placement=FLAGS.log_device_placement))
    sess.run(init)

    # Start the queue runners.
    tf.train.start_queue_runners(sess=sess)

    summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
                                            graph=sess.graph)

    for step in xrange(FLAGS.max_steps):
      start_time = time.time()
      _, loss_value = sess.run([train_op, loss])
      duration = time.time() - start_time

      assert not np.isnan(loss_value), 'Model diverged with loss = NaN'

      if step %  == :
        num_examples_per_step = FLAGS.batch_size
        examples_per_sec = num_examples_per_step / duration
        sec_per_batch = float(duration)

        format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '
                      'sec/batch)')
        print (format_str % (datetime.now(), step, loss_value,
                             examples_per_sec, sec_per_batch))

      if step %  == :
        summary_str = sess.run(summary_op)
        summary_writer.add_summary(summary_str, step)

      # Save the model checkpoint periodically.
      if step %  ==  or (step + ) == FLAGS.max_steps:
        checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt')
        saver.save(sess, checkpoint_path, global_step=step)

def main(argv=None):  # pylint: disable=unused-argument
  cifar10.maybe_download_and_extract()
  if tf.gfile.Exists(FLAGS.train_dir):
    tf.gfile.DeleteRecursively(FLAGS.train_dir)
  tf.gfile.MakeDirs(FLAGS.train_dir)
  train()

if __name__ == '__main__':
  tf.app.run()

cifar10_input.py

# Copyright  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.
# ==============================================================================

"""Routine for decoding the CIFAR-10 binary file format."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os

from six.moves import xrange  # pylint: disable=redefined-builtin
import tensorflow as tf

# Process images of this size. Note that this differs from the original CIFAR
# image size of  x . If one alters this number, then the entire model
# architecture will change and any model would need to be retrained.
IMAGE_SIZE = 

# Global constants describing the CIFAR- data set.
NUM_CLASSES =
NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN =
NUM_EXAMPLES_PER_EPOCH_FOR_EVAL = 

def read_cifar10(filename_queue):
  """Reads and parses examples from CIFAR10 data files.

  Recommendation: if you want N-way read parallelism, call this function
  N times.  This will give you N independent Readers reading different
  files & positions within those files, which will give better mixing of
  examples.

  Args:
    filename_queue: A queue of strings with the filenames to read from.

  Returns:
    An object representing a single example, with the following fields:
      height: number of rows in the result ()
      width: number of columns in the result ()
      depth: number of color channels in the result ()
      key: a scalar string Tensor describing the filename & record number
        for this example.
      label: an int32 Tensor with the label in the range ...
      uint8image: a [height, width, depth] uint8 Tensor with the image data
  """

  class CIFAR10Record(object):
    pass
  result = CIFAR10Record()

  # Dimensions of the images in the CIFAR- dataset.
  # See http://www.cs.toronto.edu/~kriz/cifar.html for a description of the
  # input format.
  label_bytes =   #  for CIFAR-
  result.height =
  result.width =
  result.depth =
  image_bytes = result.height * result.width * result.depth
  # Every record consists of a label followed by the image, with a
  # fixed number of bytes for each.
  record_bytes = label_bytes + image_bytes

  # Read a record, getting filenames from the filename_queue.  No
  # header or footer in the CIFAR- format, so we leave header_bytes
  # and footer_bytes at their default of .
  reader = tf.FixedLengthRecordReader(record_bytes=record_bytes)
  result.key, value = reader.read(filename_queue)

  # Convert from a string to a vector of uint8 that is record_bytes long.
  record_bytes = tf.decode_raw(value, tf.uint8)

  # The first bytes represent the label, which we convert from uint8->int32.
  result.label = tf.cast(
      tf.slice(record_bytes, [], [label_bytes]), tf.int32)

  # The remaining bytes after the label represent the image, which we reshape
  # from [depth * height * width] to [depth, height, width].
  depth_major = tf.reshape(tf.slice(record_bytes, [label_bytes], [image_bytes]),
                           [result.depth, result.height, result.width])
  # Convert from [depth, height, width] to [height, width, depth].
  result.uint8image = tf.transpose(depth_major, [, , ])

  return result

def _generate_image_and_label_batch(image, label, min_queue_examples,
                                    batch_size):
  """Construct a queued batch of images and labels.

  Args:
    image: -D Tensor of [height, width, ] of type.float32.
    label: -D Tensor of type.int32
    min_queue_examples: int32, minimum number of samples to retain
      in the queue that provides of batches of examples.
    batch_size: Number of images per batch.

  Returns:
    images: Images. 4D tensor of [batch_size, height, width, ] size.
    labels: Labels. 1D tensor of [batch_size] size.
  """
  # Create a queue that shuffles the examples, and then
  # read 'batch_size' images + labels from the example queue.
  num_preprocess_threads =
  images, label_batch = tf.train.shuffle_batch(
      [image, label],
      batch_size=batch_size,
      num_threads=num_preprocess_threads,
      capacity=min_queue_examples +  * batch_size,
      min_after_dequeue=min_queue_examples)

  # Display the training images in the visualizer.
  tf.summary.image('images', images)

  return images, tf.reshape(label_batch, [batch_size])

def distorted_inputs(data_dir, batch_size):
  """Construct distorted input for CIFAR training using the Reader ops.

  Args:
    data_dir: Path to the CIFAR- data directory.
    batch_size: Number of images per batch.

  Returns:
    images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, ] size.
    labels: Labels. 1D tensor of [batch_size] size.
  """
  filenames = [os.path.join(data_dir, 'data_batch_%d.bin' % i)
               for i in xrange(, )]
  for f in filenames:
    if not tf.gfile.Exists(f):
      raise ValueError('Failed to find file: ' + f)

  # Create a queue that produces the filenames to read.
  filename_queue = tf.train.string_input_producer(filenames)

  # Read examples from files in the filename queue.
  read_input = read_cifar10(filename_queue)
  reshaped_image = tf.cast(read_input.uint8image, tf.float32)

  height = IMAGE_SIZE
  width = IMAGE_SIZE

  # Image processing for training the network. Note the many random
  # distortions applied to the image.

  # Randomly crop a [height, width] section of the image.
  distorted_image = tf.random_crop(reshaped_image, [height, width, ])

  # Randomly flip the image horizontally.
  distorted_image = tf.image.random_flip_left_right(distorted_image)

  # Because these operations are not commutative, consider randomizing
  # randomize the order their operation.
  distorted_image = tf.image.random_brightness(distorted_image,
                                               max_delta=)
  distorted_image = tf.image.random_contrast(distorted_image,
                                             lower=0.2, upper=1.8)

  # Subtract off the mean and divide by the variance of the pixels.
  float_image = tf.image.per_image_standardization(distorted_image)

  # Ensure that the random shuffling has good mixing properties.
  min_fraction_of_examples_in_queue = 0.4
  min_queue_examples = int(NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN *
                           min_fraction_of_examples_in_queue)
  print ('Filling queue with %d CIFAR images before starting to train. '
         'This will take a few minutes.' % min_queue_examples)

  # Generate a batch of images and labels by building up a queue of examples.
  return _generate_image_and_label_batch(float_image, read_input.label,
                                         min_queue_examples, batch_size)

def inputs(eval_data, data_dir, batch_size):
  """Construct input for CIFAR evaluation using the Reader ops.

  Args:
    eval_data: bool, indicating if one should use the train or eval data set.
    data_dir: Path to the CIFAR- data directory.
    batch_size: Number of images per batch.

  Returns:
    images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, ] size.
    labels: Labels. 1D tensor of [batch_size] size.
  """
  if not eval_data:
    filenames = [os.path.join(data_dir, 'data_batch_%d.bin' % i)
                 for i in xrange(, )]
    num_examples_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN
  else:
    filenames = [os.path.join(data_dir, 'test_batch.bin')]
    num_examples_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_EVAL

  for f in filenames:
    if not tf.gfile.Exists(f):
      raise ValueError('Failed to find file: ' + f)

  # Create a queue that produces the filenames to read.
  filename_queue = tf.train.string_input_producer(filenames)

  # Read examples from files in the filename queue.
  read_input = read_cifar10(filename_queue)
  reshaped_image = tf.cast(read_input.uint8image, tf.float32)

  height = IMAGE_SIZE
  width = IMAGE_SIZE

  # Image processing for evaluation.
  # Crop the central [height, width] of the image.
  resized_image = tf.image.resize_image_with_crop_or_pad(reshaped_image,
                                                         width, height)

  # Subtract off the mean and divide by the variance of the pixels.
  float_image = tf.image.per_image_whitening(resized_image)

  # Ensure that the random shuffling has good mixing properties.
  min_fraction_of_examples_in_queue = 0.4
  min_queue_examples = int(num_examples_per_epoch *
                           min_fraction_of_examples_in_queue)

  # Generate a batch of images and labels by building up a queue of examples.
  return _generate_image_and_label_batch(float_image, read_input.label,
                                         min_queue_examples, batch_size)

0x4: 评估模型

现在可以在另一部分数据集上来评估训练模型的性能。脚本文件cifar10_eval.py对模型进行了评估，利用 inference()函数重构模型，并使用了在评估数据集所有10,000张CIFAR-10图片进行测试。最终计算出的精度为1:N，N=预测值中置信度最高的一项与图片真实label匹配的频次。(It calculates the precision at 1: how often the top prediction matches the true label of the image)。
为了监控模型在训练过程中的改进情况，评估用的脚本文件会周期性的在最新的检查点文件上运行，这些检查点文件是由cifar10_train.py产生。

cifar10_eval.py

# Copyright  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.
# ==============================================================================
"""Evaluation for CIFAR-10.
Accuracy:
cifar10_train.py achieves 83.0% accuracy after 100K steps ( epochs
of data) as judged by cifar10_eval.py.
Speed:
On a single Tesla K40, cifar10_train.py processes a single batch of  images
in 0.25-0.35 sec (i.e.  -  images /sec). The model reaches ~%
accuracy after 100K steps in  hours of training time.
Usage:
Please see the tutorial and website for how to download the CIFAR-
data set, compile the program and train the model.
http://tensorflow.org/tutorials/deep_cnn/
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from datetime import datetime
import math
import time
import tensorflow.python.platform
from tensorflow.python.platform import gfile
import numpy as np
import tensorflow as tf
import cifar10
FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string('eval_dir', './cifar10_eval',
                           """Directory where to write event logs.""")
tf.app.flags.DEFINE_string('eval_data', 'test',
                           """Either 'test' or 'train_eval'.""")
tf.app.flags.DEFINE_string('checkpoint_dir', './cifar10_train',
                           """Directory where to read model checkpoints.""")
tf.app.flags.DEFINE_integer('eval_interval_secs',  * ,
                            """How often to run the eval.""")
tf.app.flags.DEFINE_integer('num_examples', ,
                            """Number of examples to run.""")
tf.app.flags.DEFINE_boolean('run_once', False,
                         """Whether to run eval only once.""")
def eval_once(saver, summary_writer, top_k_op, summary_op):
  """Run Eval once.
  Args:
    saver: Saver.
    summary_writer: Summary writer.
    top_k_op: Top K op.
    summary_op: Summary op.
  """
  with tf.Session() as sess:
    ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
    if ckpt and ckpt.model_checkpoint_path:
      # Restores from checkpoint
      saver.restore(sess, ckpt.model_checkpoint_path)
      # Assuming model_checkpoint_path looks something like:
      #   /my-favorite-path/cifar10_train/model.ckpt-,
      # extract global_step from it.
      global_step = ckpt.model_checkpoint_path.split('/')[-].split('-')[-]
    else:
      print('No checkpoint file found')
      return
    # Start the queue runners.
    coord = tf.train.Coordinator()
    try:
      threads = []
      for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
        threads.extend(qr.create_threads(sess, coord=coord, daemon=True,
                                         start=True))
      num_iter = int(math.ceil(FLAGS.num_examples / FLAGS.batch_size))
      true_count =   # Counts the number of correct predictions.
      total_sample_count = num_iter * FLAGS.batch_size
      step =
      while step < num_iter and not coord.should_stop():
        predictions = sess.run([top_k_op])
        true_count += np.sum(predictions)
        step +=
      # Compute precision @ .
      precision = true_count / total_sample_count
      print('%s: precision @ 1 = %.3f' % (datetime.now(), precision))
      summary = tf.Summary()
      summary.ParseFromString(sess.run(summary_op))
      summary.value.add(tag='Precision @ 1', simple_value=precision)
      summary_writer.add_summary(summary, global_step)
    except Exception as e:  # pylint: disable=broad-except
      coord.request_stop(e)
    coord.request_stop()
    coord.join(threads, stop_grace_period_secs=)
def evaluate():
  """Eval CIFAR-10 for a number of steps."""
  with tf.Graph().as_default():
    # Get images and labels for CIFAR-.
    eval_data = FLAGS.eval_data == 'test'
    images, labels = cifar10.inputs(eval_data=eval_data)
    # Build a Graph that computes the logits predictions from the
    # inference model.
    logits = cifar10.inference(images)
    # Calculate predictions.
    top_k_op = tf.nn.in_top_k(logits, labels, )
    # Restore the moving average version of the learned variables for eval.
    variable_averages = tf.train.ExponentialMovingAverage(
        cifar10.MOVING_AVERAGE_DECAY)
    variables_to_restore = variable_averages.variables_to_restore()
    saver = tf.train.Saver(variables_to_restore)
    # Build the summary operation based on the TF collection of Summaries.
    summary_op = tf.summary.merge_all()
    graph = tf.get_default_graph().as_graph_def()
    summary_writer = tf.summary.FileWriter(FLAGS.eval_dir,
                                            graph=graph)
    while True:
      eval_once(saver, summary_writer, top_k_op, summary_op)
      if FLAGS.run_once:
        break
      time.sleep(FLAGS.eval_interval_secs)
def main(argv=None):  # pylint: disable=unused-argument
  cifar10.maybe_download_and_extract()
  if gfile.Exists(FLAGS.eval_dir):
    gfile.DeleteRecursively(FLAGS.eval_dir)
  gfile.MakeDirs(FLAGS.eval_dir)
  evaluate()
if __name__ == '__main__':
  tf.app.run()

google的tensorflow api在1.0正式版本后变化很大，旧的代码在迁移到1.0后需要修改对应的api名字

0x5: 在GPU上运行

# Copyright  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.
# ==============================================================================

"""A binary to train CIFAR-10 using multiple GPU's with synchronous updates.

Accuracy:
cifar10_multi_gpu_train.py achieves ~% accuracy after 100K steps (
epochs of data) as judged by cifar10_eval.py.

Speed: With batch_size .

System        | Step Time (sec/batch)  |     Accuracy
--------------------------------------------------------------------
 Tesla K20m  | 0.35-0.60              | ~% at 60K steps  ( hours)
 Tesla K40m  | 0.25-0.35              | ~% at 100K steps ( hours)
 Tesla K20m  | 0.13-0.20              | ~% at 30K steps  (2.5 hours)
 Tesla K20m  | 0.13-0.18              | ~% at 30K steps
 Tesla K20m  | ~0.10                  | ~% at 30K steps

Usage:
Please see the tutorial and website for how to download the CIFAR-
data set, compile the program and train the model.

http://tensorflow.org/tutorials/deep_cnn/
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from datetime import datetime
import os.path
import re
import time

import numpy as np
from six.moves import xrange  # pylint: disable=redefined-builtin
import tensorflow as tf
import cifar10

FLAGS = tf.app.flags.FLAGS

tf.app.flags.DEFINE_string('train_dir', './cifar10_train',
                           """Directory where to write event logs """
                           """and checkpoint.""")
tf.app.flags.DEFINE_integer('max_steps', ,
                            """Number of batches to run.""")
tf.app.flags.DEFINE_integer('num_gpus', ,
                            """How many GPUs to use.""")
tf.app.flags.DEFINE_boolean('log_device_placement', False,
                            """Whether to log device placement.""")

def tower_loss(scope):
  """Calculate the total loss on a single tower running the CIFAR model.

  Args:
    scope: unique prefix string identifying the CIFAR tower, e.g. 'tower_0'

  Returns:
     Tensor of shape [] containing the total loss for a batch of data
  """
  # Get images and labels for CIFAR-.
  images, labels = cifar10.distorted_inputs()

  # Build inference Graph.
  logits = cifar10.inference(images)

  # Build the portion of the Graph calculating the losses. Note that we will
  # assemble the total_loss using a custom function below.
  _ = cifar10.loss(logits, labels)

  # Assemble all of the losses for the current tower only.
  losses = tf.get_collection('losses', scope)

  # Calculate the total loss for the current tower.
  total_loss = tf.add_n(losses, name='total_loss')

  # Compute the moving average of all individual losses and the total loss.
  loss_averages = tf.train.ExponentialMovingAverage(0.9, name='avg')
  loss_averages_op = loss_averages.apply(losses + [total_loss])

  # Attach a scalar summary to all individual losses and the total loss; do the
  # same for the averaged version of the losses.
  for l in losses + [total_loss]:
    # Remove 'tower_[0-9]/' from the name in case this is a multi-GPU training
    # session. This helps the clarity of presentation on tensorboard.
    loss_name = re.sub('%s_[0-9]*/' % cifar10.TOWER_NAME, '', l.op.name)
    # Name each loss as '(raw)' and name the moving average version of the loss
    # as the original loss name.
    tf.summary.scalar(loss_name +' (raw)', l)
    tf.summary.scalar(loss_name, loss_averages.average(l))

  with tf.control_dependencies([loss_averages_op]):
    total_loss = tf.identity(total_loss)
  return total_loss

def average_gradients(tower_grads):
  """Calculate the average gradient for each shared variable across all towers.

  Note that this function provides a synchronization point across all towers.

  Args:
    tower_grads: List of lists of (gradient, variable) tuples. The outer list
      is over individual gradients. The inner list is over the gradient
      calculation for each tower.
  Returns:
     List of pairs of (gradient, variable) where the gradient has been averaged
     across all towers.
  """
  average_grads = []
  for grad_and_vars in zip(*tower_grads):
    # Note that each grad_and_vars looks like the following:
    #   ((grad0_gpu0, var0_gpu0), ... , (grad0_gpuN, var0_gpuN))
    grads = []
    for g, _ in grad_and_vars:
      # Add  dimension to the gradients to represent the tower.
      expanded_g = tf.expand_dims(g, )

      # Append on a 'tower' dimension which we will average over below.
      grads.append(expanded_g)

    # Average over the 'tower' dimension.
    grad = tf.concat(, grads)
    grad = tf.reduce_mean(grad, )

    # Keep in mind that the Variables are redundant because they are shared
    # across towers. So .. we will just return the first tower's pointer to
    # the Variable.
    v = grad_and_vars[][]
    grad_and_var = (grad, v)
    average_grads.append(grad_and_var)
  return average_grads

def train():
  """Train CIFAR-10 for a number of steps."""
  with tf.Graph().as_default(), tf.device('/cpu:0'):
    # Create a variable to count the number of train() calls. This equals the
    # number of batches processed * FLAGS.num_gpus.
    global_step = tf.get_variable(
        'global_step', [],
        initializer=tf.constant_initializer(), trainable=False)

    # Calculate the learning rate schedule.
    num_batches_per_epoch = (cifar10.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN /
                             FLAGS.batch_size)
    decay_steps = int(num_batches_per_epoch * cifar10.NUM_EPOCHS_PER_DECAY)

    # Decay the learning rate exponentially based on the number of steps.
    lr = tf.train.exponential_decay(cifar10.INITIAL_LEARNING_RATE,
                                    global_step,
                                    decay_steps,
                                    cifar10.LEARNING_RATE_DECAY_FACTOR,
                                    staircase=True)

    # Create an optimizer that performs gradient descent.
    opt = tf.train.GradientDescentOptimizer(lr)

    # Calculate the gradients for each model tower.
    tower_grads = []
    for i in xrange(FLAGS.num_gpus):
      with tf.device('/gpu:%d' % i):
        with tf.name_scope('%s_%d' % (cifar10.TOWER_NAME, i)) as scope:
          # Calculate the loss for one tower of the CIFAR model. This function
          # constructs the entire CIFAR model but shares the variables across
          # all towers.
          loss = tower_loss(scope)

          # Reuse variables for the next tower.
          tf.get_variable_scope().reuse_variables()

          # Retain the summaries from the final tower.
          summaries = tf.get_collection(tf.GraphKeys.SUMMARIES, scope)

          # Calculate the gradients for the batch of data on this CIFAR tower.
          grads = opt.compute_gradients(loss)

          # Keep track of the gradients across all towers.
          tower_grads.append(grads)

    # We must calculate the mean of each gradient. Note that this is the
    # synchronization point across all towers.
    grads = average_gradients(tower_grads)

    # Add a summary to track the learning rate.
    summaries.append(tf.summary.scalar('learning_rate', lr))

    # Add histograms for gradients.
    for grad, var in grads:
      if grad is not None:
        summaries.append(
            tf.summary.histogram(var.op.name + '/gradients', grad))

    # Apply the gradients to adjust the shared variables.
    apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)

    # Add histograms for trainable variables.
    for var in tf.trainable_variables():
      summaries.append(tf.summary.histogram(var.op.name, var))

    # Track the moving averages of all trainable variables.
    variable_averages = tf.train.ExponentialMovingAverage(
        cifar10.MOVING_AVERAGE_DECAY, global_step)
    variables_averages_op = variable_averages.apply(tf.trainable_variables())

    # Group all updates to into a single train op.
    train_op = tf.group(apply_gradient_op, variables_averages_op)

    # Create a saver.
    saver = tf.train.Saver(tf.global_variables())

    # Build the summary operation from the last tower summaries.
    summary_op = tf.summary.merge(summaries)  #tf.summary.merge_all(summaries)

    # Build an initialization operation to run below.
    init = tf.global_variables_initializer()

    # Start running operations on the Graph. allow_soft_placement must be set to
    # True to build towers on GPU, as some of the ops do not have GPU
    # implementations.
    sess = tf.Session(config=tf.ConfigProto(
        allow_soft_placement=True,
        log_device_placement=FLAGS.log_device_placement))
    sess.run(init)

    # Start the queue runners.
    tf.train.start_queue_runners(sess=sess)

    summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
                                            graph=sess.graph)

    for step in xrange(FLAGS.max_steps):
      start_time = time.time()
      _, loss_value = sess.run([train_op, loss])
      duration = time.time() - start_time

      assert not np.isnan(loss_value), 'Model diverged with loss = NaN'

      if step %  == :
        num_examples_per_step = FLAGS.batch_size * FLAGS.num_gpus
        examples_per_sec = num_examples_per_step / duration
        sec_per_batch = duration / FLAGS.num_gpus

        format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '
                      'sec/batch)')
        print (format_str % (datetime.now(), step, loss_value,
                             examples_per_sec, sec_per_batch))

      if step %  == :
        summary_str = sess.run(summary_op)
        summary_writer.add_summary(summary_str, step)

      # Save the model checkpoint periodically.
      if step %  ==  or (step + ) == FLAGS.max_steps:
        checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt')
        saver.save(sess, checkpoint_path, global_step=step)

def main(argv=None):  # pylint: disable=unused-argument
  cifar10.maybe_download_and_extract()
  if tf.gfile.Exists(FLAGS.train_dir):
    tf.gfile.DeleteRecursively(FLAGS.train_dir)
  tf.gfile.MakeDirs(FLAGS.train_dir)
  train()

if __name__ == '__main__':
  tf.app.run()

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-8.0/lib64
export CUDA_HOME=/usr/local/cuda
export PATH=/usr/local/cuda-8.0//bin:$PATH

screen python cifar10_multi_gpu_train.py --num_gpus=
python cifar10_eval.py

Relevant Link:

https://www.tensorflow.org/api_docs/python/tf/random_crop
https://github.com/tensorflow/models/commit/e5079c839058ff40dcbd15515a9cfb462fabbc2a#diff-5ae64cf077db8f00686ff8b5d7748604
https://github.com/tensorflow/tensorflow/tree/r0.7/tensorflow/models/image/cifar10
https://github.com/tensorflow/models/pull/864/commits/e93ec37201f5f2116933ae96e505f409ddbf344d
http://qiita.com/shu223/items/ef160cbe1e9d9f57c248

5. 单词的向量表示(Vector Representations of Words)

0x1: Word Embeddings

通常图像或音频系统处理的是由图片中所有单个原始像素点强度值(pix chanel)或者音频中功率谱密度的强度值，把它们编码成丰富、高纬度的向量数据集(卷积)。对于物体或语音识别这一类的任务，我们所需的全部信息已经都存储在原始数据中(显然人类本身就是依赖原始数据进行日常的物体或语音识别的)
然后，自然语言处理系统通常将词汇作为离散的单一符号，例如 "cat" 一词或可表示为 Id537 ，而 "dog" 一词或可表示为 Id143。这些符号编码毫无规律，无法提供不同词汇之间可能存在的关联信息。换句话说，在处理关于 "dogs" 一词的信息时，模型将无法利用已知的关于 "cats" 的信息(例如，它们都是动物，有四条腿，可作为宠物等等)。可见，将词汇表达为上述的独立离散符号将进一步导致数据稀疏，使我们在训练统计模型时不得不寻求更多的数据。而词汇的向量表示将克服上述的难题

向量空间模型 (VSMs)将词汇表达（嵌套）于一个连续的向量空间中，语义近似的词汇被映射为相邻的数据点。向量空间模型在自然语言处理领域中有着漫长且丰富的历史，不过几乎所有利用这一模型的方法都依赖于 分布式假设，其核心思想为出现于上下文情景中的词汇都有相类似的语义。采用这一假设的研究方法大致分为以下两类

基于计数的方法 (e.g. 潜在语义分析): 基于计数的方法计算某词汇与其邻近词汇在一个大型语料库中共同出现的频率及其他统计量，然后将这些统计量映射到一个小型且稠密的向量中
预测方法 (e.g. 神经概率化语言模型): 预测方法则试图直接从某词汇的邻近词汇对其进行预测，在此过程中利用已经学习到的小型且稠密的嵌套向量

Word2vec是一种可以进行高效率词嵌套学习的预测模型。其两种变体分别为

连续词袋模型(CBOW): 从算法角度看，这两种方法非常相似，其区别为CBOW根据源词上下文词汇('the cat sits on the')来预测目标词汇(例如，'mat')
Skip-Gram模型: Skip-Gram模型做法相反，它通过目标词汇来预测源词汇
Skip-Gram模型采取CBOW的逆过程的动机在于
    ) CBOW算法对于很多分布式信息进行了平滑处理(例如将一整段上下文信息视为一个单一观察量)。很多情况下，对于小型的数据集，这一处理是有帮助的
    ) 相形之下，Skip-Gram模型将每个"上下文-目标词汇"的组合视为一个新观察量，这种做法在大型数据集中会更为有效 

0x2: 处理噪声对比训练

神经概率化语言模型通常使用极大似然法 (ML) 进行训练，其中通过 softmax function 来最大化当提供前一个单词 h (代表 "history")，后一个单词的概率  (代表 "target")

当 score(w_t,h) 计算了文字 w_t 和 上下文 h 的相容性（通常使用向量积）。我们使用对数似然函数来训练训练集的最大值，比如通过：

这里提出了一个解决语言概率模型的合适的通用方法。然而这个方法实际执行起来开销非常大，因为我们需要去计算并正则化当前上下文环境 h 中所有其他 V 单词 w' 的概率得分，在每一步训练迭代中

即每一个单词我们都要进行一次预测，在所有语料组合中，最优可能紧跟着地单词是什么
从另一个角度来说，当使用word2vec模型时，我们并不需要对概率模型中的所有特征进行学习。而CBOW模型和Skip-Gram模型为了避免这种情况发生，使用一个二分类器（逻辑回归）在同一个上下文环境里从 k 虚构的 (噪声) 单词  区分出真正的目标单词 。我们下面详细阐述一下CBOW模型，对于Skip-Gram模型只要简单地做相反的操作即可。

噪声对比训练的意义在于，我们假设随机产生的目标单词上下文都是噪声，它们不可能也不应该和我们的目标单词有语境关联，训练的目标就在于找到一组参数，使得尽可能大的区分目标单词的目标上下文和噪音上下文

从数学角度来说，我们的目标是对每个样本最大化：

其中代表的是数据集在当前上下文 h ，根据所学习的嵌套向量  ，目标单词 w 使用二分类逻辑回归计算得出的概率。在实践中，我们通过在噪声分布中绘制比对文字来获得近似的期望值（通过计算蒙特卡洛平均值）。
当真实地目标单词被分配到较高的概率，同时噪声单词的概率很低时，目标函数也就达到最大值了。从技术层面来说，这种方法叫做"负抽样"，而且使用这个损失函数在数学层面上也有很好的解释：这个更新过程也近似于softmax函数的更新。这在计算上将会有很大的优势，因为当计算这个损失函数时，只是有我们挑选出来的 k 个 噪声单词，而没有使用整个语料库 V。这使得训练变得非常快。我们实际上使用了与noise-contrastive estimation (NCE)介绍的非常相似的方法，这在TensorFlow中已经封装了一个很便捷的函数tf.nn.nce_loss()

0x3: Skip-gram 模型

下面来看一下这个数据集

the quick brown fox jumped over the lazy dog

我们首先对一些单词以及它们的上下文环境建立一个数据集。我们可以以任何合理的方式定义'上下文'，而通常上这个方式是根据文字的句法语境的(使用语法原理的方式处理当前目标单词可，比如说把目标单词左边的内容当做一个'上下文'，或者以目标单词右边的内容，等等。现在我们把目标单词的左右单词视作一个上下文， 使用大小为1的窗口，这样就得到这样一个由(上下文, 目标单词) 组成的数据集

([the, brown], quick), ([quick, fox], brown), ([brown, jumped], fox), ...

文提到Skip-Gram模型是把目标单词和上下文颠倒过来，所以在这个问题中，举个例子，就是用'quick'来预测 'the' 和 'brown' ，用 'brown' 预测 'quick' 和 'brown' 。因此这个数据集就变成由(输入, 输出)组成的：

(quick, the), (quick, brown), (brown, quick), (brown, fox), ...

目标函数通常是对整个数据集建立的，但是本问题中要对每一个样本（或者是一个batch_size 很小的样本集，通常设置为16 <= batch_size <= 512）在同一时间执行特别的操作，称之为随机梯度下降 (SGD)。我们来看一下训练过程中每一步的执行。
假设用 t 表示上面这个例子中quick 来预测 the 的训练的单个循环。用 num_noise 定义从噪声分布中挑选出来的噪声（相反的）单词的个数，通常使用一元分布，P(w)。为了简单起见，我们就定num_noise=1，用 sheep 选作噪声词。接下来就可以计算每一对观察值和噪声值的损失函数了，每一个执行步骤就可表示为：

整个计算过程的目标是通过更新嵌套参数  来逼近目标函数(这个这个例子中就是使目标函数最大化)(即让模型向对目标值预测概率最高，而对噪音值预测概率最低)。为此我们要计算损失函数中嵌套参数的梯度。对于整个数据集，当梯度下降的过程中不断地更新参数，对应产生的效果就是不断地移动每个单词的嵌套向量，直到可以把真实单词和噪声单词很好得区分开。
我们可以把学习向量映射到2维中以便我们观察，其中用到的技术可以参考 t-SNE 降纬技术。当我们用可视化的方式来观察这些向量，就可以很明显的获取单词之间语义信息的关系，这实际上是非常有用的。当我们第一次发现这样的诱导向量空间中，展示了一些特定的语义关系，这是非常有趣的，比如文字中 male-female，gender 甚至还有 country-capital 的关系

这也解释了为什么这些向量在传统的NLP问题中可作为特性使用，比如用在对一个演讲章节打个标签，或者对一个专有名词的识别

0x4: 建立图形

先来定义一个嵌套参数矩阵。我们用唯一的随机值来初始化这个大矩阵

embeddings = tf.Variable(
    tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))

对噪声-比对的损失计算就使用一个逻辑回归模型。对此，我们需要对语料库中的每个单词定义一个权重值和偏差值。(也可称之为输出权重 与之对应的 输入嵌套值)。定义如下

nce_weights = tf.Variable(
  tf.truncated_normal([vocabulary_size, embedding_size],
                      stddev=1.0 / math.sqrt(embedding_size)))
nce_biases = tf.Variable(tf.zeros([vocabulary_size]))

我们有了这些参数之后，就可以定义Skip-Gram模型了。简单起见，假设我们已经把语料库中的文字整型化了，这样每个整型代表一个单词。Skip-Gram模型有两个输入。一个是一组用整型表示的上下文单词，另一个是目标单词。给这些输入建立占位符节点，之后就可以填入数据了

# 建立输入占位符
train_inputs = tf.placeholder(tf.int32, shape=[batch_size])
train_labels = tf.placeholder(tf.int32, shape=[batch_size, ])

然后我们需要对批数据中的单词建立嵌套向量

embed = tf.nn.embedding_lookup(embeddings, train_inputs)

现在我们有了每个单词的嵌套向量，接下来就是使用噪声-比对的训练方式来预测目标单词(找到最有可能是和目标单词对应的上下文)

# 计算 NCE 损失函数, 每次使用负标签的样本.
loss = tf.reduce_mean(
  tf.nn.nce_loss(nce_weights, nce_biases, embed, train_labels,
                 num_sampled, vocabulary_size))

我们对损失函数建立了图形节点，然后我们需要计算相应梯度和更新参数的节点，比如说在这里我们会使用随机梯度下降法，TensorFlow也已经封装好了该过程

# 使用 SGD 控制器.
optimizer = tf.train.GradientDescentOptimizer(learning_rate=1.0).minimize(loss)

0x5: 训练模型

训练的过程很简单，只要在循环中使用feed_dict不断给占位符填充数据，同时调用 session.run即可

for inputs, labels in generate_batch(...):
  feed_dict = {training_inputs: inputs, training_labels: labels}
  _, cur_loss = session.run([optimizer, loss], feed_dict=feed_dict)

0x6: 嵌套学习结果可视化

# Copyright  The TensorFlow Authors. 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.
# ==============================================================================

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import collections
import math
import os
import random
import zipfile

import numpy as np
from six.moves import urllib
from six.moves import xrange  # pylint: disable=redefined-builtin
import tensorflow as tf

# Step : Download the data.
url = 'http://mattmahoney.net/dc/'

def maybe_download(filename, expected_bytes):
  """Download a file if not present, and make sure it's the right size."""
  if not os.path.exists(filename):
    filename, _ = urllib.request.urlretrieve(url + filename, filename)
  statinfo = os.stat(filename)
  if statinfo.st_size == expected_bytes:
    print('Found and verified', filename)
  else:
    print(statinfo.st_size)
    raise Exception(
        'Failed to verify ' + filename + '. Can you get to it with a browser?')
  return filename

filename = maybe_download('text8.zip', )

# Read the data into a list of strings.
def read_data(filename):
  """Extract the first file enclosed in a zip file as a list of words"""
  with zipfile.ZipFile(filename) as f:
    data = tf.compat.as_str(f.read(f.namelist()[])).split()
  return data

words = read_data(filename)
print('Data size', len(words))

# Step : Build the dictionary and replace rare words with UNK token.
vocabulary_size = 

def build_dataset(words):
  count = [['UNK', -]]
  count.extend(collections.Counter(words).most_common(vocabulary_size - ))
  dictionary = dict()
  for word, _ in count:
    dictionary[word] = len(dictionary)
  data = list()
  unk_count =
  for word in words:
    if word in dictionary:
      index = dictionary[word]
    else:
      index =   # dictionary['UNK']
      unk_count +=
    data.append(index)
  count[][] = unk_count
  reverse_dictionary = dict(zip(dictionary.values(), dictionary.keys()))
  return data, count, dictionary, reverse_dictionary

data, count, dictionary, reverse_dictionary = build_dataset(words)
del words  # Hint to reduce memory.
print('Most common words (+UNK)', count[:])
print('Sample data', data[:], [reverse_dictionary[i] for i in data[:]])

data_index = 

# Step : Function to generate a training batch for the skip-gram model.
def generate_batch(batch_size, num_skips, skip_window):
  global data_index
  assert batch_size % num_skips ==
  assert num_skips <=  * skip_window
  batch = np.ndarray(shape=(batch_size), dtype=np.int32)
  labels = np.ndarray(shape=(batch_size, ), dtype=np.int32)
  span =  * skip_window +   # [ skip_window target skip_window ]
  buffer = collections.deque(maxlen=span)
  for _ in range(span):
    buffer.append(data[data_index])
    data_index = (data_index + ) % len(data)
  for i in range(batch_size // num_skips):
    target = skip_window  # target label at the center of the buffer
    targets_to_avoid = [skip_window]
    for j in range(num_skips):
      while target in targets_to_avoid:
        target = random.randint(, span - )
      targets_to_avoid.append(target)
      batch[i * num_skips + j] = buffer[skip_window]
      labels[i * num_skips + j, ] = buffer[target]
    buffer.append(data[data_index])
    data_index = (data_index + ) % len(data)
  # Backtrack a little bit to avoid skipping words in the end of a batch
  data_index = (data_index + len(data) - span) % len(data)
  return batch, labels

batch, labels = generate_batch(batch_size=, num_skips=, skip_window=)
for i in range():
  print(batch[i], reverse_dictionary[batch[i]],
        '->', labels[i, ], reverse_dictionary[labels[i, ]])

# Step : Build and train a skip-gram model.

batch_size =
embedding_size =   # Dimension of the embedding vector.
skip_window =        # How many words to consider left and right.
num_skips =          # How many times to reuse an input to generate a label.

# We pick a random validation set to sample nearest neighbors. Here we limit the
# validation samples to the words that have a low numeric ID, which by
# construction are also the most frequent.
valid_size =      # Random set of words to evaluate similarity on.
valid_window =   # Only pick dev samples in the head of the distribution.
valid_examples = np.random.choice(valid_window, valid_size, replace=False)
num_sampled =     # Number of negative examples to sample.

graph = tf.Graph()

with graph.as_default():

  # Input data.
  train_inputs = tf.placeholder(tf.int32, shape=[batch_size])
  train_labels = tf.placeholder(tf.int32, shape=[batch_size, ])
  valid_dataset = tf.constant(valid_examples, dtype=tf.int32)

  # Ops and variables pinned to the CPU because of missing GPU implementation
  with tf.device('/cpu:0'):
    # Look up embeddings for inputs.
    embeddings = tf.Variable(
        tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))
    embed = tf.nn.embedding_lookup(embeddings, train_inputs)

    # Construct the variables for the NCE loss
    nce_weights = tf.Variable(
        tf.truncated_normal([vocabulary_size, embedding_size],
                            stddev=1.0 / math.sqrt(embedding_size)))
    nce_biases = tf.Variable(tf.zeros([vocabulary_size]))

  # Compute the average NCE loss for the batch.
  # tf.nce_loss automatically draws a new sample of the negative labels each
  # time we evaluate the loss.
  loss = tf.reduce_mean(
      tf.nn.nce_loss(weights=nce_weights,
                     biases=nce_biases,
                     labels=train_labels,
                     inputs=embed,
                     num_sampled=num_sampled,
                     num_classes=vocabulary_size))

  # Construct the SGD optimizer using a learning rate of 1.0.
  optimizer = tf.train.GradientDescentOptimizer(1.0).minimize(loss)

  # Compute the cosine similarity between minibatch examples and all embeddings.
  norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), , keep_dims=True))
  normalized_embeddings = embeddings / norm
  valid_embeddings = tf.nn.embedding_lookup(
      normalized_embeddings, valid_dataset)
  similarity = tf.matmul(
      valid_embeddings, normalized_embeddings, transpose_b=True)

  # Add variable initializer.
  init = tf.global_variables_initializer()

# Step : Begin training.
num_steps = 

with tf.Session(graph=graph) as session:
  # We must initialize all variables before we use them.
  init.run()
  print("Initialized")

  average_loss =
  for step in xrange(num_steps):
    batch_inputs, batch_labels = generate_batch(
        batch_size, num_skips, skip_window)
    feed_dict = {train_inputs: batch_inputs, train_labels: batch_labels}

    # We perform one update step by evaluating the optimizer op (including it
    # in the list of returned values for session.run()
    _, loss_val = session.run([optimizer, loss], feed_dict=feed_dict)
    average_loss += loss_val

    if step %  == :
      if step > :
        average_loss /=
      # The average loss is an estimate of the loss over the last  batches.
      print("Average loss at step ", step, ": ", average_loss)
      average_loss = 

    # Note that this is expensive (~% slowdown if computed every  steps)
    if step %  == :
      sim = similarity.eval()
      for i in xrange(valid_size):
        valid_word = reverse_dictionary[valid_examples[i]]
        top_k =   # number of nearest neighbors
        nearest = (-sim[i, :]).argsort()[:top_k + ]
        log_str = "Nearest to %s:" % valid_word
        for k in xrange(top_k):
          close_word = reverse_dictionary[nearest[k]]
          log_str = "%s %s," % (log_str, close_word)
        print(log_str)
  final_embeddings = normalized_embeddings.eval()

# Step : Visualize the embeddings.

def plot_with_labels(low_dim_embs, labels, filename='tsne.png'):
  assert low_dim_embs.shape[] >= len(labels), "More labels than embeddings"
  plt.figure(figsize=(, ))  # in inches
  for i, label in enumerate(labels):
    x, y = low_dim_embs[i, :]
    plt.scatter(x, y)
    plt.annotate(label,
                 xy=(x, y),
                 xytext=(, ),
                 textcoords='offset points',
                 ha='right',
                 va='bottom')

  plt.savefig(filename)

try:
  from sklearn.manifold import TSNE
  import matplotlib.pyplot as plt

  tsne = TSNE(perplexity=, n_components=, init='pca', n_iter=)
  plot_only =
  low_dim_embs = tsne.fit_transform(final_embeddings[:plot_only, :])
  labels = [reverse_dictionary[i] for i in xrange(plot_only)]
  plot_with_labels(low_dim_embs, labels)

except ImportError:
  print("Please install sklearn, matplotlib, and scipy to visualize embeddings.")

0x7: 嵌套学习的评估: 类比推理

词嵌套在NLP的预测问题中是非常有用且使用广泛地。如果要检测一个模型是否是可以成熟地区分词性或者区分专有名词的模型，最简单的办法就是直接检验它的预测词性、语义关系的能力，比如让它解决形如king is to queen as father is to ?这样的问题。这种方法叫做类比推理

# Copyright  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.
# ==============================================================================
"""Multi-threaded word2vec mini-batched skip-gram model.
Trains the model described in:
(Mikolov, et. al.) Efficient Estimation of Word Representations in Vector Space
ICLR .
http://arxiv.org/abs/1301.3781
This model does traditional minibatching.
The key ops used are:
* placeholder for feeding in tensors for each example.
* embedding_lookup for fetching rows from the embedding matrix.
* sigmoid_cross_entropy_with_logits to calculate the loss.
* GradientDescentOptimizer for optimizing the loss.
* skipgram custom op that does input processing.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import sys
import threading
import time
import tensorflow.python.platform
from six.moves import xrange  # pylint: disable=redefined-builtin
import numpy as np
import tensorflow as tf
from tensorflow.models.embedding import gen_word2vec as word2vec
flags = tf.app.flags
flags.DEFINE_string("save_path", None, "Directory to write the model and "
                    "training summaries.")
flags.DEFINE_string("train_data", None, "Training text file. "
                    "E.g., unzipped file http://mattmahoney.net/dc/text8.zip.")
flags.DEFINE_string(
    "eval_data", None, "File consisting of analogies of four tokens."
    "embedding 2 - embedding 1 + embedding 3 should be close "
    "to embedding 4."
    "E.g. https://word2vec.googlecode.com/svn/trunk/questions-words.txt.")
flags.DEFINE_integer("embedding_size", , "The embedding dimension size.")
flags.DEFINE_integer(
    "epochs_to_train", ,
    "Number of epochs to train. Each epoch processes the training data once "
    "completely.")
flags.DEFINE_float("learning_rate", 0.2, "Initial learning rate.")
flags.DEFINE_integer("num_neg_samples", ,
                     "Negative samples per training example.")
flags.DEFINE_integer("batch_size", ,
                     "Number of training examples processed per step "
                     "(size of a minibatch).")
flags.DEFINE_integer("concurrent_steps", ,
                     "The number of concurrent training steps.")
flags.DEFINE_integer("window_size", ,
                     "The number of words to predict to the left and right "
                     "of the target word.")
flags.DEFINE_integer("min_count", ,
                     "The minimum number of word occurrences for it to be "
                     "included in the vocabulary.")
flags.DEFINE_float("subsample", 1e-,
                   "Subsample threshold for word occurrence. Words that appear "
                   "with higher frequency will be randomly down-sampled. Set "
                   "to 0 to disable.")
flags.DEFINE_boolean(
    "interactive", False,
    "If true, enters an IPython interactive session to play with the trained "
    "model. E.g., try model.analogy('france', 'paris', 'russia') and "
    "model.nearby(['proton', 'elephant', 'maxwell']")
flags.DEFINE_integer("statistics_interval", ,
                     "Print statistics every n seconds.")
flags.DEFINE_integer("summary_interval", ,
                     "Save training summary to file every n seconds (rounded "
                     "up to statistics interval.")
flags.DEFINE_integer("checkpoint_interval", ,
                     "Checkpoint the model (i.e. save the parameters) every n "
                     "seconds (rounded up to statistics interval.")
FLAGS = flags.FLAGS
class Options(object):
  """Options used by our word2vec model."""
  def __init__(self):
    # Model options.
    # Embedding dimension.
    self.emb_dim = FLAGS.embedding_size
    # Training options.
    # The training text file.
    self.train_data = FLAGS.train_data
    # Number of negative samples per example.
    self.num_samples = FLAGS.num_neg_samples
    # The initial learning rate.
    self.learning_rate = FLAGS.learning_rate
    # Number of epochs to train. After these many epochs, the learning
    # rate decays linearly to zero and the training stops.
    self.epochs_to_train = FLAGS.epochs_to_train
    # Concurrent training steps.
    self.concurrent_steps = FLAGS.concurrent_steps
    # Number of examples for one training step.
    self.batch_size = FLAGS.batch_size
    # The number of words to predict to the left and right of the target word.
    self.window_size = FLAGS.window_size
    # The minimum number of word occurrences for it to be included in the
    # vocabulary.
    self.min_count = FLAGS.min_count
    # Subsampling threshold for word occurrence.
    self.subsample = FLAGS.subsample
    # How often to print statistics.
    self.statistics_interval = FLAGS.statistics_interval
    # How often to write to the summary file (rounds up to the nearest
    # statistics_interval).
    self.summary_interval = FLAGS.summary_interval
    # How often to write checkpoints (rounds up to the nearest statistics
    # interval).
    self.checkpoint_interval = FLAGS.checkpoint_interval
    # Where to write out summaries.
    self.save_path = FLAGS.save_path
    # Eval options.
    # The text file for eval.
    self.eval_data = FLAGS.eval_data
class Word2Vec(object):
  """Word2Vec model (Skipgram)."""
  def __init__(self, options, session):
    self._options = options
    self._session = session
    self._word2id = {}
    self._id2word = []
    self.build_graph()
    self.build_eval_graph()
    self.save_vocab()
    self._read_analogies()
  def _read_analogies(self):
    """Reads through the analogy question file.
    Returns:
      questions: a [n, ] numpy array containing the analogy question's
                 word ids.
      questions_skipped: questions skipped due to unknown words.
    """
    questions = []
    questions_skipped =
    with open(self._options.eval_data, "rb") as analogy_f:
      for line in analogy_f:
        if line.startswith(b":"):  # Skip comments.
          continue
        words = line.strip().lower().split(b" ")
        ids = [self._word2id.get(w.strip()) for w in words]
        if None in ids or len(ids) != :
          questions_skipped +=
        else:
          questions.append(np.array(ids))
    print("Eval analogy file: ", self._options.eval_data)
    print("Questions: ", len(questions))
    print("Skipped: ", questions_skipped)
    self._analogy_questions = np.array(questions, dtype=np.int32)
  def forward(self, examples, labels):
    """Build the graph for the forward pass."""
    opts = self._options
    # Declare all variables we need.
    # Embedding: [vocab_size, emb_dim]
    init_width = 0.5 / opts.emb_dim
    emb = tf.Variable(
        tf.random_uniform(
            [opts.vocab_size, opts.emb_dim], -init_width, init_width),
        name="emb")
    self._emb = emb
    # Softmax weight: [vocab_size, emb_dim]. Transposed.
    sm_w_t = tf.Variable(
        tf.zeros([opts.vocab_size, opts.emb_dim]),
        name="sm_w_t")
    # Softmax bias: [emb_dim].
    sm_b = tf.Variable(tf.zeros([opts.vocab_size]), name="sm_b")
    # Global step: scalar, i.e., shape [].
    self.global_step = tf.Variable(, name="global_step")
    # Nodes to compute the nce loss w/ candidate sampling.
    labels_matrix = tf.reshape(
        tf.cast(labels,
                dtype=tf.int64),
        [opts.batch_size, ])
    # Negative sampling.
    sampled_ids, _, _ = (tf.nn.fixed_unigram_candidate_sampler(
        true_classes=labels_matrix,
        num_true=,
        num_sampled=opts.num_samples,
        unique=True,
        range_max=opts.vocab_size,
        distortion=0.75,
        unigrams=opts.vocab_counts.tolist()))
    # Embeddings for examples: [batch_size, emb_dim]
    example_emb = tf.nn.embedding_lookup(emb, examples)
    # Weights for labels: [batch_size, emb_dim]
    true_w = tf.nn.embedding_lookup(sm_w_t, labels)
    # Biases for labels: [batch_size, ]
    true_b = tf.nn.embedding_lookup(sm_b, labels)
    # Weights for sampled ids: [num_sampled, emb_dim]
    sampled_w = tf.nn.embedding_lookup(sm_w_t, sampled_ids)
    # Biases for sampled ids: [num_sampled, ]
    sampled_b = tf.nn.embedding_lookup(sm_b, sampled_ids)
    # True logits: [batch_size, ]
    true_logits = tf.reduce_sum(tf.mul(example_emb, true_w), ) + true_b
    # Sampled logits: [batch_size, num_sampled]
    # We replicate sampled noise lables for all examples in the batch
    # using the matmul.
    sampled_b_vec = tf.reshape(sampled_b, [opts.num_samples])
    sampled_logits = tf.matmul(example_emb,
                               sampled_w,
                               transpose_b=True) + sampled_b_vec
    return true_logits, sampled_logits
  def nce_loss(self, true_logits, sampled_logits):
    """Build the graph for the NCE loss."""
    # cross-entropy(logits, labels)
    opts = self._options
    true_xent = tf.nn.sigmoid_cross_entropy_with_logits(
        true_logits, tf.ones_like(true_logits))
    sampled_xent = tf.nn.sigmoid_cross_entropy_with_logits(
        sampled_logits, tf.zeros_like(sampled_logits))
    # NCE-loss is the sum of the true and noise (sampled words)
    # contributions, averaged over the batch.
    nce_loss_tensor = (tf.reduce_sum(true_xent) +
                       tf.reduce_sum(sampled_xent)) / opts.batch_size
    return nce_loss_tensor
  def optimize(self, loss):
    """Build the graph to optimize the loss function."""
    # Optimizer nodes.
    # Linear learning rate decay.
    opts = self._options
    words_to_train = float(opts.words_per_epoch * opts.epochs_to_train)
    lr = opts.learning_rate * tf.maximum(
        0.0001, 1.0 - tf.cast(self._words, tf.float32) / words_to_train)
    self._lr = lr
    optimizer = tf.train.GradientDescentOptimizer(lr)
    train = optimizer.minimize(loss,
                               global_step=self.global_step,
                               gate_gradients=optimizer.GATE_NONE)
    self._train = train
  def build_eval_graph(self):
    """Build the eval graph."""
    # Eval graph
    # Each analogy task is to predict the 4th word (d) given three
    # words: a, b, c.  E.g., a=italy, b=rome, c=france, we should
    # predict d=paris.
    # The eval feeds three vectors of word ids for a, b, c, each of
    # which is of size N, where N is the number of analogies we want to
    # evaluate in one batch.
    analogy_a = tf.placeholder(dtype=tf.int32)  # [N]
    analogy_b = tf.placeholder(dtype=tf.int32)  # [N]
    analogy_c = tf.placeholder(dtype=tf.int32)  # [N]
    # Normalized word embeddings of shape [vocab_size, emb_dim].
    nemb = tf.nn.l2_normalize(self._emb, )
    # Each row of a_emb, b_emb, c_emb is a word's embedding vector.
    # They all have the shape [N, emb_dim]
    a_emb = tf.gather(nemb, analogy_a)  # a's embs
    b_emb = tf.gather(nemb, analogy_b)  # b's embs
    c_emb = tf.gather(nemb, analogy_c)  # c's embs
    # We expect that d's embedding vectors on the unit hyper-sphere is
    # near: c_emb + (b_emb - a_emb), which has the shape [N, emb_dim].
    target = c_emb + (b_emb - a_emb)
    # Compute cosine distance between each pair of target and vocab.
    # dist has shape [N, vocab_size].
    dist = tf.matmul(target, nemb, transpose_b=True)
    # For each question (row in dist), find the top  words.
    _, pred_idx = tf.nn.top_k(dist, )
    # Nodes for computing neighbors for a given word according to
    # their cosine distance.
    nearby_word = tf.placeholder(dtype=tf.int32)  # word id
    nearby_emb = tf.gather(nemb, nearby_word)
    nearby_dist = tf.matmul(nearby_emb, nemb, transpose_b=True)
    nearby_val, nearby_idx = tf.nn.top_k(nearby_dist,
                                         min(, self._options.vocab_size))
    # Nodes in the construct graph which are used by training and
    # evaluation to run/feed/fetch.
    self._analogy_a = analogy_a
    self._analogy_b = analogy_b
    self._analogy_c = analogy_c
    self._analogy_pred_idx = pred_idx
    self._nearby_word = nearby_word
    self._nearby_val = nearby_val
    self._nearby_idx = nearby_idx
  def build_graph(self):
    """Build the graph for the full model."""
    opts = self._options
    # The training data. A text file.
    (words, counts, words_per_epoch, self._epoch, self._words, examples,
     labels) = word2vec.skipgram(filename=opts.train_data,
                                 batch_size=opts.batch_size,
                                 window_size=opts.window_size,
                                 min_count=opts.min_count,
                                 subsample=opts.subsample)
    (opts.vocab_words, opts.vocab_counts,
     opts.words_per_epoch) = self._session.run([words, counts, words_per_epoch])
    opts.vocab_size = len(opts.vocab_words)
    print("Data file: ", opts.train_data)
    print("Vocab size: ", opts.vocab_size - , " + UNK")
    print("Words per epoch: ", opts.words_per_epoch)
    self._examples = examples
    self._labels = labels
    self._id2word = opts.vocab_words
    for i, w in enumerate(self._id2word):
      self._word2id[w] = i
    true_logits, sampled_logits = self.forward(examples, labels)
    loss = self.nce_loss(true_logits, sampled_logits)
    tf.scalar_summary("NCE loss", loss)
    self._loss = loss
    self.optimize(loss)
    # Properly initialize all variables.
    tf.initialize_all_variables().run()
    self.saver = tf.train.Saver()
  def save_vocab(self):
    """Save the vocabulary to a file so the model can be reloaded."""
    opts = self._options
    with open(os.path.join(opts.save_path, "vocab.txt"), "w") as f:
      for i in xrange(opts.vocab_size):
        f.write("%s %d\n" % (tf.compat.as_text(opts.vocab_words[i]),
                             opts.vocab_counts[i]))
  def _train_thread_body(self):
    initial_epoch, = self._session.run([self._epoch])
    while True:
      _, epoch = self._session.run([self._train, self._epoch])
      if epoch != initial_epoch:
        break
  def train(self):
    """Train the model."""
    opts = self._options
    initial_epoch, initial_words = self._session.run([self._epoch, self._words])
    summary_op = tf.merge_all_summaries()
    summary_writer = tf.train.SummaryWriter(opts.save_path,
                                            graph_def=self._session.graph_def)
    workers = []
    for _ in xrange(opts.concurrent_steps):
      t = threading.Thread(target=self._train_thread_body)
      t.start()
      workers.append(t)
    last_words, last_time, last_summary_time = initial_words, time.time(),
    last_checkpoint_time =
    while True:
      time.sleep(opts.statistics_interval)  # Reports our progress once a while.
      (epoch, step, loss, words, lr) = self._session.run(
          [self._epoch, self.global_step, self._loss, self._words, self._lr])
      now = time.time()
      last_words, last_time, rate = words, now, (words - last_words) / (
          now - last_time)
      print("Epoch %4d Step %8d: lr = %5.3f loss = %6.2f words/sec = %8.0f\r" %
            (epoch, step, lr, loss, rate), end="")
      sys.stdout.flush()
      if now - last_summary_time > opts.summary_interval:
        summary_str = self._session.run(summary_op)
        summary_writer.add_summary(summary_str, step)
        last_summary_time = now
      if now - last_checkpoint_time > opts.checkpoint_interval:
        self.saver.save(self._session,
                        opts.save_path + "model",
                        global_step=step.astype(int))
        last_checkpoint_time = now
      if epoch != initial_epoch:
        break
    for t in workers:
      t.join()
    return epoch
  def _predict(self, analogy):
    """Predict the top 4 answers for analogy questions."""
    idx, = self._session.run([self._analogy_pred_idx], {
        self._analogy_a: analogy[:, ],
        self._analogy_b: analogy[:, ],
        self._analogy_c: analogy[:, ]
    })
    return idx
  def eval(self):
    """Evaluate analogy questions and reports accuracy."""
    # How many questions we get right at precision@.
    correct =
    total = self._analogy_questions.shape[]
    start =
    while start < total:
      limit = start +
      sub = self._analogy_questions[start:limit, :]
      idx = self._predict(sub)
      start = limit
      for question in xrange(sub.shape[]):
        for j in xrange():
          if idx[question, j] == sub[question, ]:
            # Bingo! We predicted correctly. E.g., [italy, rome, france, paris].
            correct +=
            break
          elif idx[question, j] in sub[question, :]:
            # We need to skip words already in the question.
            continue
          else:
            # The correct label is not the precision@
            break
    print()
    print("Eval %4d/%d accuracy = %4.1f%%" % (correct, total,
                                              correct * 100.0 / total))
  def analogy(self, w0, w1, w2):
    """Predict word w3 as in w0:w1 vs w2:w3."""
    wid = np.array([[self._word2id.get(w, ) for w in [w0, w1, w2]]])
    idx = self._predict(wid)
    for c in [self._id2word[i] for i in idx[, :]]:
      if c not in [w0, w1, w2]:
        return c
    return "unknown"
  def nearby(self, words, num=):
    """Prints out nearby words given a list of words."""
    ids = np.array([self._word2id.get(x, ) for x in words])
    vals, idx = self._session.run(
        [self._nearby_val, self._nearby_idx], {self._nearby_word: ids})
    for i in xrange(len(words)):
      print("\n%s\n=====================================" % (words[i]))
      for (neighbor, distance) in zip(idx[i, :num], vals[i, :num]):
        print("%-20s %6.4f" % (self._id2word[neighbor], distance))
def _start_shell(local_ns=None):
  # An interactive shell is useful for debugging/development.
  import IPython
  user_ns = {}
  if local_ns:
    user_ns.update(local_ns)
  user_ns.update(globals())
  IPython.start_ipython(argv=[], user_ns=user_ns)
def main(_):
  """Train a word2vec model."""
  if not FLAGS.train_data or not FLAGS.eval_data or not FLAGS.save_path:
    print("--train_data --eval_data and --save_path must be specified.")
    sys.exit()
  opts = Options()
  with tf.Graph().as_default(), tf.Session() as session:
    model = Word2Vec(opts, session)
    for _ in xrange(opts.epochs_to_train):
      model.train()  # Process one epoch
      model.eval()  # Eval analogies.
    # Perform a final save.
    model.saver.save(session,
                     os.path.join(opts.save_path, "model.ckpt"),
                     global_step=model.global_step)
    if FLAGS.interactive:
      # E.g.,
      # []: model.analogy('france', 'paris', 'russia')
      # []: model.nearby(['proton', 'elephant', 'maxwell'])
      _start_shell(locals())
if __name__ == "__main__":
  tf.app.run()

curl http://mattmahoney.net/dc/text8.zip > text8.zip
unzip text8.zip
curl https://storage.googleapis.com/google-code-archive-source/v2/code.google.com/word2vec/source-archive.zip > source-archive.zip
unzip -p source-archive.zip  word2vec/trunk/questions-words.txt > questions-words.txt
rm text8.zip source-archive.zip

TF_INC=$(python -c 'import tensorflow as tf; print(tf.sysconfig.get_include())')
g++ -std=c++ -shared word2vec_ops.cc word2vec_kernels.cc -o word2vec_ops.so -fPIC -I $TF_INC -O2 -D_GLIBCXX_USE_CXX11_ABI= 

python word2vec_optimized.py \
  --train_data=text8 \
  --eval_data=questions-words.txt \
  --save_path=./

Relevant Link:

http://www.cnblogs.com/rocketfan/p/4976806.html
https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/examples/tutorials/word2vec/word2vec_basic.py
http://www.aclweb.org/anthology/N1
http://msr-waypoint.com/en-us/um/people/gzweig/Pubs/NAACL2013Regularities.pdf3-1090
http://www.tensorfly.cn/tfdoc/tutorials/word2vec.html
https://github.com/tensorflow/models/tree/master/tutorials/embedding
http://www.tensorfly.cn/tfdoc/tutorials/word2vec.html

6. 循环神经网络(RNN)、LSTM(Long-Short Term Memory, LSTM)

0x1: 语言模型

此教程将展示如何在高难度的语言模型中训练循环神经网络。该问题的目标是获得一个能确定语句概率的概率模型。为了做到这一点，通过之前已经给出的词语来预测后面的词语。我们将使用 PTB(Penn Tree Bank) 数据集，这是一种常用来衡量模型的基准，同时它比较小而且训练起来相对快速。

0x2: LSTM

模型的核心由一个 LSTM 单元组成，其可以在某时刻处理一个词语，以及计算语句可能的延续性的概率。网络的存储状态由一个零矢量初始化并在读取每一个词语后更新。而且，由于计算上的原因，我们将以 batch_size 为最小批量来处理数据。
基础的伪代码就像下面这样：

lstm = rnn_cell.BasicLSTMCell(lstm_size)
# 初始化 LSTM 存储状态.
state = tf.zeros([batch_size, lstm.state_size])

loss = 0.0
for current_batch_of_words in words_in_dataset:
    # 每次处理一批词语后更新状态值.
    output, state = lstm(current_batch_of_words, state)

    # LSTM 输出可用于产生下一个词语的预测
    logits = tf.matmul(output, softmax_w) + softmax_b
    probabilities = tf.nn.softmax(logits)
    loss += loss_function(probabilities, target_words)

0x3: 截断反向传播

为使学习过程易于处理，通常的做法是将反向传播的梯度在（按时间）展开的步骤上照一个固定长度(num_steps)截断。 通过在一次迭代中的每个时刻上提供长度为 num_steps 的输入和每次迭代完成之后反向传导，这会很容易实现。
一个简化版的用于计算图创建的截断反向传播代码：

# 一次给定的迭代中的输入占位符.
words = tf.placeholder(tf.int32, [batch_size, num_steps])

lstm = rnn_cell.BasicLSTMCell(lstm_size)
# 初始化 LSTM 存储状态.
initial_state = state = tf.zeros([batch_size, lstm.state_size])

for i in range(len(num_steps)):
    # 每处理一批词语后更新状态值.
    output, state = lstm(words[:, i], state)

    # 其余的代码.
    # ...

final_state = state

迭代整个数据集

# 一个 numpy 数组，保存每一批词语之后的 LSTM 状态.
numpy_state = initial_state.eval()
total_loss = 0.0
for current_batch_of_words in words_in_dataset:
    numpy_state, current_loss = session.run([final_state, loss],
        # 通过上一次迭代结果初始化 LSTM 状态.
        feed_dict={initial_state: numpy_state, words: current_batch_of_words})
    total_loss += current_loss

0x4: 输入

在输入 LSTM 前，词语 ID 被嵌入到了一个密集的表示中(单词矢量表示可以在不同的单词之间建立关联性的依据)。这种方式允许模型高效地表示词语，也便于写代码

# embedding_matrix 张量的形状是： [vocabulary_size, embedding_size]
word_embeddings = tf.nn.embedding_lookup(embedding_matrix, word_ids)

嵌入的矩阵会被随机地初始化，模型会学会通过数据分辨不同词语的意思

0x5: 损失函数

我们想使目标词语的平均负对数概率最小

论文中的典型衡量标准是每个词语的平均困惑度（perplexity），计算式为

同时我们会观察训练过程中的困惑度值（perplexity）

0x6: 多个 LSTM 层堆叠

要想给模型更强的表达能力，可以添加多层 LSTM 来处理数据。第一层的输出作为第二层的输入，以此类推。
类 MultiRNNCell 可以无缝的将其实现

lstm = rnn_cell.BasicLSTMCell(lstm_size)
stacked_lstm = rnn_cell.MultiRNNCell([lstm] * number_of_layers)

initial_state = state = stacked_lstm.zero_state(batch_size, tf.float32)
for i in range(len(num_steps)):
    # 每次处理一批词语后更新状态值.
    output, state = stacked_lstm(words[:, i], state)

    # 其余的代码.
    # ...

final_state = state

0x7: 在GPU上编译并运行

wget http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz
python ptb_word_lm.py --data_path=./simple-examples/data/ --alsologtostderr --model large

Relevant Link:

http://colah.github.io/posts/2015-08-Understanding-LSTMs/
http://lib.csdn.net/article/deeplearning/59839
http://www.tensorfly.cn/tfdoc/tutorials/recurrent.html

7. 用深度学习网络搭建一个聊天机器人

python udc_train.py --num_gpus=
python udc_test.py --model_dir=./data
python udc_predict.py --model_dir=./data

import os
import time
import itertools
import sys
import numpy as np
import tensorflow as tf
import udc_model
import udc_hparams
import udc_metrics
import udc_inputs
from models.dual_encoder import dual_encoder_model
from models.helpers import load_vocab

tf.flags.DEFINE_string("model_dir", None, "Directory to load model checkpoints from")
tf.flags.DEFINE_string("vocab_processor_file", "./data/vocab_processor.bin", "Saved vocabulary processor file")
FLAGS = tf.flags.FLAGS

if not FLAGS.model_dir:
  print("You must specify a model directory")
  sys.exit()

def tokenizer_fn(iterator):
  return (x.split(" ") for x in iterator)

# Load vocabulary
vp = tf.contrib.learn.preprocessing.VocabularyProcessor.restore(
  FLAGS.vocab_processor_file)

# Load your own data here
INPUT_CONTEXT = "how old are you!"
POTENTIAL_RESPONSES = ["fine, thanks", "twenty six yesrs old"]

def get_features(context, utterance):
  context_matrix = np.array(list(vp.transform([context])))
  utterance_matrix = np.array(list(vp.transform([utterance])))
  context_len = len(context.split(" "))
  utterance_len = len(utterance.split(" "))
  features = {
    "context": tf.convert_to_tensor(context_matrix, dtype=tf.int64),
    "context_len": tf.constant(context_len, shape=[,], dtype=tf.int64),
    "utterance": tf.convert_to_tensor(utterance_matrix, dtype=tf.int64),
    "utterance_len": tf.constant(utterance_len, shape=[,], dtype=tf.int64),
  }
  return features, None

if __name__ == "__main__":
  hparams = udc_hparams.create_hparams()
  model_fn = udc_model.create_model_fn(hparams, model_impl=dual_encoder_model)
  estimator = tf.contrib.learn.Estimator(model_fn=model_fn, model_dir=FLAGS.model_dir)

  # Ugly hack, seems to be a bug in Tensorflow
  # estimator.predict doesn't work without this line
  estimator._targets_info = tf.contrib.learn.estimators.tensor_signature.TensorSignature(tf.constant(, shape=[,]))

  print("Context: {}".format(INPUT_CONTEXT))
  for r in POTENTIAL_RESPONSES:
    prob = estimator.predict(input_fn=lambda: get_features(INPUT_CONTEXT, r))
    print("{}: {:g}".format(r, prob[,]))

我们可以利用模型训练学习得到的模型和实际的场景进行对比，例如我们认为

INPUT_CONTEXT = "how old are you!"
POTENTIAL_RESPONSES = ["fine, thanks", "twenty six yesrs old"]

然后看模型是否得到和我们假定的一样的结果

Relevant Link:

http://naturali.io/deeplearning/chatbot/introduction/2016/04/28/chatbot-part1.html
http://naturali.io/deeplearning/chatbot/introduction/2016/05/16/chatbot-part2.html
https://arxiv.org/abs/1506.08909
https://github.com/dennybritz/chatbot-retrieval

Copyright (c) 2017 LittleHann All rights reserved