TensorFlow之机器学习入门

TensorFlow 应用实例

上面介绍了 TensorFlow 中的一些基本概念，下面我们通过一个小例子来了解一下怎么使用 TensorFlow 进行机器学习。

建立模型(Model)

如下为我们进行某项实验获得的一些实验数据：

输入	输出
1	4.8
2	8.5
3	10.4
6	21
8	25.3

我们将这些数据放到一个二维图上可以看的更直观一些，如下，这些数据在图中表现为一些离散的点：

我们需要根据现有的这些数据归纳出一个通用模型，通过这个模型我们可以预测其他的输入值产生的输出值。
如下图，我们选择的模型既可以是红线表示的鬼都看不懂的曲线模型，也可以是蓝线表示的线性模型，在概率统计理论的分析中，这两种模型符合真实模型的概率是一样的。

根据 “奥卡姆剃刀原则-若有多个假设与观察一致，则选最简单的那个，蓝线表示的线性模型更符合我们的直观预期。
如果用 xx 表示输入， yy 表示输出，线性模型可以用下面的方程表示：
y=W×x+b
y=W×x+b

即使我们选择了直线模型，可以选择的模型也会有很多，如下图的三条直线都像是一种比较合理的模型，只是 WW和bb参数不同。这时我们需要设计一个损失模型(loss model)，来评估一下哪个模型更合理一些，并找到一个最准确的模型。

 

如下图每条黄线代表线性模型计算出来的值与实际输出值之间的差值:

我们用y′y′表示实验得到的实际输出，用下面的方程表示我们的损失模型：

显然，损失模型里得到的lossloss越小，说明我们的线性模型越准确。

使用 TensorFlow 实现模型

上面我们根据实验数据建立了一个线性模型，并为这个线性模型设计了一个损失模型，下面介绍的是怎么在 TensorFlow 中实现我们设计的模型。
在我们的线性模型 y=W×x+by=W×x+b 中，输入xx可以用占位 Tensor 表示，输出yy可以用线性模型的输出表示，我们需要不断的改变WW和bb的值，来找到一个使lossloss最小的值。这里WW和bb可以用变量 Tensor 表示。使用tf.Variable()可以创建一个变量 Tensor，如下就是我们模型的实现代码：
 

import tensorflow as tf

# 创建变量 W 和 b 节点，并设置初始值
W = tf.Variable([.1], dtype=tf.float32)
b = tf.Variable([-.1], dtype=tf.float32)
# 创建 x 节点，用来输入实验中的输入数据
x = tf.placeholder(tf.float32)
# 创建线性模型
linear_model = W*x + b

# 创建 y 节点，用来输入实验中得到的输出数据，用于损失模型计算
y = tf.placeholder(tf.float32)
# 创建损失模型
loss = tf.reduce_sum(tf.square(linear_model - y))

# 创建 Session 用来计算模型
sess = tf.Session()

通过tf.Variable()创建变量 Tensor 时需要设置一个初始值，但这个初始值并不能立即使用，例如上面的代码中，我们使用print(sess.run(W))尝试打印W的值会得到下面提示未初始化的异常

tensorflow.python.framework.errors_impl.FailedPreconditionError: Attempting to use uninitialized value Variable

变量 Tensor 需要经过下面的 init 过程后才能使用：

# 初始化变量
init = tf.global_variables_initializer()
sess.run(init)

这之后再使用print(sess.run(W))打印就可以看到我们之前赋的初始值：

[ 0.1]

变量初始化完之后，我们可以先用上面对W和b设置的初始值0.1和-0.1运行一下我们的线性模型看看结果：

print(sess.run(linear_model, {x: [1, 2, 3, 6, 8]}))

输出结果为：

[ 0.          0.1         0.20000002  0.5         0.69999999]

貌似与我们实验的实际输出差距很大，我们再运行一下损失模型：

print(sess.run(loss, {x: [1, 2, 3, 6, 8], y: [4.8, 8.5, 10.4, 21.0, 25.3]}))

得到的损失值也很大

1223.05

我们可以用tf.assign()对W和b变量重新赋值再检验一下：

# 给 W 和 b 赋新值
fixW = tf.assign(W, [2.])
fixb = tf.assign(b, [1.])
# run 之后新值才会生效
sess.run([fixW, fixb])
# 重新验证损失值
print(sess.run(loss, {x: [1, 2, 3, 6, 8], y: [4.8, 8.5, 10.4, 21.0, 25.3]}))

