TensorFlow机器学习实战指南之第二章

朱雀 2022-01-09 12:49 295阅读 0赞

## **一、计算图中的操作** ##

在这个例子中，我们将结合前面所学的知识，传入一个列表到计算图中的操作，并打印返回值：

声明张量和占位符。这里，创建一个numpy数组，传入计算图操作：

import tensorflow as tf
    import numpy as np
    
    # Create graph
    sess = tf.Session()
    # Create data to feed in
    x_vals = np.array([1., 3., 5., 7., 9.])
    x_data = tf.placeholder(tf.float32)
    m = tf.constant(3.)
    # Multiplication
    prod = tf.multiply(x_data, m)
    for x_val in x_vals:
        print(sess.run(prod, feed_dict={x_data: x_val}))

**输出：**

3.0
    9.0
    15.0
    21.0
    27.0

在下面这个例子中，我们将学习如何在同一个计算图中进行多个乘法操作。

下面我们将用两个矩阵乘以占位符，然后做加法。传入两个矩阵（三维numpy数组）：

我们将传入两个形状为3×5的numpy数组，然后  
每个矩阵乘以常量矩阵（形状为：5×1），将返回一个形状为3×1的矩阵。紧接着再乘以1×1的矩阵，返回的  
结果矩阵仍然为3×1。最后，加上一个3×1的矩阵，示例如下：

### 1.首先，创建数据和占位符： ###

# Create graph
    sess = tf.Session()
    # Create data to feed in
    my_array = np.array([[1., 3., 5., 7., 9.],
                         [-2., 0., 2., 4., 6.],
                         [-6., -3., 0., 3., 6.]])
    x_vals = np.array([my_array, my_array + 1])
    x_data = tf.placeholder(tf.float32, shape=(3, 5))

### 2.接着，创建矩阵乘法和加法中要用到的常量矩阵： ###

m1 = tf.constant([[1.],[0.],[-1.],[2.],[4.]])
    m2 = tf.constant([[2.]])
    a1 = tf.constant([[10.]])

### 3.现在声明操作，表示成计算图： ###

# 1st Operation Layer = Multiplication
    prod1 = tf.matmul(x_data, m1)
    
    # 2nd Operation Layer = Multiplication
    prod2 = tf.matmul(prod1, m2)
    
    # 3rd Operation Layer = Addition
    add1 = tf.add(prod2, a1)

### 4.最后，通过计算图赋值： ###

for x_val in x_vals:
        print(sess.run(add1, feed_dict={x_data: x_val}))

**输出：**

[[102.]
     [ 66.]
     [ 58.]]
    [[114.]
     [ 78.]
     [ 70.]]

在我们通过计算图运行数据之前心里要有个数：声明数据形状，预估操作返回值形状。由于预先不知道  
或者维度在变化，情况也可能发生变化。为了实现目标，**我们指明变化的维度，或者事先不知道的维度设为**  
**none。**例如，占位符有未知列维度，使用方式如下：

x_data = tf.placeholder(tf.float32,shape=(3,None))

## **二、TensorFlow的多层Layer** ##

1.首先，通过numpy创建2D图像，4×4像素图片。我们将创建成四维：第一维和最后一维大小为1。注  
意，TensorFlow的图像函数是处理四维图片的，这四维是：图片数量、高度、宽度和颜色通道。这里是一张  
图片，单颜色通道，所以设两个维度值为1：

# Create graph
    sess = tf.Session()
    
    # Create a small random 'image' of size 4x4
    x_shape = [1, 4, 4, 1]
    x_val = np.random.uniform(size=x_shape)

2.下面在计算图中创建占位符。此例中占位符是用来传入图片的，代码如下：

x_data = tf.placeholder(tf.float32, shape=x_shape)

3.为了创建过滤4×4像素图片的滑动窗口，我们将用TensorFlow内建函数conv2d（）（常用来做图像处  
理）卷积2×2形状的常量窗口。conv2d（）函数传入滑动窗口、过滤器和步长。本例将在滑动窗口四个方向  
上计算，所以在四个方向上都要指定步长。创建一个2×2的窗口，每个方向长度为2的步长。为了计算平均  
值，我们将用常量为0.25的向量与2×2的窗口卷积，代码如下：

