TensorFlow深入MNIST笔记[三]
TensorFlow是进行大规模数值计算的强大库。其优点之一是实施和训练深层神经网络。
加载MNIST数据
from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets(‘MNIST_data‘, one_hot=True)
这mnist是一个轻量级的类，它将训练，验证和测试集存储为NumPy数组。它还提供了一个迭代数据服务的功能，我们将在下面使用。
启动TensorFlow InteractiveSession
TensorFlow依靠高效的C ++后端来进行计算。与该后端的连接称为会话。TensorFlow程序的常见用法是首先创建一个图形，然后在会话中启动它。
这里使用方便的InteractiveSession类，这使得TensorFlow更加灵活地构建代码。它允许您与运行图形的运算图进行交织操作 。如果您没有使用 InteractiveSession，那么您应该在开始会话并启动图之前构建整个计算 图。
import tensorflow as tf sess = tf.InteractiveSession()
计算图
为了在Python中进行有效的数值计算，我们通常使用像NumPy这样的数据库 ，可以使用诸如Python之外的矩阵乘法等昂贵的操作，使用其他语言实现的高效代码。不幸的是，每次操作都需要重新切换到Python的开销很大。如果要在GPU上运行计算或以分布式方式运行计算，那么这种开销尤其糟糕，传输数据的成本很高。
TensorFlow也在Python之外进行了大量的工作，但它需要进一步的工作来避免这种开销。TensorFlow不是独立于Python运行单一昂贵的操作，而是可以描述完全在Python之外运行的交互操作的图形。这种方法类似于Theano或Torch所使用的方法。
Python代码的作用是构建这个外部计算图，并且决定运行计算图的哪些部分。
建立一个Softmax回归模型
我们通过创建输入图像和目标输出类的节点来开始构建计算图。
x = tf.placeholder(tf.float32, shape=[None, 784]) y_ = tf.placeholder(tf.float32, shape=[None, 10])
x和y_是每个placeholder要求TensorFlow运行计算时输入的值。
784是单个的维数，None指示所述第一尺寸，对应于批量大小，可以是任何大小的。
目标输出类y_也将由二维张量组成，其中每行是一个10维向量，指示对应的MNIST图像属于哪个数字类（零到九个）。
Variable是居住在TensorFlow计算图中的值。它可以被计算使用甚至修改。在机器学习应用中，通常有一个模型参数为 Variable
W = tf.Variable(tf.zeros([784,10])) b = tf.Variable(tf.zeros([10]))
W是一个784x10矩阵（因为我们有784个输入特征和10个输出），b是一个10维向量（因为我们有10个类）。必须使用该会话初始化它们。此步骤获取已经指定的初始值（在这种情况下为零），并将其分配给每个 Variable。这可以Variables一次完成：
sess.run(tf.global_variables_initializer())
预测类和损失函数
我们现在可以实现我们的回归模型。只需一行！我们将矢量化输入图像乘以x权重矩阵W，加上偏差b。
y = tf.matmul(x,W) + b
损失函数是应用于模型预测的目标和softmax激活函数之间的交叉熵。与初学者教程一样，我们使用稳定的公式：
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
tf.reduce_mean取平均
tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)使用详细介绍如下：
import tensorflow as tf
# our NN‘s output
logits = tf.constant([[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0]])
# step1:do softmax
y = tf.nn.softmax(logits)
# true label
y_ = tf.constant([[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]])
# step2:do cross_entropy
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
# do cross_entropy just one step
cross_entropy2 = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y_)) # dont forget tf.reduce_sum()!!
with tf.Session() as sess:
softmax = sess.run(y)
c_e = sess.run(cross_entropy)
c_e2 = sess.run(cross_entropy2)
print("step1:softmax result=")
print(softmax)
print("step2:cross_entropy result=")
print(c_e)
print("Function(softmax_cross_entropy_with_logits) result=")
print(c_e2)
输出：
训练模型
现在我们已经定义了我们的模型和训练损失函数，直接使用TensorFlow进行训练。因为TensorFlow知道整个计算图，它可以使用自动找出相对于每个变量的损失的梯度。TensorFlow具有多种 内置优化算法。对于这个例子，我们将使用最大梯度下降，步长为0.5来降低交叉熵。
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
TensorFlow实际上在这一行中做的是向计算图添加新的操作。这些操作包括计算梯度，计算参数更新步骤，以及对参数应用更新步骤。
返回的操作运行train_step时，将梯度下降更新应用于参数。因此，训练模型可以通过反复运行来实现train_step。
for _ in range(1000):
batch = mnist.train.next_batch(100)
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
每个训练迭代中加载100个训练样例。然后我们运行该 train_step操作，feed_dict用于替换placeholder张量 x和y_训练示例。请注意，您可以使用feed_dict- 替换计算图中的任何张量- 它不仅限于placeholder
评估模型
首先，我们将弄清楚我们预测正确的标签。是一个非常有用的功能，它给出沿某个轴的张量中最高条目的索引。tf.argmax例如，tf.argmax(y,1)我们的模型认为是每个输入最有可能的标签，tf.argmax(y_,1)而是真正的标签。我们可以tf.equal用来检查我们的预测是否符合真相。
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
这给了我们一个布尔的列表。为了确定哪个部分是正确的，我们转换为浮点数，然后取平均值。例如， [True, False, True, True]会变成[1,0,1,1]
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
构建多层卷积网络
权重初始化
创建大量的权重和偏差。通常应该用少量的噪声来初始化重量以进行对称断裂，并且防止0梯度。
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)
卷积和集合
TensorFlow还为卷积和集合操作提供了很大的灵活性。我们如何处理边界？我们的步幅是多少？我们的卷积使用一个步长，零填充，使输出的大小与输入相同。为了使代码更清洁，我们还将这些操作抽象为函数。
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding=‘SAME‘)
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding=‘SAME‘)
第一卷积层
我们现在可以实现我们的第一层。它将由卷积组成，卷积将为每个5x5补丁计算32个功能。它的重量张量将具有一个形状[5, 5, 1, 32]。前两个维度是补丁大小，下一个是输入通道的数量，最后一个是输出通道的数量。我们还将有一个偏置向量，每个输出通道都有一个分量。我们还将有一个偏置向量，每个输出通道都有一个分量。
W_conv1 = weight_variable([5, 5, 1, 32]) b_conv1 = bias_variable([32])
要应用图层，我们首先重新x形成4d张量，第二和第三维对应于图像的宽度和高度，最后的尺寸对应于颜色通道的数量。
x_image = tf.reshape(x, [-1, 28, 28, 1])
然后我们x_image与权重张量进行卷积，添加偏差，应用ReLU函数，最后加入最大值。该max_pool_2x2方法将图像大小减小到14x14。
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) h_pool1 = max_pool_2x2(h_conv1)
第二卷积层
为了构建一个深层次的网络，我们堆叠这种类型的几层。第二层将为每个5x5补丁提供64个功能。
W_conv2 = weight_variable([5, 5, 32, 64]) b_conv2 = bias_variable([64]) h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) h_pool2 = max_pool_2x2(h_conv2)
密集层
现在图像尺寸已经缩小到7x7，我们添加了一个具有1024个神经元的完全连接的图层，以便对整个图像进行处理。我们从汇集层将张量重塑成一批向量，乘以权重矩阵，添加偏倚并应用ReLU。
W_fc1 = weight_variable([7 * 7 * 64, 1024]) b_fc1 = bias_variable([1024]) h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64]) h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
退出
我们创建一个placeholder神经元在输出期间输出的概率。TensorFlow的tf.nn.dropoutop自动处理缩放神经元输出，除了掩盖它们，所以退出只是工作，没有任何额外的缩放
keep_prob = tf.placeholder(tf.float32) h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
读出层
最后，我们添加一层，就像上面一层softmax回归一样。
W_fc2 = weight_variable([1024, 10]) b_fc2 = bias_variable([10]) y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
培训和评估模型
差异在于：
- 我们将用更复杂的ADAM优化器替换最陡峭的梯度下降优化器。
- 我们将包括额外的参数
keep_prob中feed_dict，控制辍学率。 - 在培训过程中，我们将每隔100次迭代添加日志记录。
我们也将使用tf.Session而不是tf.InteractiveSession。这更好地分离了创建图形（模型规范）的过程和评估图形（模型拟合）的过程。它通常会使更清洁的代码。在一个with块中创建tf.Session， 以便在块被退出后自动销毁。
随意运行这段代码。请注意，它会执行20,000次训练迭代，并且可能需要一段时间（可能长达半小时），具体取决于您的处理器。
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(20000):
batch = mnist.train.next_batch(50)
if i % 100 == 0:
train_accuracy = accuracy.eval(feed_dict={
x: batch[0], y_: batch[1], keep_prob: 1.0})
print(‘step %d, training accuracy %g‘ % (i, train_accuracy))
train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
print(‘test accuracy %g‘ % accuracy.eval(feed_dict={
x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
运行此代码后的最终测试设置精度应为大约99.2％。