02 The TensorFlow Way（3）

Implementing Back Propagation

        使用TensorFlow的好处之一是可以跟踪操作，并根据反向传播自动更新模型变量。如下，我们将介绍如何在训练机器学习模型时将这一方面作为优势。

        Getting ready：

        现在我们将介绍如何在模型中改变我们的变量，使损失函数最小化。 我们已经了解了如何使用对象和操作，并创建了可以测量我们的预测和目标之间距离的损失函数。 现在我们只需要告诉TensorFlow如何通过我们的计算来传播错误图形更新变量并最大限度地减少损失函数。 这是通过声明优化函数来完成的。 一旦我们有一个声明的优化函数，TensorFlow将通过并计算出图中我们所有计算的反向传播项。 当我们提供数据并减少损失函数时，TensorFlow将相应地修改图中的变量。

        具体实现看下面例子：

        How to do it...:

        以下是回归示例的工作原理：

        1.我们从加载数字Python包，numpy和tensorflow开始：

        import numpy as np

        import tensorflow as tf

        2.graph session:

        sess = tf.Session()

        3.接下来我们创建数据，占位符和A变量：

        x_vals = np.random.normal(1, 0.1, 100)

        y_vals = np.repeat(10., 100)

        x_data = tf.placeholder(shape=[1], dtype=tf.float32)

        y_target = tf.placeholder(shape=[1], dtype=tf.float32)

        A = tf.Variable(tf.random_normal(shape=[1]))
        4.我们将乘法运算添加到我们的graph中：

        my_output = tf.mul(x_data, A)
        5.接下来我们在乘法输出和目标之间增加L2损失函数：

        loss = tf.square(my_output - y_target)
        6.在我们run之前，必须初始化变量：

        init = tf.initialize_all_variables()

        sess.run(init)

        7.现在我们必须声明一种在图中优化变量的方法。 我们声明一个优化器算法。 大多数优化算法需要知道每次迭代有多远。 该距离由学习率控制。 如果我们的学习率太大，我们的算法可能会超出最小值，但是如果我们的学习率太小，则算法可能需要太长的时间才能收敛; 这与梯度消失和梯度爆炸问题有关。 学习率对收敛性有很大的影响，我们将在本节末尾进行讨论。 在这里，我们使用标准梯度下降算法，有许多不同的优化算法运行不同，可以根据问题做更好或更差。 有关不同优化算法的很好的概述，请参阅Sebastian Ruder在本配方末尾的另见部分的论文：

        my_opt = tf.train.GradientDescentOptimizer(learning_rate=0.02)

        train_step = my_opt.minimize(loss)
        8.第一步是循环使用训练算法，并告诉TensorFlow训练多次。 我们会做这101次，每25次迭代打印一次结果。 要训练，我们将选择一个随机的x和y条目，并通过图表进行输入。 TensorFlow将自动计算损失，并略微改变A偏差以最大限度地减少损失：
        for i in range(100): 

              rand_index = np.random.choice(100)

              rand_x = [x_vals[rand_index]]

              rand_y = [y_vals[rand_index]]

              sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})

              if (i+1)%25==0:

                     print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)))

                     print('Loss = ' + str(sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y})))

        9.现在我们将介绍简单分类示例的代码。 如果我们首先重新设置图形，我们可以使用相同的TensorFlow脚本。 请记住，我们将尝试找到一个最佳的translation，A将将两个分布转换为原始，而Sigmoid函数会将两个分割分成两个不同的类。

        10.首先我们重新设置graph并重新初始化graph session：
        from tensorflow.python.framework import ops

        ops.reset_default_graph()

        sess = tf.Session()
        11.接下来，我们将从两个不同的正态分布N（-1,1）和N（3,1）创建数据。 我们还将生成目标标签，数据占位符和偏差变量A：
        x_vals = np.concatenate((np.random.normal(-1, 1, 50), np.random.normal(3, 1, 50)))

        y_vals = np.concatenate((np.repeat(0., 50), np.repeat(1., 50)))

        x_data = tf.placeholder(shape=[1], dtype=tf.float32)

        y_target = tf.placeholder(shape=[1], dtype=tf.float32)

        A = tf.Variable(tf.random_normal(mean=10, shape=[1]))

        **请注意，我们将A初始化为大约10的值，远离理论值-1。 我们这样做是为了显示算法如何从值10收敛到最优值-1。
        12.接下来，我们将翻译操作添加到图形。 请记住，我们不需要将其包装在一个sigmoid函数中，因为损失函数将为我们做到这一点：

        my_output = tf.add(x_data, A)
        13.因为特定的损失函数需要具有与它们相关联的额外维度的批次数据（附加维度是批次号），我们将使用函数expand_dims（）向输出添加一个额外的维度。在下一节中， 将讨论如何在培训中使用可变大小的批次。 现在我们一次只会使用一个随机数据点：
        my_output_expanded = tf.expand_dims(my_output, 0)

        y_target_expanded = tf.expand_dims(y_target, 0)
        14.接下来我们将初始化一个变量A：
        init = tf.initialize_all_variables()

        sess.run(init)
        15.现在我们声明损失函数。 将使用不规范的交叉熵用Sigmoid函数转换它们。 TensorFlow有一个函数叫做nn.sigmoid_cross_ entropy_with_logits（）。 如前所述，它希望这些论据具有特定的维度，因此我们必须相应地使用扩展的输出和目标：

        xentropy = tf.nn.sigmoid_cross_entropy_with_logits( my_output_expanded, y_target_expanded)
        16.就像回归的例子，我们需要添加一个优化函数的图，TensorFlow知道如何更新图中的偏差变量：
        my_opt = tf.train.GradientDescentOptimizer(0.05)

        train_step = my_opt.minimize(xentropy)
        17.最后，我们通过随机选择的数据点循环数百次，并更新相应的变量。每200次迭代，我们将打印出一个值和损失：
        for i in range(1400):

           rand_index = np.random.choice(100)

           rand_x = [x_vals[rand_index]]

           rand_y = [y_vals[rand_index]]

           sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})

           if (i+1)%200==0:

               print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)))

               print('Loss = ' + str(sess.run(xentropy, feed_dict={x_data: rand_x, y_target: rand_y})))

        How it works...：
        作为一个总的来说，这两个例子中，我们做了以下：

        1.数据的构建。

        2.初始化占位符和变量。

        3.构建模型。

        4.构造loss function。

        5.设置优化算法。

        6.最后，遍历随机样本数据迭代更新我们的变量。

