【深度学习】使用飞桨paddle实现波士顿房价预测任务

使用飞桨实现波士顿房价预测任务

由于开始学习深度学习，因此每次开始都熟悉一下深度学习模型的基本步骤：

在之前的学习中，我们学习了使用Python和NumPy实现波士顿房价预测任务的方法，本章我们将尝试使用飞桨paddle重写房价预测任务，体会二者的异同。在数据处理之前，需要先加载飞桨框架的相关类库。

1. 数据处理

数据处理的代码不依赖飞桨框架实现，与使用Python构建房价预测任务的代码相同，因此独立为单独的代码。

# 导入需要用到的package
import numpy as np
from sklearn.preprocessing import MinMaxScalerdef load_data():# 从文件导入数据datafile = './work/housing.data'data = np.fromfile(datafile, sep=' ')# 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE','DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]feature_num = len(feature_names)# 将原始数据进行Reshape，变成[N, 14]这样的形状data = data.reshape([data.shape[0] // feature_num, feature_num])# 将原数据集拆分成训练集和测试集# 这里使用80%的数据做训练，20%的数据做测试# 测试集和训练集必须是没有交集的ratio = 0.8offset = int(data.shape[0] * ratio)train_data, test_data = data[:offset], data[offset:]# # 计算训练集的最大值，最小值# maximums, minimums = training_data.max(axis=0), \#                         training_data.min(axis=0)## # 对数据进行归一化处理# for i in range(feature_num):#     data[:, i] = (data[:, i] - minimums[i]) / (maximums[i] - minimums[i])# 使用训练集计算最大值和最小值scaler = MinMaxScaler()# 只在训练集上拟合scaler.fit(train_data)data = scaler.transform(data)# 训练集和测试集的划分比例train_data = data[:offset]test_data = data[offset:]return train_data, test_data

在后续的使用通过引用即可

from load_data import load_data
train_data, test_data = load_data()

2.模型设计

模型设计的实质是定义线性回归的网络结构，建议通过创建Python类的方式构建模型，该类需要继承paddle.nn.Layer父类，并且在类中定义init函数和forward函数。forward是飞桨前向计算逻辑的函数，在调用模型实例时会自动执行，其使用的网络层需要在init中声明。

init函数：在类的初始化函数中声明每一层网络的实现函数。在房价预测任务中，只需要定义一层全连接层。
forward函数：在构建神经网络时实现前向计算过程，并返回预测结果，在本任务中返回的是房价预测结果。

#加载飞桨、NumPy和相关类库
import paddle
from paddle.nn import Linear
import paddle.nn.functional as F
import numpy as np
import os
import random
from load_data import load_dataclass Regressor(paddle.nn.Layer):# self代表类的实例自身def __init__(self):# 初始化父类中的一些参数super(Regressor, self).__init__()# 定义一层全连接层，输入维度是13，输出维度是1self.fc = Linear(in_features=13, out_features=1)# 网络的前向计算def forward(self, inputs):x = self.fc(inputs)return x

3.训练配置

• 声明定义好的回归模型实例为Regressor，并将模型的状态设置为train。
• 使用load_data函数加载训练数据和测试数据。
• 设置优化算法和学习率，优化算法采用随机梯度下降，学习率设置为0.01。

训练配置的代码实现如下：

# 声明定义好的线性回归模型
model = Regressor()
# 开启模型训练模式，模型的状态设置为train
model.train()
# 使用load_data加载训练集数据和测试集数据
train_data, test_data = load_data()
# 定义优化算法，采用随机梯度下降SGD
# 学习率设置为0.01
opt = paddle.optimizer.SGD(learning_rate=0.005, parameters=model.parameters())

4.训练过程

由于model.train()已经被Regressor用来设置模型的状态，因此新增了一个train_model来作为训练过程方法。

    def train_model(self, train_data, num_epochs, batch_size=10, eta=0.01):# 定义模型训练轮次epoch（外层循环）for epoch_id in range(num_epochs):# 在每轮迭代开始之前，对训练集数据进行样本乱序np.random.shuffle(train_data)# 对训练集数据进行拆分，batch_size设置为10mini_batches = [train_data[k:k + batch_size] for k in range(0, len(train_data), batch_size)]# 定义模型训练（内层循环）for iter_id, mini_batch in enumerate(mini_batches):x = np.array(mini_batch[:, :-1])  # 将当前批的房价影响因素的数据转换为np.array格式y = np.array(mini_batch[:, -1:])  # 将当前批的标签数据（真实房价）转换为np.array格式# 将np.array格式的数据转为张量tensor格式house_features = paddle.to_tensor(x, dtype='float32')prices = paddle.to_tensor(y, dtype='float32')# 前向计算predicts = model(house_features)# 计算损失，损失函数采用平方误差square_error_costloss = F.square_error_cost(predicts, label=prices)avg_loss = paddle.mean(loss)if iter_id % 20 == 0:print("epoch: {}, iter: {}, loss is: {}".format(epoch_id, iter_id, avg_loss.numpy()))# 反向传播，计算每层参数的梯度值avg_loss.backward()# 更新参数，根据设置好的学习率迭代一步opt.step()# 清空梯度变量，进行下一轮计算opt.clear_grad()

