TensorFlow 2.0 实现线性回归
线性回归是机器学习中最简单的问题，同时线性回归也与人工神经网络有千丝万缕的关系。文章中，我们将以线性回归为例，使用 TensorFlow 2.0 提供的 API 来进行实现。与此同时，我们会使用 1.x API 与之对比。
线性回归是入门机器学习必学的算法，其也是最基础的算法之一。接下来，我们以线性回归为例，使用 TensorFlow 2.0 提供的 API 和 Eager Execution 机制对其进行实现。
低阶 API 实现
低阶 API 实现，实际上就是利用 Eager Execution 机制来完成。实验首先初始化一组随机数据样本，并添加噪声，然后将其可视化出来。
import matplotlib.pyplot as plt
import tensorflow as tf
%matplotlib inline
TRUE_W = 3.0
TRUE_b = 2.0
NUM_SAMPLES = 100
# 初始化随机数据
X = tf.random.normal(shape=[NUM_SAMPLES, 1]).numpy()
noise = tf.random.normal(shape=[NUM_SAMPLES, 1]).numpy()
y = X * TRUE_W + TRUE_b + noise # 添加噪声
plt.scatter(X, y)
接下来，我们定义一元线性回归模型。
$$f(w, b, x) = w*x + b$$
这里我们构建自定义模型类，并使用 TensorFlow 提供的 tf.Variable 随机初始化参数 $w$ 和截距项 $b$。
class Model(object):
def __init__(self):
self.W = tf.Variable(tf.random.uniform([1])) # 随机初始化参数
self.b = tf.Variable(tf.random.uniform([1]))
def __call__(self, x):
return self.W * x + self.b # w*x + b
对于随机初始化的 $w$ 和 $b$，我们可以将其拟合直线绘制到样本散点图中。
model = Model() # 实例化模型
plt.scatter(X, y)
plt.plot(X, model(X), c='r')
可以明显看出，直线并没有很好地拟合样本。当然，由于是随机初始化，也有极小概率一开始拟合效果非常好，那么重新执行一次上面的单元格另外随机初始化一组数据即可。
然后，我们定义线性回归使用到的损失函数。这里使用线性回归问题中常用的平方损失函数。对于线性回归问题中与数学相关的知识点，本次实验不再推动和讲解。
$${\rm Loss}(w, b, x, y) = \sum_{i=1}^N (f(w, b, x_i) - y_i)^2$$
根据公式实现损失计算函数。
def loss_fn(model, x, y):
y_ = model(x)
return tf.reduce_mean(tf.square(y_ - y))
接下来，就可以开始迭代过程了，这也是最关键的一步。使用迭代方法求解线性回归的问题中，我们首先需要计算参数的梯度，然后使用梯度下降法来更新参数。
公式中，$lr$ 指代学习率。
TensorFlow 2.0 中的 Eager Execution 提供了 tf.GradientTape 用于追踪梯度。所以，下面我们就实现梯度下降法的迭代更新过程。
EPOCHS = 10
LEARNING_RATE = 0.1
for epoch in range(EPOCHS): # 迭代次数
with tf.GradientTape() as tape: # 追踪梯度
loss = loss_fn(model, X, y) # 计算损失
dW, db = tape.gradient(loss, [model.W, model.b]) # 计算梯度
model.W.assign_sub(LEARNING_RATE * dW) # 更新梯度
model.b.assign_sub(LEARNING_RATE * db)
# 输出计算过程
print('Epoch [{}/{}], loss [{:.3f}], W/b [{:.3f}/{:.3f}]'.format(epoch, EPOCHS, loss,
float(model.W.numpy()),
float(model.b.numpy())))
Epoch [0/10], loss [9.949], W/b [1.395/0.608]
Epoch [1/10], loss [6.420], W/b [1.791/0.899]
Epoch [2/10], loss [4.270], W/b [2.097/1.132]
Epoch [3/10], loss [2.957], W/b [2.332/1.318]
Epoch [4/10], loss [2.156], W/b [2.514/1.466]
Epoch [5/10], loss [1.665], W/b [2.653/1.585]
Epoch [6/10], loss [1.365], W/b [2.761/1.680]
Epoch [7/10], loss [1.180], W/b [2.845/1.756]
Epoch [8/10], loss [1.067], W/b [2.909/1.817]
Epoch [9/10], loss [0.998], W/b [2.958/1.865]
上面的代码中，我们初始化 tf.GradientTape() 以追踪梯度，然后使用 tape.gradient 方法就可以计算梯度了。值得注意的是，tape.gradient() 第二个参数支持以列表形式传入多个参数同时计算梯度。紧接着，使用 .assign_sub 即可完成公式中的减法操作用以更新梯度。
最终，我们绘制参数学习完成之后，模型的拟合结果。
plt.scatter(X, y)
plt.plot(X, model(X), c='r')
如无意外，你将得到一个比随机参数好很多的拟合直线。
提示：由于是随机初始化参数，如果迭代后拟合效果仍然不好，一般是迭代次数太少的原因。你可以重复执行上面的迭代单元格多次，增加参数更新迭代次数，即可改善拟合效果。此提示对后面的内容同样有效。
高阶 API 实现
TensorFlow 2.0 中提供了大量的高阶 API 帮助我们快速构建所需模型，接下来，我们使用一些新的 API 来完成线性回归模型的构建。这里还是沿用上面提供的示例数据。
tf.keras 模块下提供的 tf.keras.layers.Dense 全连接层（线性层）实际上就是一个线性计算过程。所以，模型的定义部分我们就可以直接实例化一个全连接层即可。
model = tf.keras.layers.Dense(units=1) # 实例化线性层
其中，units 为输出空间维度。此时，参数已经被初始化了，所以我们可以绘制出拟合直线。
plt.scatter(X, y)
plt.plot(X, model(X), c='r')
你可以使用 model.variables 打印出模型初始化的随机参数。
model.variables
[<tf.Variable 'dense/kernel:0' shape=(1, 1) dtype=float32, numpy=array([[1.4135073]], dtype=float32)>,
<tf.Variable 'dense/bias:0' shape=(1,) dtype=float32, numpy=array([0.], dtype=float32)>]接下来就可以直接构建模型迭代过程了。
这里同样使用 tf.GradientTape() 来追踪梯度，我们简化损失计算和更新的过程。首先，损失可以使用现有 API tf.keras.losses.mean_squared_error 计算，最终使用 tf.reduce_sum 求得全部样本的平均损失。
EPOCHS = 10
LEARNING_RATE = 0.002
for epoch in range(EPOCHS): # 迭代次数
with tf.GradientTape() as tape: # 追踪梯度
y_ = model(X)
loss = tf.reduce_sum(tf.keras.losses.mean_squared_error(y, y_)) # 计算损失
grads = tape.gradient(loss, model.variables) # 计算梯度
optimizer = tf.keras.optimizers.SGD(LEARNING_RATE) # 随机梯度下降
optimizer.apply_gradients(zip(grads, model.variables)) # 更新梯度
print('Epoch [{}/{}], loss [{:.3f}]'.format(epoch, EPOCHS, loss))
Epoch [0/10], loss [848.794]
Epoch [1/10], loss [339.506]
Epoch [2/10], loss [172.200]
Epoch [3/10], loss [116.692]
Epoch [4/10], loss [98.099]
Epoch [5/10], loss [91.816]
Epoch [6/10], loss [89.674]
Epoch [7/10], loss [88.938]
Epoch [8/10], loss [88.684]
Epoch [9/10], loss [88.596]
其次，使用 model.variables 即可读取可参数的列表，无需像上面那样手动传入。这里不再按公式手动更新梯度，而是使用现有的随机梯度下降函数 tf.keras.optimizers.SGD，然后使用 apply_gradients 即可更新梯度。
最终，同样将迭代完成的参数绘制拟合直线到原图中。
plt.scatter(X, y)
plt.plot(X, model(X), c='r')
如果拟合效果不好，请参考上文提示。
Keras 方式实现
上面的高阶 API 实现过程实际上还不够精简，我们可以完全使用 TensorFlow Keras API 来实现线性回归。
我们这里使用 Keras 提供的 Sequential 序贯模型结构。和上面的例子相似，向其中添加一个线性层。不同的地方在于，Keras 序贯模型第一层为线性层时，规定需指定输入维度，这里为 input_dim=1。
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(units=1, input_dim=1))
model.summary() # 查看模型结构
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
dense_1 (Dense) (None, 1) 2
=================================================================
Total params: 2
Trainable params: 2
Non-trainable params: 0
_________________________________________________________________
接下来，直接使用 .compile 编译模型，指定损失函数为 MSE 平方损失，优化器选择 SGD 随机梯度下降。然后，就可以使用 .fit 传入数据开始迭代了。
model.compile(optimizer='sgd', loss='mse')
model.fit(X, y, steps_per_epoch=1000)
1000/1000 [==============================] - 1s 1ms/step - loss: 5.9901
steps_per_epoch 只的是在默认小批量为 32 的条件下，传入相应次数的小批量样本。最终绘制出迭代完成的拟合图像。
plt.scatter(X, y)
plt.plot(X, model(X), c='r')
如果拟合效果不好，请参考上文提示。
如上所示，完全使用 Keras 高阶 API 实际上只需要 4 行核心代码即可完成。相比于最开始的低阶 API 简化了很多。
TensorFlow 1.x 实现
为了与 TensorFlow 2.0 线性回归实现过程进行对比。最终，我们给出 TensorFlow 1.x 线性回归实现代码。这里，我们需要实验 TensorFlow 2.0 中 tensorflow.compat.v1 模块下提供的兼容性代码。
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior() # 关闭 Eager Execution 特性
接下来，就可以使用 TensorFlow 1.x 中提供的图与会话方式来实现线性回归过程了。
X_train = tf.placeholder(tf.float32) # 定义占位符张量
y_train = tf.placeholder(tf.float32)
W = tf.Variable(tf.random.normal([1])) # 初始化参数
b = tf.Variable(tf.random.normal([1]))
LEARNING_RATE = 0.001 # 学习率
y_train_ = W*X_train + b # 线性函数
loss = tf.reduce_mean(tf.square(y_train_ - y_train)) # 平方损失函数
optimizer = tf.train.GradientDescentOptimizer(
LEARNING_RATE).minimize(loss) # 梯度下降优化损失函数
EPOCHS = 1000 # 迭代次数
with tf.Session() as sess: # 启动会话
tf.global_variables_initializer().run() # 初始化全局变量
for epoch in range(EPOCHS): # 迭代优化
sess.run(optimizer, feed_dict={X_train:X, y_train:y})
final_weight = sess.run(W) # 最终参数
final_bias = sess.run(b)
print(final_weight, final_bias)
[2.7856345] [1.6973654]最后，我们依据迭代更新的参数，将拟合直线绘制到原图中。
preds = final_weight * X + final_bias # 计算预测值
plt.scatter(X, y)
plt.plot(X, preds, c='r')
关联阅读