Evaluating Models：
        我们已经学会了如何在TensorFlow的回归和分类算法。完成后，我们必须能够评估模型的预测，以确定它有多好。
        Getting ready：
        评价模型是非常重要的，每一个后续的模型将有某种形式的模型评价。使用tensorflow，我们必须建立这个功能的计算图，称之为期间和/或之后，我们的模型训练。
        评估模型在训练过程中给我们洞察算法，并可能给我们提示调试它，改善它，或完全改变模型。而训练不是必要的评价过程中，我们将展示如何做到这两者的回归和分类。
        训练后，我们需要量化模型如何执行的数据。理想情况下，我们有一个单独的训练和测试集（甚至验证集），我们可以评估模型。
        当我们想评估一个模型，我们会想这样做的一个大批量的数据点。如果我们已经实施批处理培训，我们可以重用我们的模型，这样的一批预测。如果我们已经实施随机训练，我们可能需要创建一个单独的评价程序，可以处理数据分批。
        How to do it...：
        回归模型试图预测连续数。目标不是一个类别，而是一个期望的数字。为了评估这些回归预测的实际目标，我们需要一个总的测量两者之间的距离。大多数情况下，一个有意义的损失函数将满足这些标准。这里是如何改变从上面的简单的回归算法打印输出在训练回路中的损失和评估的损失在最后。对于一个例子，我们将重新审视和重写我们的回归例子，在此之前实施反向传播。

        分类模型预测一类基于数值输入。实际的目标序列的1和0，我们必须测量真实值和预测值多么接近。对分类模型的损失函数通常不是有助于解释我们的模型做的。通常，我们需要某种分类的精度，这是通常的百分比预测正确的类别。

        How it works...：

       import matplotlib.pyplot as plt       import numpy as np       import tensorflow as tf       sess = tf.Session()       x_vals = np.random.normal(1, 0.1, 100)       y_vals = np.repeat(10., 100)       x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)       y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)       batch_size = 25       train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False)       test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))       x_vals_train = x_vals[train_indices]       x_vals_test = x_vals[test_indices]       y_vals_train = y_vals[train_indices]       y_vals_test = y_vals[test_indices]       A = tf.Variable(tf.random_normal(shape=[1,1]))        my_output = tf.matmul(x_data, A)       loss = tf.reduce_mean(tf.square(my_output - y_target))       init = tf.initialize_all_variables()       sess.run(init)       my_opt = tf.train.GradientDescentOptimizer(0.02)       train_step = my_opt.minimize(loss)       for i in range(100):            rand_index = np.random.choice(len(x_vals_train), size=batch_size)           rand_x = np.transpose([x_vals_train[rand_index]])           rand_y = np.transpose([y_vals_train[rand_index]])           sess.run(train_step, feed_dict={x_data: rand_x, y_target:rand_y})       if (i+1)%25==0:           print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)))           print('Loss = ' + str(sess.run(loss, feed_dict={x_data:rand_x, y_target: rand_y})))    Step #25 A = [[ 6.39879179]]    Loss = 13.7903    Step #50 A = [[ 8.64770794]]    Loss = 2.53685    Step #75 A = [[ 9.40029907]]    Loss = 0.818259    Step #100 A = [[ 9.6809473]]    Loss = 1.10908   mse_test = sess.run(loss, feed_dict={x_data: np.transpose([x_vals_test]), y_target: np.transpose([y_vals_test])})   mse_train = sess.run(loss, feed_dict={x_data: np.transpose([x_vals_train]), y_target: np.transpose([y_vals_train])})   print('MSE' on test:' + str(np.round(mse_test, 2)))   print('MSE' on train:' + str(np.round(mse_train, 2)))   MSE on test:1.35   MSE on train:0.88

       from tensorflow.python.framework import ops       ops.reset_default_graph()       sess = tf.Session()       batch_size = 25       x_vals = np.concatenate((np.random.normal(-1, 1, 50), np.random.normal(2, 1, 50)))       y_vals = np.concatenate((np.repeat(0., 50), np.repeat(1., 50)))       x_data = tf.placeholder(shape=[1, None], dtype=tf.float32)       y_target = tf.placeholder(shape=[1, None], dtype=tf.float32)       train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False)       test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))       x_vals_train = x_vals[train_indices]       x_vals_test = x_vals[test_indices]       y_vals_train = y_vals[train_indices]       y_vals_test = y_vals[test_indices]       A = tf.Variable(tf.random_normal(mean=10, shape=[1]))       my_output = tf.add(x_data, A)       init = tf.initialize_all_variables()       sess.run(init)       xentropy = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(my_output, y_target))       my_opt = tf.train.GradientDescentOptimizer(0.05)       train_step = my_opt.minimize(xentropy)       for i in range(1800):           rand_index = np.random.choice(len(x_vals_train), size=batch_size)           rand_x = [x_vals_train[rand_index]]           rand_y = [y_vals_train[rand_index]]           sess.run(train_step, feed_dict={x_data: rand_x, y_target:rand_y})           if (i+1)%200==0:               print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)))               print('Loss = ' + str(sess.run(xentropy, feed_dict={x_data: rand_x, y_target: rand_y})))   Step #200 A = [ 6.64970636]   Loss = 3.39434   Step #400 A = [ 2.2884655]   Loss = 0.456173   Step #600 A = [ 0.29109824]   Loss = 0.312162   Step #800 A = [-0.20045301]   Loss = 0.241349   Step #1000 A = [-0.33634067]   Loss = 0.376786   Step #1200 A = [-0.36866501]   Loss = 0.271654   Step #1400 A = [-0.3727718]   Loss = 0.294866   Step #1600 A = [-0.39153299]   Loss = 0.202275   Step #1800 A = [-0.36630616]   Loss = 0.358463       y_prediction = tf.squeeze(tf.round(tf.nn.sigmoid(tf.add(x_data,A))))   correct_prediction = tf.equal(y_prediction, y_target)   accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))   acc_value_test = sess.run(accuracy, feed_dict={x_data: [x_vals_test], y_target: [y_vals_test]})   acc_value_train = sess.run(accuracy, feed_dict={x_data: [x_vals_train], y_target: [y_vals_train]})   print('Accuracy' on train set: ' + str(acc_value_train))   print('Accuracy' on test set: ' + str(acc_value_test))   Accuracy on train set: 0.925   Accuracy on test set: 0.95