5.numpy和python构建深度学习模型和飞桨的比较

5.1 前向计算forward

	# paddledef forward(self, inputs):x = self.fc(inputs)return x# numpy+pythondef forward(self, x):z = np.dot(x, self.w) + self.breturn z

在Python310\Lib\site-packages\paddle\nn\functional\common.py路径下，可以看到paddle底层封装的方法和numpy+python是一致的

5.2.计算损失函数 loss

	import paddle.nn.functional as F# 计算损失，损失函数采用平方误差square_error_costloss = F.square_error_cost(predicts, label=prices)avg_loss = paddle.mean(loss)def loss(self, z, y):error = z - ynum_samples = error.shape[0]cost = error * errorcost = np.sum(cost) / num_samplesreturn cost

在Python310\Lib\site-packages\paddle\nn\functional\loss.py路径下，可以看到paddle封装了均方误差square_error_cost的方法，该方法中并没有/N，因此还计算了avg_loss = paddle.mean(loss)

5.3.梯度计算gradient

# paddle# 定义优化算法，采用随机梯度下降SGD# 学习率设置为0.01opt = paddle.optimizer.SGD(learning_rate=0.005, parameters=model.parameters())# 反向传播，计算每层参数的梯度值avg_loss.backward()# 更新参数，根据设置好的学习率迭代一步opt.step()# 清空梯度变量，进行下一轮计算opt.clear_grad()# numpy + pythondef gradient(self, x, y):z = self.forward(x)N = x.shape[0]gradient_w = 1. / N * np.sum((z - y) * x, axis=0)gradient_w = gradient_w[:, np.newaxis]gradient_b = 1. / N * np.sum(z - y)return gradient_w, gradient_bdef update(self, gradient_w, gradient_b, eta=0.01):self.w = self.w - eta * gradient_wself.b = self.b - eta * gradient_b

6.模型保存和推理

6.1.模型保存

# 保存模型参数，文件名为LR_model.pdparams
paddle.save(model.state_dict(), 'LR_model.pdparams')
print("模型保存成功, 模型参数保存在LR_model.pdparams中")

6.2.模型推理

需要注意的是在模型推理后，需要做反向的归一化处理，这里会用到max_values, min_values，这里的最大最小值是用训练数据在归一化之前获取的，为了避免重新load data，因此在返回数据时，将这两个数据一并返回。

#加载飞桨、NumPy和相关类库
import paddle
import numpy as np
from load_data import load_data
from train_paddle import Regressor
train_data, test_data, max_values, min_values = load_data()def load_one_example():# 从测试集中随机选择一条作为推理数据# 从测试集中随机选择一条作为推理数据idx = np.random.randint(0, test_data.shape[0])idx = -10one_data, label = test_data[idx, :-1], test_data[idx, -1]# 将数据格式修改为[1,13]one_data = one_data.reshape([1, -1])return one_data, labelif __name__ == '__main__':# 将模型参数保存到指定路径中model_dict = paddle.load('LR_model.pdparams')model = Regressor()model.load_dict(model_dict)# 将模型状态修改为.evalmodel.eval()one_data, label = load_one_example()# 将数据格式转换为张量one_data = paddle.to_tensor(one_data,dtype="float32")predict = model(one_data)# 对推理结果进行后处理print(predict.numpy(), max_values[-1], min_values[-1])predict = predict * (max_values[-1] - min_values[-1]) + min_values[-1]# 对label数据进行后处理label = label * (max_values[-1] - min_values[-1]) + min_values[-1]print("Inference result is {}, the corresponding label is {}".format(predict.numpy(), label))

这里的label是原始数据，predict是预测数据。

6.3 用plt绘制test_data曲线图

	N = y.shape[0]  # 数据点的数量# 由于 x 在这个例子中是为了生成 y 而存在的，并且我们实际上不会用它来绘图（因为我们只有 y 和 predict），# 我们可以简单地使用 range(N) 来作为 x 轴的索引，但这在绘制曲线图时通常不是必需的，因为 Matplotlib 会自动处理。# 然而，为了演示目的，我们将创建一个与 y 和 predict 相同长度的 x_index 数组。x_index = np.arange(N)# 绘制原始数据 yplt.plot(x_index, y.flatten(), color='blue', label='Original Data (y)', alpha=0.6, linewidth=1)# 绘制预测数据 predictplt.plot(x_index, predict.numpy().flatten(), color='red', label='Predicted Data (predict)', linewidth=2)# 添加标题和标签（注意：这里我们没有使用实际的 x 值作为横轴标签，因为只有 y 和 predict）plt.title('Comparison of Original Data and Predicted Data')plt.xlabel('Index')  # 或者你可以使用 'Sample Number'、'Data Point' 等标签plt.ylabel('Value')plt.legend()# 显示图表plt.grid(True)plt.show()

