线性回归

让我们从经典的线性回归（Linear Regression [1]）模型开始这份教程。在这一章里，你将使用真实的数据集建立起一个房价预测模型，并且了解到机器学习中的若干重要概念。

本教程源代码目录在book/fit_a_line， 初次使用请您参考Book文档使用说明。

背景介绍

给定一个大小为

线性回归 - 图1的数据集线性回归 - 图2，其中线性回归 - 图3是第线性回归 - 图4个样本线性回归 - 图5个属性上的取值，线性回归 - 图6是该样本待预测的目标。线性回归模型假设目标线性回归 - 图7可以被属性间的线性组合描述，即

线性回归 - 图8

例如，在我们将要建模的房价预测问题里，

线性回归 - 图9是描述房子线性回归 - 图10的各种属性（比如房间的个数、周围学校和医院的个数、交通状况等），而线性回归 - 图11是房屋的价格。

初看起来，这个假设实在过于简单了，变量间的真实关系很难是线性的。但由于线性回归模型有形式简单和易于建模分析的优点，它在实际问题中得到了大量的应用。很多经典的统计学习、机器学习书籍[2,3,4]也选择对线性模型独立成章重点讲解。

效果展示

我们使用从UCI Housing Data Set获得的波士顿房价数据集进行模型的训练和预测。下面的散点图展示了使用模型对部分房屋价格进行的预测。其中，每个点的横坐标表示同一类房屋真实价格的中位数，纵坐标表示线性回归模型根据特征预测的结果，当二者值完全相等的时候就会落在虚线上。所以模型预测得越准确，则点离虚线越近。

线性回归 - 图12 图1. 预测值 V.S. 真实值

模型概览

模型定义

在波士顿房价数据集中，和房屋相关的值共有14个：前13个用来描述房屋相关的各种信息，即模型中的

线性回归 - 图13；最后一个值为我们要预测的该类房屋价格的中位数，即模型中的线性回归 - 图14。因此，我们的模型就可以表示成：

线性回归 - 图15

线性回归 - 图16 表示模型的预测结果，用来和真实值线性回归 - 图17区分。模型要学习的参数即：线性回归 - 图18。

建立模型后，我们需要给模型一个优化目标，使得学到的参数能够让预测值

线性回归 - 图19尽可能地接近真实值线性回归 - 图20。这里我们引入损失函数（Loss Function，或Cost Function）这个概念。 输入任意一个数据样本的目标值线性回归 - 图21和模型给出的预测值线性回归 - 图22，损失函数输出一个非负的实值。这个实值通常用来反映模型误差的大小。

对于线性回归模型来讲，最常见的损失函数就是均方误差（Mean Squared Error， MSE）了，它的形式是：

线性回归 - 图23

即对于一个大小为

线性回归 - 图24的测试集，线性回归 - 图25是线性回归 - 图26个数据预测结果误差平方的均值。

对损失函数进行优化所采用的方法一般为梯度下降法。梯度下降法是一种一阶最优化算法。如果

线性回归 - 图27在点线性回归 - 图28有定义且可微，则认为线性回归 - 图29在点线性回归 - 图30沿着梯度的负方向线性回归 - 图31下降的是最快的。反复调节线性回归 - 图32，使得线性回归 - 图33接近最小值或者极小值，调节的方式为：

线性回归 - 图34

其中λ代表学习率。这种调节的方法称为梯度下降法。

训练过程

定义好模型结构之后，我们要通过以下几个步骤进行模型训练 1. 初始化参数，其中包括权重

线性回归 - 图35和偏置线性回归 - 图36，对其进行初始化（如0均值，1方差）。 2. 网络正向传播计算网络输出和损失函数。 3. 根据损失函数进行反向误差传播 （backpropagation），将网络误差从输出层依次向前传递, 并更新网络中的参数。 4. 重复2~3步骤，直至网络训练误差达到规定的程度或训练轮次达到设定值。

数据集

数据集介绍

这份数据集共506行，每行包含了波士顿郊区的一类房屋的相关信息及该类房屋价格的中位数。其各维属性的意义如下：

属性名解释类型
CRIM该镇的人均犯罪率连续值
ZN占地面积超过25,000平方呎的住宅用地比例连续值
INDUS非零售商业用地比例连续值
CHAS是否邻近 Charles River离散值，1=邻近；0=不邻近
NOX一氧化氮浓度连续值
RM每栋房屋的平均客房数连续值
AGE1940年之前建成的自用单位比例连续值
DIS到波士顿5个就业中心的加权距离连续值
RAD到径向公路的可达性指数连续值
TAX全值财产税率连续值
PTRATIO学生与教师的比例连续值
B1000(BK - 0.63)^2，其中BK为黑人占比连续值
LSTAT低收入人群占比连续值
MEDV同类房屋价格的中位数连续值