my_filter = tf.constant(0.25, shape=[2, 2, 1, 1])
    my_strides = [1, 2, 2, 1]
    mov_avg_layer = tf.nn.conv2d(x_data, my_filter, my_strides,
                                 padding='SAME', name='Moving_Avg_Window')

4.注意，我们通过conv2d（）函数的name参数，把这层Layer命名为“Moving\_Avg\_Window”。

5.现在定义一个自定义Layer，操作滑动窗口平均的2×2的返回值。自定义函数将输入张量乘以一个2×2  
的矩阵张量，然后每个元素加1。因为矩阵乘法只计算二维矩阵，所以剪裁图像的多余维度（大小为1）。  
TensorFlow通过内建函数squeeze（）剪裁。下面是新定义的Layer：

def custom_layer(input_matrix):
        input_matrix_sqeezed = tf.squeeze(input_matrix)
        A = tf.constant([[1., 2.], [-1., 3.]])
        b = tf.constant(1., shape=[2, 2])
        temp1 = tf.matmul(A, input_matrix_sqeezed)
        temp = tf.add(temp1, b) # Ax + b
        return(tf.sigmoid(temp))

6.现在把刚刚新定义的Layer加入到计算图中，并且用tf.name\_scope（）命名唯一的Layer名字，后续在  
计算图中可折叠/扩展Custom\_Layer层，代码如下：

# Add custom layer to graph
    with tf.name_scope('Custom_Layer') as scope:
        custom_layer1 = custom_layer(mov_avg_layer)

7.为占位符传入4×4像素图片，然后执行计算图，代码如下：

print(sess.run(custom_layer1, feed_dict={x_data: x_val}))

**输出：**

[[0.9027293  0.9333066 ]
     [0.84296674 0.8839635 ]]

## **三、TensorFlow实现损失函数** ##

损失函数（loss function）对机器学习来讲是非常重要的。它们度量模型输出值与目标值（target）间的  
差值。本节会介绍TensorFlow中实现的各种损失函数。

为了优化机器学习算法，我们需要评估机器学习模型训练输出结果。在TensorFlow中评估输出结果依赖  
损失函数。损失函数告诉TensorFlow，预测结果相比期望的结果是好是坏。在大部分场景下，我们会有算法  
模型训练的样本数据集和目标值。损失函数比较预测值与目标值，并给出两者之间的数值化的差值。

为了比较不同损失函数的区别，我们将会在图表中绘制出来。先创建计算图，然后加载  
matplotlib（Python的绘图库），代码如下：

import matplotlib.pyplot as plt
    import tensorflow as tf

首先，将讲解回归算法的损失函数。回归算法是预测连续因变量的。创建预测序列和目标序列作为张  
量，预测序列是-1到1之间的等差数列，代码如下：

# Numerical Predictions 
    x_vals = tf.linspace(-1., 1., 500)
    target = tf.constant(0.)

### **1.回归模型的损失函数** ###

（1）L2正则损失函数（即欧拉损失函数）。L2正则损失函数是预测值与目标值差值的平方和。注意，上述  
例子中目标值为0。L2正则损失函数是非常有用的损失函数，因为它在目标值附近有更好的曲度，机器学习  
算法利用这点收敛，并且离目标越近收敛越慢，代码如下：

# L2 loss
    # L = (pred - actual)^2
    l2_y_vals = tf.square(target - x_vals)
    l2_y_out = sess.run(l2_y_vals)

注意：

TensorFlow有内建的L2正则形式，称为nn.l2\_loss（）。这个函数其实是实际L2正则  
的一半，换句话说，它是上面l2\_y\_vals的1/2。

（2）L1正则损失函数（即绝对值损失函数）。与L2正则损失函数对差值求平方不同的是，L1正则损失函数  
对差值求绝对值。L1正则在目标值附近不平滑，这会导致算法不能很好地收敛。代码如下：

# L1 loss
    # L = abs(pred - actual)
    l1_y_vals = tf.abs(target - x_vals)
    l1_y_out = sess.run(l1_y_vals)