可以看到，整体预测得并不是很好。

7 使用飞桨高层API实现波士顿房价预测任务

如上代码使用飞桨的基础API完成了波士顿房价预测任务，是否有更加快捷地实现方法呢？答案是肯定的。下面使用飞桨高层API实现波士顿房价预测任务，代码实现如下：

#加载飞桨、NumPy和相关类库
import paddle
from paddle.nn import Linear
paddle.set_default_dtype("float32")
import paddle.nn.functional as F
import numpy as np
import matplotlib.pyplot as pltclass Regressor(paddle.nn.Layer):# self代表类的实例自身def __init__(self):# 初始化父类中的一些参数super(Regressor, self).__init__()# 定义一层全连接层，输入维度是13，输出维度是1self.fc = Linear(in_features=13, out_features=1)# 网络的前向计算def forward(self, inputs):x = self.fc(inputs)return xif __name__ == '__main__':# 使用飞桨高层API加载波士顿房价预测数据集，包括训练集和测试集# paddle.text：用于加载文本领域数据集。train_dataset = paddle.text.datasets.UCIHousing(mode='train')eval_dataset = paddle.text.datasets.UCIHousing(mode='test')# 模型训练model = paddle.Model(Regressor())# model.prepare：用于定义模型训练参数，如优化器paddle.optimizer.SGD、损失函数paddle.nn.MSELoss等。model.prepare(paddle.optimizer.SGD(learning_rate=0.005, parameters=model.parameters()),paddle.nn.MSELoss())# model.fit：用于模型训练，并指定相关参数，如训练轮次epochs，批大小batch_size，可视化的模型方式verbose。model.fit(train_dataset, eval_dataset, epochs=10, batch_size=10, verbose=1)# model.evaluate：用于在测试集上评估模型的损失函数值和评价指标。由于本实践没有定义模型评价指标，因此只输出损失函数值。本实践使用均方误差损失（Mean Squared Error，MSE）。result = model.evaluate(eval_dataset, batch_size=10)print("result:", result)test_data = eval_dataset.datax = test_data[:, :-1]  # 所有行，列从第 0 列到倒数第 2 列# 提取最后一列作为 Yy = test_data[:, -1].reshape([-1, 1])# model.predict：用于模型推理。x = paddle.to_tensor(x, dtype="float32")result_pred = model.predict(x, batch_size=1) # result_pred是一个list，元素数目对应模型的输出数目result_pred = result_pred[0] # tuple,其中第一个值是arraypredict = np.vstack(result_pred)# y = y * (max_values[-1] - min_values[-1]) + min_values[-1]print("Inference result is {}, the corresponding label is {}".format(predict, y))N = y.shape[0]  # 数据点的数量# 由于 x 在这个例子中是为了生成 y 而存在的，并且我们实际上不会用它来绘图（因为我们只有 y 和 predict），# 我们可以简单地使用 range(N) 来作为 x 轴的索引，但这在绘制曲线图时通常不是必需的，因为 Matplotlib 会自动处理。# 然而，为了演示目的，我们将创建一个与 y 和 predict 相同长度的 x_index 数组。x_index = np.arange(N)# 绘制原始数据 yplt.plot(x_index, y.flatten(), color='blue', label='Original Data (y)', alpha=0.6, linewidth=1)# 绘制预测数据 predictplt.plot(x_index, predict.flatten(), color='red', label='Predicted Data (predict)', linewidth=2)# 添加标题和标签（注意：这里我们没有使用实际的 x 值作为横轴标签，因为只有 y 和 predict）plt.title('Comparison of Original Data and Predicted Data')plt.xlabel('Index')  # 或者你可以使用 'Sample Number'、'Data Point' 等标签plt.ylabel('Value')plt.legend()# 显示图表plt.grid(True)plt.show()

学习总结

1、numpy+python和paddle训练过程是相同的，paddle对前向计算、计算损失和反向传播梯度进行了封装，不再需要逐一编写代码，这就是使用飞桨框架的威力！但是通过numpy+python比较容易理解深度学习的过程。
2、模型推理时，需要将测试数据转换为张量x = paddle.to_tensor(x, dtype=“float32”)
3、将一行数据的x，y分离出来的代码

x = test_data[:, :-1]
y = test_data[:, -1].reshape([-1, 1])
如果只需要分离部分记录：
x = test_data[0:3][:, :-1]
y = test_data[0:3][:, -1].reshape([-1, 1])
# 这是Numpy库的广播功能

4、用plt绘制曲线图时，需要用到y和predict，其中y的shap是（N,1)，需要用y.flatten()降维到(N,）。predict还是张量，需要用predict.numpy()先转换为numpy格式，再通过flatten()降维。
5、使用飞桨高层API加载波士顿房价预测数据集是下载下来的，也可以指定数据集路径。
6、目前还没有定义模型评价指标，后续再学习