数据预处理

连续值与离散值

观察一下数据，我们的第一个发现是：所有的13维属性中，有12维的连续值和1维的离散值（CHAS）。离散值虽然也常使用类似0、1、2这样的数字表示，但是其含义与连续值是不同的，因为这里的差值没有实际意义。例如，我们用0、1、2来分别表示红色、绿色和蓝色的话，我们并不能因此说“蓝色和红色”比“绿色和红色”的距离更远。所以通常对一个有

线性回归 - 图37个可能取值的离散属性，我们会将它们转为线性回归 - 图38个取值为0或1的二值属性或者将每个可能取值映射为一个多维向量。不过就这里而言，因为CHAS本身就是一个二值属性，就省去了这个麻烦。

属性的归一化

另外一个稍加观察即可发现的事实是，各维属性的取值范围差别很大（如图2所示）。例如，属性B的取值范围是[0.32, 396.90]，而属性NOX的取值范围是[0.3850, 0.8170]。这里就要用到一个常见的操作-归一化（normalization）了。归一化的目标是把各位属性的取值范围放缩到差不多的区间，例如[-0.5,0.5]。这里我们使用一种很常见的操作方法：减掉均值，然后除以原取值范围。

做归一化（或 Feature scaling）至少有以下3个理由：

  • 过大或过小的数值范围会导致计算时的浮点上溢或下溢。

  • 不同的数值范围会导致不同属性对模型的重要性不同（至少在训练的初始阶段如此），而这个隐含的假设常常是不合理的。这会对优化的过程造成困难，使训练时间大大的加长。

  • 很多的机器学习技巧/模型（例如L1，L2正则项，向量空间模型-Vector Space Model）都基于这样的假设：所有的属性取值都差不多是以0为均值且取值范围相近的。

线性回归 - 图39 图2. 各维属性的取值范围

整理训练集与测试集

我们将数据集分割为两份：一份用于调整模型的参数，即进行模型的训练，模型在这份数据集上的误差被称为训练误差；另外一份被用来测试，模型在这份数据集上的误差被称为测试误差。我们训练模型的目的是为了通过从训练数据中找到规律来预测未知的新数据，所以测试误差是更能反映模型表现的指标。分割数据的比例要考虑到两个因素：更多的训练数据会降低参数估计的方差，从而得到更可信的模型；而更多的测试数据会降低测试误差的方差，从而得到更可信的测试误差。我们这个例子中设置的分割比例为

线性回归 - 图40

在更复杂的模型训练过程中，我们往往还会多使用一种数据集：验证集。因为复杂的模型中常常还有一些超参数（Hyperparameter）需要调节，所以我们会尝试多种超参数的组合来分别训练多个模型，然后对比它们在验证集上的表现选择相对最好的一组超参数，最后才使用这组参数下训练的模型在测试集上评估测试误差。由于本章训练的模型比较简单，我们暂且忽略掉这个过程。

训练

fit_a_line/trainer.py演示了训练的整体过程。

配置数据提供器(Datafeeder)

首先我们引入必要的库：

  1. import paddle
  2. import paddle.fluid as fluid
  3. import numpy
  4. import math
  5. import sys
  6. from __future__ import print_function

我们通过uci_housing模块引入了数据集合UCI Housing Data Set

其中，在uci_housing模块中封装了：

  • 数据下载的过程。下载数据保存在~/.cache/paddle/dataset/uci_housing/housing.data。
  • 数据预处理的过程。接下来我们定义了用于训练的数据提供器。提供器每次读入一个大小为BATCH_SIZE的数据批次。如果用户希望加一些随机性，它可以同时定义一个批次大小和一个缓存大小。这样的话，每次数据提供器会从缓存中随机读取批次大小那么多的数据。
  1. BATCH_SIZE = 20
  2.  
  3. train_reader = paddle.batch(
  4.     paddle.reader.shuffle(
  5.         paddle.dataset.uci_housing.train(), buf_size=500),
  6.         batch_size=BATCH_SIZE)
  7.  
  8. test_reader = paddle.batch(
  9.     paddle.reader.shuffle(
  10.         paddle.dataset.uci_housing.test(), buf_size=500),
  11.         batch_size=BATCH_SIZE)

如果想直接从txt文件中读取数据的话，可以参考以下方式。

feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'convert']

feature_num = len(feature_names)

data = numpy.fromfile(filename, sep=' ') # 从文件中读取原始数据

