TensorFlow实战-1 以神经网络算法为例的入门

本文由 沈庆阳 所有,转载请与作者取得联系!

TensorFlow相关概念

计算图(Graph)

计算图是TensorFlow中最基本的一个概念。在TensorFlow的程序中，所有的计算操作都会被转化为一张计算图上面的一个节点。使用TensorBoard可以清晰地查看TensorFlow程序生成的计算图。

TensorBoard中查看的一张计算图

计算图的使用

TensorFlow的程序一般分为2个部分。第一个部分是定义部分，其定义了计算图中所有的计算。第二个部分则是运行部分，在该部分执行计算。如求a,b两个变量的和，在TensorFlow的程序中代码如下：

a = tf.constant([1.0, 2.0], name='a')
b = tf.constant([3.0, 4.0], name='b')
result = tf.add(a, b, name='add')

上述代码中的tf是通过import tensorflow as tf得来的。
在TensorFlow的程序运行过程中，其会自动维护一个默认的计算图，这个计算图可以通过调用函数tf.get_default_graph函数来获得。在程序中，通过使用print(a.graph is tf.get_default_graph)来判断当前a张量属于的计算图是否是默认的计算图，其输出的是一个布尔值。
TensorFlow还支持通过调用tf.Graph函数来生成新的计算图。注意，属于不同的计算图上的张量以及运算操作不共享。
TensorFlow计算图创建与定义变量的示例：

# 创建计算图g1，并在其中定义张量v，初始值为0.
g1 = tf.Graph()
with g1.as_default():
  v = tf.get_variable('v', initializer = tf.zeros_initializer(shape=[1]))

# 创建计算图g2，并在其中定义张量v，初始值为1.
g2 = tf.Graph()
with g2.as_default():
  v = tf.get_variable('v', initializer = tf.ones_initializer(shape=[1]))

TensorFlow中计算图读取张量的示例：

# 读取计算图g1中的变量v的值
with tf.Session(graph=g1) as sess:
  tf.global_variables_initializer().run()
  with tf.variable_scope('', reuse=True):
    print(sess.run(tf.get_variable('v')))

# 读取计算图g2中的变量v的值
with tf.Session(graph=g2) as sess:
  tf.global_variables_initializer().run()
  with tf.variable_scope('', reuse=True):
    print(sess.run(tf.get_variable('v')))

由于计算图g1中的v的值是0，g2中的v的值是1，因此上述程序的输出应该是：

[0.]
[1.]

张量（Tensor）

TensorFlow的名字也来源于张量。在TensorFlow中，所有的数据都是以张量的形式来表示的。简单的说，张量就是一个多维数组，但其在TensorFlow中的存储并非以数组的形式来存储的。张量并未真正地保存数值，而是保存的如何得到数值的计算过程。以简单地加法（add）运算为例：

a = tf.constant([1.0, 2.0], name='a')
b = tf.constant([3.0, 4.0], name='b')
result = tf.add(a, b, name='add')
print(result)

其输出为：

Tensor("add:0", shape=(2,), dtype=float32)

很显然，result是一个张量，这从程序的输出便能看得出。此外，我们还能从输出得到其他的信息：一个张量有3个属性。第一，张量的名称（name）；第二，张量的维度（shape）；第三，张量的类型（type）。
张量result的名称为'add'，而输出的结果'add:0'指的是result节点'add'输出的第一个结果。张量的属性名称并不是张量的唯一的标识符，其名称也表明了这个张量是如何计算而来的。张量的命名方式为'node:src_output'，其中node为节点的名称，src_output指明当前张量来自节点的第几个输出（从0开始计数）。
张量的维度（shape）表明了张量的维度信息。上述result输出的shape=(2,)表示的是长度为2的一维数组。
最后便是类型，每个张量的类型都是唯一的。如果出现类型不匹配则会报错，这个错误在TensorFlow的程序中很常见。举例，如果将上述的程序改为如下形式：

a = tf.constant([1, 2], name='a')
b = tf.constant([3.0, 4.0], name='b')
result = tf.add(a, b, name='add')

运行上面的代码则会报错

TypeError: Input 'y' of 'Add' Op has type float32 that does not match type int32 of argument 'x'.

很明显，我们的a张量是int32型的，而b是float32型的，不同的类型无法进行运算操作。如果将a = tf.constant([1, 2], name='a')进行简单修改，声明其张量类型a = tf.constant([1, 2], name='a', dtype=tf.float32)那么程序就可以运行了。
TensorFlow有14种不同的类型，而最常见的有实数（float32、float64）、整数（int8、int16、int32、int64和uint8）、布尔型（bool）和复数（complex64、complex128）。