（3）Pseudo-Huber 损失函数

Pseudo-Huber损失函数是Huber损失函数的连续、平滑估计，试图利用L1和L2正则削减极值处的陡峭，  
使得目标值附近连续。它的表达式依赖参数delta。我们将绘图来显示delta1=0.25和delta2=5的区别

Huber损失函数经常用于回归问题，它是分段函数，公式如下：

![d849f8f12a13f275f516159564255c742b5.jpg][]

从这个公式可以看出当残差（预测值与目标值的差值，即y-f(x) ）很小的时候，损失函数为L2范数，残差大的时候，为L1范数的线性函数。

Peseudo-Huber损失函数是Huber损失函数的连续、平滑估计，在目标附近连续，公式如下：

![b92d933f77e56583fb92428b7f01ded9aef.jpg][]

该公式依赖于参数delta，delta越大，则两边的线性部分越陡峭。

# Pseudo-Huber loss
    # L = delta^2 * (sqrt(1 + ((pred - actual)/delta)^2) - 1)
    delta1 = tf.constant(0.25)
    phuber1_y_vals = tf.multiply(tf.square(delta1), tf.sqrt(1. + tf.square((target - x_vals) / delta1)) - 1.)
    phuber1_y_out = sess.run(phuber1_y_vals)
    
    delta2 = tf.constant(5.)
    phuber2_y_vals = tf.mul(tf.square(delta2), tf.sqrt(1. + tf.square((target - x_vals) / delta2)) - 1.)
    phuber2_y_out = sess.run(phuber2_y_vals)

以下为L1、L2、Huber损失函数的对比图如下，其中Huber的delta取0.25、5两个值：

![1542450-20190429110720931-1392795860.png][]

x_array = sess.run(x_vals)
    plt.plot(x_array, l2_y_out, 'b-', label='L2 Loss')
    plt.plot(x_array, l1_y_out, 'r--', label='L1 Loss')
    plt.plot(x_array, phuber1_y_out, 'k-.', label='P-Huber Loss(0.25)')
    plt.plot(x_array, phuber2_y_out, 'g:', label='P-Huber Loss(5.)')
    plt.ylim(-0.2, 0.4)
    plt.legend(loc='lower right', prop={
        'size': 11})
    plt.show()

### **2.分类模型的损失函数** ###

分类损失函数主要用于评估预测分类结果，重新定义预测值（-3至5的等差序列）和目标值（目标值为1），如下：

y_pred=tf.linspace(-3., 5., 100)
    
    y_target=tf.constant(1.)
    
    y_targets=tf.fill([100, ], 1.)

（1）Hinge损失函数

Hinge损失常用于二分类问题，主要用来评估向量机算法，但有时也用来评估神经网络算法，公式如下：

![bd9939e6c37df38f1b205cf635637be0465.jpg][]

loss_hinge_vals = tf.maximum(0., 1. – tf.mul(y_target, y_pred))
    
    loss_hinge_out = sess.run(loss_hinge_vals)

（2）两类交叉熵（Cross-entropy）损失函数

交叉熵来自于信息论，是分类问题中使用广泛的损失函数。交叉熵刻画了两个概率分布之间的距离，当两个概率分布越接近时，它们的交叉熵也就越小，给定两个概率分布p和q，则距离如下：

![0e523289fd6456f6c4b284f9be3bd6b8ecd.jpg][]

对于两类问题，当一个概率p=y，则另一个概率q=1-y，因此代入化简后的公式如下：

![f58d117bdf73b1fec780767370a17f9a8fe.jpg][]

# Cross entropy loss
    # L = -actual * (log(pred)) - (1-actual)(log(1-pred))
    xentropy_y_vals = - tf.multiply(target, tf.log(x_vals)) - tf.multiply((1. - target), tf.log(1. - x_vals))
    xentropy_y_out = sess.run(xentropy_y_vals)

（3）Sigmoid交叉熵损失函数

与上面的两类交叉熵类似，只是将预测值y\_pred值通过sigmoid函数进行转换，再计算交叉熵损失。