data = data.reshape(data.shape[0] // feature_num, feature_num)

maximums, minimums, avgs = data.max(axis=0), data.min(axis=0), data.sum(axis=0)/data.shape[0]

for i in six.moves.range(feature_num-1): data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i]) # six.moves可以兼容python2和python3

ratio = 0.8 # 训练集和验证集的划分比例

offset = int(data.shape[0]*ratio)

train_data = data[:offset]

test_data = data[offset:]

train_reader = paddle.batch( paddle.reader.shuffle( train_data, buf_size=500), batch_size=BATCH_SIZE)

test_reader = paddle.batch( paddle.reader.shuffle( test_data, buf_size=500), batch_size=BATCH_SIZE)

配置训练程序

训练程序的目的是定义一个训练模型的网络结构。对于线性回归来讲，它就是一个从输入到输出的简单的全连接层。更加复杂的结果，比如卷积神经网络，递归神经网络等会在随后的章节中介绍。训练程序必须返回平均损失作为第一个返回值，因为它会被后面反向传播算法所用到。

  1. x = fluid.layers.data(name='x', shape=[13], dtype='float32') # 定义输入的形状和数据类型
  2. y = fluid.layers.data(name='y', shape=[1], dtype='float32') # 定义输出的形状和数据类型
  3. y_predict = fluid.layers.fc(input=x, size=1, act=None) # 连接输入和输出的全连接层
  4.  
  5. main_program = fluid.default_main_program() # 获取默认/全局主函数
  6. startup_program = fluid.default_startup_program() # 获取默认/全局启动程序
  7.  
  8. cost = fluid.layers.square_error_cost(input=y_predict, label=y) # 利用标签数据和输出的预测数据估计方差
  9. avg_loss = fluid.layers.mean(cost) # 对方差求均值，得到平均损失

详细资料请参考：fluid.default_main_programfluid.default_startup_program

Optimizer Function 配置

在下面的 SGD optimizer，learning_rate 是学习率，与网络的训练收敛速度有关系。

  1. sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001)
  2. sgd_optimizer.minimize(avg_loss)
  3.  
  4. #克隆main_program得到test_program
  5. #有些operator在训练和测试之间的操作是不同的，例如batch_norm，使用参数for_test来区分该程序是用来训练还是用来测试
  6. #该api不会删除任何操作符,请在backward和optimization之前使用
  7. test_program = main_program.clone(for_test=True)

定义运算场所

我们可以定义运算是发生在CPU还是GPU

  1. use_cuda = False
  2. place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() # 指明executor的执行场所
  3.  
  4. ###executor可以接受传入的program，并根据feed map(输入映射表)和fetch list(结果获取表)向program中添加数据输入算子和结果获取算子。使用close()关闭该executor，调用run(...)执行program。
  5. exe = fluid.Executor(place)

详细资料请参考:fluid.executor

创建训练过程

训练需要有一个训练程序和一些必要参数，并构建了一个获取训练过程中测试误差的函数。必要参数有executor,program,reader,feeder,fetch_list，executor表示之前创建的执行器，program表示执行器所执行的program，是之前创建的program，如果该项参数没有给定的话则默认使用defalut_main_program，reader表示读取到的数据，feeder表示前向输入的变量，fetch_list表示用户想得到的变量或者命名的结果。

  1. num_epochs = 100
  2.  
  3. def train_test(executor, program, reader, feeder, fetch_list):
  4.     accumulated = 1 * [0]
  5.     count = 0
  6.     for data_test in reader():
  7.         outs = executor.run(program=program,
  8.                             feed=feeder.feed(data_test),
  9.                             fetch_list=fetch_list)
  10.         accumulated = [x_c[0] + x_c[1][0] for x_c in zip(accumulated, outs)] # 累加测试过程中的损失值
  11.         count += 1 # 累加测试集中的样本数量
  12.     return [x_d / count for x_d in accumulated] # 计算平均损失

训练主循环

给出需要存储的目录名，并初始化一个执行器。

  1. %matplotlib inline
  2. params_dirname = "fit_a_line.inference.model"
  3. feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
  4. exe.run(startup_program)
  5. train_prompt = "train cost"
  6. test_prompt = "test cost"
  7. from paddle.utils.plot import Ploter
  8. plot_prompt = Ploter(train_prompt, test_prompt)
  9. step = 0
  10.  
  11. exe_test = fluid.Executor(place)