会话（Session）

在一个TensorFlow的程序中，我们定义好了变量和计算之后，需要通过会话来执行运算。会话拥有并负责管理TensorFlow运行时的所有资源。在会话运行结束之后，需要调用sess.close()来关闭会话从而释放会话中占用的资源（内存、显存等），如果没有做到的话则会产生资源泄露等问题。
通过Python的上下文管理器来使用会话则省去了关闭会话的操作，实现代码如下：

with tf.Session() as sess
  sess.run()
  ...

通过这种方式来创建对话Python的上下文管理器会在程序退出时自动释放所有占用的资源。而且，当程序异常退出/崩溃时，Python也会自动释放资源，因此提倡用这种方式来创建Session。
在TensorFlow的程序中会生成一个默认的计算图，如果没有对运算进行特别指定的话，那么运算则会自动加入到这个计算图当中。通过tf.Tensor.eval函数可以计算一个张量的取值，例子如下：

sess = tf.Session()
with sess.as_default():
  print(result.eval())

有很多TensorFlow的程序是写在Jupyter Notebook中，或在交互式的Python Shell中运行，此时通过tf.InteractiveSession来构建默认会话则会更加方便。使用tf.InteractiveSession可以省去将会话注册为默认会话的过程。
TensorFlow提供了通过ConfigProto Protocol Buffer来配置生成的会话的方法。使用ConfigProto配置会话的例子如下：

config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=True)
# 生成两种会话
sess1 = tf.InteractiveSession(config=config)
sess2 = tf.Session(config=config)

ConfigProto可以配置的的参数很多，如GPU分配的策略、并行的线程数、运算超过时间等。其中，allow_soft_placement与log_device_placement最为常用。
allow_soft_placement决定着程序是否可以在CPU上运行。当其取值为True时：当程序无法在GPU上运行时、指定GPU不存在或运算输入包含对CPU计算结果的引用，上述三个条件满足其一时，GPU上的运算可以放到CPU上运行。通常allow_soft_placement会设置为True，这是为了让程序可以在某些运算GPU不支持的时候自动调整到CPU上运行，而不是报错。
第二个参数log_device_placement设置为True的时候日志中则会记录每个节点被安排在哪个设备上，以方便调试。

使用TensorFlow实现简单的神经网络

在从零开始机器学习-16 初探神经网络（Neural Network）和从零开始机器学习-17 神经网络的训练过程中，介绍了关于神经网络的前向传播算法和反向传播算法。在这里，我们尝试用TensorFlow来实现神经网络的前向传播和反向传播，搭建一个完整的神经网络。

简单的神经网络模型
我们的目标是实现上图的神经网络模型。这个神经网络有2个输入，x1和x2；1个输出y1。在上面的模型中，每个箭头上都有一个权重值，在这里没有标出。关于神经网络的前向传播算法在这里不再赘述。
我们将输入层连接到隐藏层神经元的权重以矩阵的形式表示出来，命名为W1，将隐藏层连接到输入层的权重命名为W2，输入层矩阵命名为X。这样，W1是一个2*3的矩阵，W2是一个1*3的矩阵，X是一个1*2的矩阵。由此，用TensorFlow来表示前向传播结果的代码如下：

a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

矩阵的乘法在TensorFlow中使用tf.matmul函数来实现。

TensorFlow与神经网络参数

在神经网络中，参数的初始值通常是随机数。TensorFlow的变量tf.Variable的作用则是保存和更新神经网络中的参数。TensorFlow具有如下的随机数生成函数：

函数名	随机数分布方式	参数
tf.random_normal	正态分布	平均值、标准差、取值类型
tf.truncated_normal	正态分布，但随机数如果超过2倍标准差则重新随机	平均值、标准差、取值类型
tf.random_uniform	平均分布	最小、最大值、取值类型
tf.randon_gamma	Gamma分布	形状参数Alpha、尺度参数Beta、取值类型

除了随机生成之外，TensorFlow还支持使用常数来填充：

函数名	功能	例子
tf.zeros	生成全是0的数组	tf.zeros([2, 3], int32) -> [[0, 0, 0], [0, 0, 0]]
tf.ones	生成全是1的数组	tf.ones([2, 3], int32) -> [[1, 1, 1], [1, 1, 1]]
tf.fill	使用特定数字填充	tf.fill([2, 3], 2) -> [[2, 2, 2], [2, 2, 2]]
tf.constant	产生一个给定的常量	tf.constant([1, 2]) -> [1, 2]