# Sigmoid entropy loss
    # L = -actual * (log(sigmoid(pred))) - (1-actual)(log(1-sigmoid(pred)))
    # or
    # L = max(actual, 0) - actual * pred + log(1 + exp(-abs(actual)))
    xentropy_sigmoid_y_vals = tf.nn.sigmoid_cross_entropy_with_logits(labels=x_vals, logits=targets)
    xentropy_sigmoid_y_out = sess.run(xentropy_sigmoid_y_vals)

（4）加权交叉熵损失函数

加权交叉熵损失函数是Sigmoid交叉熵损失函数的加权，是对正目标的加权。假定权重为0.5，在TensorFlow中的调用方式如下：

# Weighted (softmax) cross entropy loss
    # L = -actual * (log(pred)) * weights - (1-actual)(log(1-pred))
    # or
    # L = (1 - pred) * actual + (1 + (weights - 1) * pred) * log(1 + exp(-actual))
    weight = tf.constant(0.5)
    xentropy_weighted_y_vals = tf.nn.weighted_cross_entropy_with_logits(x_vals, targets, weight)
    xentropy_weighted_y_out = sess.run(xentropy_weighted_y_vals)

（5）Softmax交叉熵损失函数

Softmax交叉熵损失函数是作用于非归一化的输出结果，只针对单个目标分类计算损失。

通过softmax函数将输出结果转化成概率分布，从而便于输入到交叉熵里面进行计算（交叉熵要求输入为概率），softmax定义如下：

![563ba75679f147df6b0a423e8c0fdc6d2da.jpg][]

结合前面的交叉熵定义公式，则Softmax交叉熵损失函数公式如下：

![cd372968d724931f1b355f265c00bde709f.jpg][]

# Softmax entropy loss
    # L = -actual * (log(softmax(pred))) - (1-actual)(log(1-softmax(pred)))
    unscaled_logits = tf.constant([[1., -3., 10.]])
    target_dist = tf.constant([[0.1, 0.02, 0.88]])
    softmax_xentropy = tf.nn.softmax_cross_entropy_with_logits_v2(labels=unscaled_logits, logits=target_dist)

用于回归相关的损失函数，对比图如下：

![1542450-20190429113736854-671740717.png][]

### **3.总结** ###

下面对各种损失函数进行一个总结，如下表所示：

![82527483dd970e7305df7a41746a3e87d80.jpg][]

在实际使用中，对于回归问题经常会使用MSE均方误差（L2取平均）计算损失，对于分类问题经常会使用Sigmoid交叉熵损失函数。

转载于:https://www.cnblogs.com/xinmomoyan/p/10782374.html

[d849f8f12a13f275f516159564255c742b5.jpg]: /images/20220109/8a97701e1bfd4d12859880280aab26a8.png
[b92d933f77e56583fb92428b7f01ded9aef.jpg]: /images/20220109/9599d2c3e51b497e908c36d90817bcba.png
[1542450-20190429110720931-1392795860.png]: /images/20220109/99c9f39550c34b4cb81306e8e7cd6cc4.png
[bd9939e6c37df38f1b205cf635637be0465.jpg]: /images/20220109/1e4b7db6ddcf407c8196f46ad5ac9c61.png
[0e523289fd6456f6c4b284f9be3bd6b8ecd.jpg]: /images/20220109/12716dfe27994e52b9bdb9ae37c08961.png
[f58d117bdf73b1fec780767370a17f9a8fe.jpg]: /images/20220109/8d100eb77ce7486c8e55c93c95e4ee6c.png
[563ba75679f147df6b0a423e8c0fdc6d2da.jpg]: /images/20220109/0f394d4fac5e440d8b2d5da2f666beeb.png
[cd372968d724931f1b355f265c00bde709f.jpg]: /images/20220109/abc68758fa8340fda195c3cc383ed1c9.png
[1542450-20190429113736854-671740717.png]: /images/20220109/0bde285c7e174bc4a45dc043a0a141de.png
[82527483dd970e7305df7a41746a3e87d80.jpg]: /images/20220109/e2c6cddad46149cdac87d84c0237c094.png