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

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏生信小驿站

机器学习识别乳腺癌

人工神经网络是一种类似于大脑神经突触连接的结构进行信息处理的数学模型,由大量的输入层节点、隐藏层节点和输出层节点连接构成。有关神经网络算法最核心的三个问题就是:...

1212
来自专栏一心无二用,本人只专注于基础图像算法的实现与优化。

基于模糊集理论的一种图像二值化算法的原理、实现效果及代码

  这是篇很古老的论文中的算法,发表与1994年,是清华大学黄良凯(Liang-kai Huang) 所写,因此国外一些论文里和代码里称之为Huang's fu...

30211
来自专栏张俊红

Sklearn参数详解—GBDT

这篇介绍Boosting的第二个模型GBDT,GBDT和Adaboost都是Boosting模型的一种,但是略有不同,主要有以下两点不同:

1944
来自专栏程序生活

机器学习(四)通过递归的矩阵向量空间预测组合语义摘要简介方法结果结论

Semantic Compositionality Through Recursive Matrix-Vector Spaces 摘要 单字矢量空间模型已经在学...

3517
来自专栏用户2442861的专栏

Logistic回归与梯度下降法

http://blog.csdn.net/acdreamers/article/details/44657979

2171
来自专栏LhWorld哥陪你聊算法

【深度学习篇】--神经网络中解决梯度弥散问题

在梯度下降中,随着算法反向反馈到前面几层,梯度会越来越小,最终,没有变化,这时或许还没有收敛到比较好的解,这就是梯度消失问题,深度学习遭受不稳定的梯度,不同层学...

4544
来自专栏数据星河

人工智能之机器学习CART算法解析

  人工智能之机器学习主要有三大类:1)分类;2)回归;3)聚类。今天我们重点探讨一下CART算法。

1290
来自专栏菩提树下的杨过

机器学习笔记(5):多类逻辑回归-手动添加隐藏层

了解神经网络原理的同学们应该都知道,隐藏层越多,最终预测结果的准确度越高,但是计算量也越大,在上一篇的基础上,我们手动添加一个隐藏层,代码如下(主要参考自多层感...

2326
来自专栏生信小驿站

R 集成算法③ 随机森林

按这种算法得到的随机森林中的每一棵都是很弱的,但是大家组合起来就很厉害了。我觉得可以这样比喻随机森林算法:每一棵决策树就是一个精通于某一个窄领域的专家,这样在随...

1724
来自专栏机器学习、深度学习

人脸检测--Face Detection with End-to-End Integration of a ConvNet and a 3D Model

Face Detection with End-to-End Integration of a ConvNet and a 3D Model ECCV201...

2287

扫码关注云+社区

领取腾讯云代金券