在TensorFlow中，给神经网络权重初始值的示例如下：

weights = tf.Variable(tf.randon_normal([2, 3], stddev=2))

TensorFlow还支持通过其他变量的初始值来初始化新的变量：

w1 = tf.Variable(weights.initialized_value())
w2 = tf.Variable(weights.initialized_value() * 2)

上述代码中，w1使用了weights的初始值来初始化，w2使用了2倍的weights的初始值进行初始化。
综上，前向传播的算法，在TensorFlow中的代码如下：

import tensorflow as tf

# 声明w1和w2两个变量，正态分布随机数填充
w1 = tf.Variable(tf.random_normal((2, 3), mean=0, stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal((3, 1), mean=0, stddev=1, seed=1))
# 将输入特征先用常量定义
x = tf.constant([[0.5, 0.6]])
# 前向传播
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

# 初始化变量并运行
with tf.Session() as sess:
    sess.run(w1.initializer)
    sess.run(w2.initializer)

    print(sess.run(y))

在上述代码中，可以看到在计算输出Y之前，我们需要给w1和w2分别执行初始化操作。在一个简单的神经网络中，我们也许只需要执行两三次，但当一个网络十分庞大，参数十分巨大的时候，这样便变得十分繁琐，使得代码维护性变差。因此，TensorFlow提供了tf.global_Variable_initializer函数来实现所有变量的初始化。这样一来，上面的两句初始化w1和w2的语句就可以精简为如下：

init_op = tf.global_Variable_initializer()
sess.run(init_op)

TensorFlow实现神经网络训练过程

神经网络的训练过程简言之就是设置神经网络参数的过程。
让我们再来回顾一下反向传播算法：
算法过程：
1：在（0,1）区间内随机初始化网络中的所有连接权值和阈值
2：repeat
3： for all (xk,yk) ∈ D do
4： 根据当前参数和公式计算输出
5： 计算输出层神经元的梯度项gj
6： 计算隐藏层神经元的梯度项eh
7： 计算和更新连接权值ωhj、νih和阈值θj γh
8： end for
9：until 达到停止训练的条件
在每次迭代开始的时候，我们需要选取训练数据。而对于训练数据的选取，通常选择整个数据集中的一小部分，这一小部分也叫作Batch。选择好Batch之后，通过前向传播得到神经网络的预测结果，通过预测与真实情况的差距来决定如何更新参数。
在前面实现前向传播算法的时候，我们使用了tf.constant来给特征赋值，当然这只是权宜之计。因为面对几十个常量来说还好，但一个数据集通常都是巨大的，如果使用tf.constant则会占用大量的资源，造成程序无法运行。幸运的是，TensorFlow提供了解决方案。
TensorFlow提供了placeholder占位符来提供数据的输入。placeholder定义的是一个位置，至于这个位置的数据则是在程序运行的时候再给出。这样，输入数据占用的资源也就要少了很多。在定义placeholder的时候，需要指定这个位置的数据类型，这个数据类型与张量的定义一样是不可以改变的。placeholder的维度信息可以根据提供的数据推导出，因此不一定需要提前指定。我们再使用placeholder将前向传播算法实现一遍：

import tensorflow as tf

# 声明w1和w2两个变量，正态分布随机数填充
w1 = tf.Variable(tf.random_normal((2, 3), mean=0, stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal((3, 1), mean=0, stddev=1, seed=1))
# 将输入特征用placeholder指定
x = tf.placeholder(tf.float32, shape=(1, 2), name='input')
# 前向传播
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

# 初始化变量并运行
with tf.Session() as sess:
    # 全局 变量初始器
    init_op = tf.global_variables_initializer()
    sess.run(init_op)

    print(sess.run(y, feed_dict={x: [[0.5, 0.6]]}))

在sess.run(y, feed_dict={x: [[0.5, 0.6]]})中，我们不再像上一个程序一样直接使用sess.run(y)便可以得到结果，而是需要通过feed_dict给输入指定值。feed_dict是一个字典，在字典中需要给出每个placeholder的取值。
上述字典向placeholder输入的是一个1*2的矩阵，如果我们输入2个、3个或以上的数据时，可以这样写：

feed_dict={x:[[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]]}

对于反向传播算法，我们得到一个训练集的Batch之后，需要使用损失函数来评价当前的预测值与实际的差距，然后再调整神经网络的参数。在TensorFlow中的反向传播算法表示如下：

    # 将输出y通过S函数映射到0到1上
    y = tf.sigmoid(y)
    # 定义交叉熵来作为损失函数
    cross_entropy = - tf.reduce_mean(y_ * tf.log(tf.clip_by_value(y, 1e-10, 1.0))
                                     + (1-y) * tf.log(tf.clip_by_value(1-y, 1e-10, 1.0)))
    learning_rate = 0.001
    # 定义BP算法的优化参数
    train_step = tf.train.AdadeltaOptimizer(learning_rate).minimize(cross_entropy)

TensorFlow实现的神经网络代码

在TensorFlow的程序中，实现神经网络算法的步骤主要如下：
1、定义神经网络的结构和前向传播的结果
2、定义损失函数和反向传播优化算法
3、生成会话并迭代运行反向传播算法
完整的TensorFlow实现的神经网络的代码如下：

import tensorflow as tf

# 使用Numpy的随机数生成训练数据
from numpy.random import RandomState

# 批量大小
batch_size = 16
# 学习速率
learning_rate = 0.001
# 设定训练多少轮
STEPS = 10000

# 声明w1和w2两个变量，正态分布随机数填充
w1 = tf.Variable(tf.random_normal((2, 3), mean=0, stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal((3, 1), mean=0, stddev=1, seed=1))
# 将输入特征用placeholder指定
x = tf.placeholder(tf.float32, shape=(None, 2), name='x-input')
y_ = tf.placeholder(tf.float32, shape=(None, 1), name='y-input')


# 前向传播过程
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

# 反向传播过程
# 将输出y通过S函数映射到0到1上
y = tf.sigmoid(y)
# 定义交叉熵来作为损失函数
cross_entropy = - tf.reduce_mean(y * tf.log(tf.clip_by_value(y, 1e-10, 1.0))
                                 + (1-y) * tf.log(tf.clip_by_value(1-y, 1e-10, 1.0)))
# 定义BP算法的优化参数
train_step = tf.train.AdadeltaOptimizer(learning_rate).minimize(cross_entropy)

# 生成一个训练数据集
rand = RandomState(1)
dataset_size = 512
X = rand.rand(dataset_size, 2)
# 如果x1+x2<1则为正样本，反之为负样本。使用1代表正样本，0代表负样本。
Y = [[int(x1 + x2 < 1)] for (x1, x2) in X]

# 初始化变量并运行
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print('训练之前的权重值为：')
    print(sess.run(w1))
    print(sess.run(w2))

    for i in range(STEPS):
        # 选取训练样本
        start = (i * batch_size) % dataset_size
        end = min(start + batch_size, dataset_size)

        # 训练神经网络并更新参数
        sess.run(train_step,
                 feed_dict={x: X[start:end], y_: Y[start:end]})
        if i % 1000 == 0:
            # 每隔一段时间计算交叉熵并输出
            total_cross_entropy = sess.run(cross_entropy,
                                           feed_dict={x: X, y_: Y})
            print('在训练%d步后，总交叉熵为%g' % (i, total_cross_entropy))

    print('训练完成之后的权重值为：')
    print(sess.run(w1))
    print(sess.run(w2))

运行输出结果如下：

2018-07-06 14:45:08.802697: I C:\tf_jenkins\workspace\tf-nightly-windows\M\windows\PY\36\tensorflow\core\platform\cpu_feature_guard.cc:140] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2
训练之前的权重值为：
[[-0.8113182   1.4845988   0.06532937]
 [-2.4427042   0.0992484   0.5912243 ]]
[[-0.8113182 ]
 [ 1.4845988 ]
 [ 0.06532937]]
在训练0步后，总交叉熵为0.297232
在训练1000步后，总交叉熵为0.296764
在训练2000步后，总交叉熵为0.29613
在训练3000步后，总交叉熵为0.295387
在训练4000步后，总交叉熵为0.294566
在训练5000步后，总交叉熵为0.293689
在训练6000步后，总交叉熵为0.292765
在训练7000步后，总交叉熵为0.291805
在训练8000步后，总交叉熵为0.290816
在训练9000步后，总交叉熵为0.289806
训练完成之后的权重值为：
[[-0.82267827  1.4959371   0.07675438]
 [-2.454002    0.11048034  0.60258645]]
[[-0.82463264]
 [ 1.4965477 ]
 [ 0.07755461]]

可以看到，经过简单的训练之后，训练之前和训练之后的权重不同，交叉熵也稍微降低了。

觉得写的不错的朋友可以点一个 喜欢♥ ~
谢谢你的支持！