paddlepaddle提供了reader机制来读取训练数据。reader会一次提供多列数据，因此我们需要一个python的列表来定义读取顺序。我们构建一个循环来进行训练，直到训练结果足够好或者循环次数足够多。如果训练迭代次数满足参数保存的迭代次数，可以把训练参数保存到params_dirname。设置训练主循环

  1. for pass_id in range(num_epochs):
  2.     for data_train in train_reader():
  3.         avg_loss_value, = exe.run(main_program,
  4.                                   feed=feeder.feed(data_train),
  5.                                   fetch_list=[avg_loss])
  6.         if step % 10 == 0: # 每10个批次记录并输出一下训练损失
  7.             plot_prompt.append(train_prompt, step, avg_loss_value[0])
  8.             plot_prompt.plot()
  9.             print("%s, Step %d, Cost %f" %
  10.                       (train_prompt, step, avg_loss_value[0]))
  11.         if step % 100 == 0:  # 每100批次记录并输出一下测试损失
  12.             test_metics = train_test(executor=exe_test,
  13.                                      program=test_program,
  14.                                      reader=test_reader,
  15.                                      fetch_list=[avg_loss.name],
  16.                                      feeder=feeder)
  17.             plot_prompt.append(test_prompt, step, test_metics[0])
  18.             plot_prompt.plot()
  19.             print("%s, Step %d, Cost %f" %
  20.                       (test_prompt, step, test_metics[0]))
  21.             if test_metics[0] < 10.0: # 如果准确率达到要求，则停止训练
  22.                 break
  23.  
  24.         step += 1
  25.  
  26.         if math.isnan(float(avg_loss_value[0])):
  27.             sys.exit("got NaN loss, training failed.")
  28.  
  29.         #保存训练参数到之前给定的路径中
  30.         if params_dirname is not None:
  31.             fluid.io.save_inference_model(params_dirname, ['x'], [y_predict], exe)

预测

需要构建一个使用训练好的参数来进行预测的程序，训练好的参数位置在params_dirname。

准备预测环境

类似于训练过程，预测器需要一个预测程序来做预测。我们可以稍加修改我们的训练程序来把预测值包含进来。

  1. infer_exe = fluid.Executor(place)
  2. inference_scope = fluid.core.Scope()

预测

保存图片

  1. def save_result(points1, points2):
  2.     import matplotlib
  3.     matplotlib.use('Agg')
  4.     import matplotlib.pyplot as plt
  5.     x1 = [idx for idx in range(len(points1))]
  6.     y1 = points1
  7.     y2 = points2
  8.     l1 = plt.plot(x1, y1, 'r--', label='predictions')
  9.     l2 = plt.plot(x1, y2, 'g--', label='GT')
  10.     plt.plot(x1, y1, 'ro-', x1, y2, 'g+-')
  11.     plt.title('predictions VS GT')
  12.     plt.legend()
  13.     plt.savefig('./image/prediction_gt.png')

通过fluid.io.load_inference_model，预测器会从params_dirname中读取已经训练好的模型，来对从未遇见过的数据进行预测。

  1. with fluid.scope_guard(inference_scope):
  2.     [inference_program, feed_target_names,
  3.      fetch_targets] = fluid.io.load_inference_model(params_dirname, infer_exe) # 载入预训练模型
  4.     batch_size = 10
  5.  
  6.     infer_reader = paddle.batch(
  7.         paddle.dataset.uci_housing.test(), batch_size=batch_size) # 准备测试集
  8.  
  9.     infer_data = next(infer_reader())
  10.     infer_feat = numpy.array(
  11.         [data[0] for data in infer_data]).astype("float32") # 提取测试集中的数据
  12.     infer_label = numpy.array(
  13.         [data[1] for data in infer_data]).astype("float32") # 提取测试集中的标签
  14.  
  15.     assert feed_target_names[0] == 'x'
  16.     results = infer_exe.run(inference_program,
  17.                             feed={feed_target_names[0]: numpy.array(infer_feat)},
  18.                             fetch_list=fetch_targets) # 进行预测
  19.     #打印预测结果和标签并可视化结果
  20.     print("infer results: (House Price)")
  21.     for idx, val in enumerate(results[0]):
  22.         print("%d: %.2f" % (idx, val)) # 打印预测结果
  23.  
  24.     print("\nground truth:")
  25.     for idx, val in enumerate(infer_label):
  26.         print("%d: %.2f" % (idx, val)) # 打印标签值
  27.  
  28.     save_result(results[0], infer_label) # 保存图片

总结

在这章里，我们借助波士顿房价这一数据集，介绍了线性回归模型的基本概念，以及如何使用PaddlePaddle实现训练和测试的过程。很多的模型和技巧都是从简单的线性回归模型演化而来，因此弄清楚线性模型的原理和局限非常重要。

参考文献