输出的损失值比之前的小了很多：

159.94

我们需要不断调整变量W和b的值，找到使损失值最小的W和b。这肯定是一个very boring的过程，因此 TensorFlow 提供了训练模型的方法，自动帮我们进行这些繁琐的训练工作。

使用 TensorFlow 训练模型

TensorFlow 提供了很多优化算法来帮助我们训练模型。最简单的优化算法是梯度下降(Gradient Descent)算法，它通过不断的改变模型中变量的值，来找到最小损失值。
如下的代码就是使用梯度下降优化算法帮助我们训练模型：

# 创建一个梯度下降优化器，学习率为0.001
optimizer = tf.train.GradientDescentOptimizer(0.001)
train = optimizer.minimize(loss)

# 用两个数组保存训练数据
x_train = [1, 2, 3, 6, 8]
y_train = [4.8, 8.5, 10.4, 21.0, 25.3]

# 训练10000次
for i in range(10000):
    sess.run(train, {x: x_train, y: y_train})

# 打印一下训练后的结果
print('W: %s b: %s loss: %s' % (sess.run(W), sess.run(b), sess.run(loss, {x: x_train , y: y_train})))

打印出来的训练结果如下，可以看到损失值已经很小了：

W: [ 2.98236108] b: [ 2.07054377] loss: 2.12941

我们整理一下前面的代码，完整的demo代码如下，将下面的代码保存在一个demo.py文件里，通过python3 demo.py执行一下就可以看到训练结果了：

import tensorflow as tf

# 创建变量 W 和 b 节点，并设置初始值
W = tf.Variable([.1], dtype=tf.float32)
b = tf.Variable([-.1], dtype=tf.float32)
# 创建 x 节点，用来输入实验中的输入数据
x = tf.placeholder(tf.float32)
# 创建线性模型
linear_model = W * x + b

# 创建 y 节点，用来输入实验中得到的输出数据，用于损失模型计算
y = tf.placeholder(tf.float32)
# 创建损失模型
loss = tf.reduce_sum(tf.square(linear_model - y))

# 创建 Session 用来计算模型
sess = tf.Session()

# 初始化变量
init = tf.global_variables_initializer()
sess.run(init)

# 创建一个梯度下降优化器，学习率为0.001
optimizer = tf.train.GradientDescentOptimizer(0.001)
train = optimizer.minimize(loss)

# 用两个数组保存训练数据
x_train = [1, 2, 3, 6, 8]
y_train = [4.8, 8.5, 10.4, 21.0, 25.3]

# 训练10000次
for i in range(10000):
    sess.run(train, {x: x_train, y: y_train})

# 打印一下训练后的结果
print('W: %s b: %s loss: %s' % (sess.run(W), sess.run(
    b), sess.run(loss, {x: x_train, y: y_train})))

TensorFlow 高级训练模型

tf.estimator是TensorFlow提供的高级库，提供了很多常用的训练模型，可以简化机器学习中的很多训练过程，如：

• 运行训练循环
• 运行评估循环
• 管理训练数据集

评估模型

前面的demo中我们构建了一个线性模型，通过使用一组实验数据训练我们的线性模型，我们得到了一个自认为损失最小的最优模型，根据训练结果我们的最优模型可以表示为下面的方程：
y=2.98x+2.07

但是这个我们自认为的最优模型是否会一直是最优的？我们需要通过一些新的实验数据来 评估(evaluation)模型的 泛化性能(generalization performance)，如果新的实验数据应用到到这个模型中损失值越小，那么这个模型的泛化性能就越好，反之就越差。下面的demo中我们也会看到怎么评估模型。

使用LinearRegressor

 

前面我们构建了一个线性模型，通过训练得到一个线性回归方程。tf.estimator中也提供了线性回归的训练模型tf.estimator.LinearRegressor，下面的代码就是使用LinearRegressor训练并评估模型的方法：

# 我们会用到NumPy来处理各种训练数据
import numpy as np
import tensorflow as tf

# 创建一个特征向量列表，该特征列表里只有一个特征向量，
# 该特征向量为实数向量，只有一个元素的数组，且该元素名称为 x，
# 我们还可以创建其他更加复杂的特征列表
feature_columns = [tf.feature_column.numeric_column("x", shape=[1])]

# 创建一个LinearRegressor训练器，并传入特征向量列表
estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns)

# 保存训练用的数据
x_train = np.array([1., 2., 3., 6., 8.])
y_train = np.array([4.8, 8.5, 10.4, 21.0, 25.3])

# 保存评估用的数据
x_eavl = np.array([2., 5., 7., 9.])
y_eavl = np.array([7.6, 17.2, 23.6, 28.8])

# 用训练数据创建一个输入模型，用来进行后面的模型训练
# 第一个参数用来作为线性回归模型的输入数据
# 第二个参数用来作为线性回归模型损失模型的输入
# 第三个参数batch_size表示每批训练数据的个数
# 第四个参数num_epochs为epoch的次数，将训练集的所有数据都训练一遍为1次epoch
# 低五个参数shuffle为取训练数据是顺序取还是随机取
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=2, num_epochs=None, shuffle=True)

# 再用训练数据创建一个输入模型，用来进行后面的模型评估
train_input_fn_2 = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=2, num_epochs=1000, shuffle=False)

# 用评估数据创建一个输入模型，用来进行后面的模型评估
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_eavl}, y_eavl, batch_size=2, num_epochs=1000, shuffle=False)

# 使用训练数据训练1000次
estimator.train(input_fn=train_input_fn, steps=1000)

# 使用原来训练数据评估一下模型，目的是查看训练的结果
train_metrics = estimator.evaluate(input_fn=train_input_fn_2)
print("train metrics: %r" % train_metrics)

# 使用评估数据评估一下模型，目的是验证模型的泛化性能
eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print("eval metrics: %s" % eval_metrics)

运行上面的代码输出为：

train metrics: {'loss': 1.0493528, 'average_loss': 0.52467638, 'global_step': 1000}
eval metrics: {'loss': 0.72186172, 'average_loss': 0.36093086, 'global_step': 1000}

评估数据的loss比训练数据还要小，说明我们的模型泛化性能很好。

自定义Estimator模型

tf.estimator库中提供了很多预定义的训练模型，但是有可能这些训练模型不能满足我们的需求，我们需要使用自己构建的模型。
我们可以通过实现tf.estimator.Estimator的子类来构建我们自己的训练模型，LinearRegressor就是Estimator的一个子类。另外我们也可以只给Estimator基类提供一个model_fn的实现，定义我们自己的模型训练、评估方法以及计算损失的方法。
下面的代码就是使用我们最开始构建的线性模型实现自定义Estimator的实例。

import numpy as np
import tensorflow as tf

# 定义模型训练函数，同时也定义了特征向量


def model_fn(features, labels, mode):
    # 构建线性模型
    W = tf.get_variable("W", [1], dtype=tf.float64)
    b = tf.get_variable("b", [1], dtype=tf.float64)
    y = W * features['x'] + b
    # 构建损失模型
    loss = tf.reduce_sum(tf.square(y - labels))
    # 训练模型子图
    global_step = tf.train.get_global_step()
    optimizer = tf.train.GradientDescentOptimizer(0.01)
    train = tf.group(optimizer.minimize(loss),
                     tf.assign_add(global_step, 1))
    # 通过EstimatorSpec指定我们的训练子图积极损失模型
    return tf.estimator.EstimatorSpec(
        mode=mode,
        predictions=y,
        loss=loss,
        train_op=train)

# 创建自定义的训练模型
estimator = tf.estimator.Estimator(model_fn=model_fn)

# 后面的训练逻辑与使用LinearRegressor一样
x_train = np.array([1., 2., 3., 6., 8.])
y_train = np.array([4.8, 8.5, 10.4, 21.0, 25.3])

x_eavl = np.array([2., 5., 7., 9.])
y_eavl = np.array([7.6, 17.2, 23.6, 28.8])

train_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=2, num_epochs=None, shuffle=True)

train_input_fn_2 = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=2, num_epochs=1000, shuffle=False)

eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_eavl}, y_eavl, batch_size=2, num_epochs=1000, shuffle=False)

estimator.train(input_fn=train_input_fn, steps=1000)

train_metrics = estimator.evaluate(input_fn=train_input_fn_2)
print("train metrics: %r" % train_metrics)

eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print("eval metrics: %s" % eval_metrics)

上面代码的输出为

train metrics: {'loss': 0.8984344, 'global_step': 1000}
eval metrics: {'loss': 0.48776609, 'global_step': 1000}