深度学习实验三：波士顿房价预测任务

一、实验目的

1. 使用Python和NumPy实现波士顿房价预测任务
2. 使用飞桨实现波士顿房价预测任务

二、实验环境

Python 3.7、PaddlePaddle 2.3.2

三、实验内容

1.使用Python和NumPy实现波士顿房价预测任务

相关资料网上有很多，故此处未附代码，仅展示流程及测试结果

（1）数据处理

数据处理包含五个部分：数据导入、数据形状变换、数据集划分、数据归一化处理和封装load data函数。数据预处理后，才能被模型调用。
①数据导入：通过代码读入数据，了解下波士顿房价的数据集结构，数据存放在本地目录下housing.data文件中。
②数据形状变换：由于读入的原始数据是1维的，所有数据都连在一起。因此需要将数据的形状进行变换，形成一个2维的矩阵。
③数据集划分：将数据集划分成训练集和测试集，其中训练集用于确定模型的参数，测试集用于评判模型的效果。
④数据归一化处理：对每个特征进行归一化处理。这样做有两个好处：一是模型训练更高效；二是特征前的权重大小可以代表该变量对预测结果的贡献度（因为每个特征值本身的范围相同）。

（2）模型设计

①随机产生w的初始值。为了保持程序每次运行结果的一致性，设置固定的随机数种子；
②在每轮迭代开始之前，将训练数据的顺序随机打乱；
③按每次取batch_size条数据的方式取出；
④将训练数据进行拆分，每个mini_batch包含batch_size条的数据。

（3）训练

使用numpy的矩阵操作方便的完成了gradient的计算，但w的维度与gradient_w不同。导致该问题的原因是使用np.mean函数的时候消除了第0维。为了加减乘除等计算方便，gradient_w和w必须保持一致的形状。所以，我们将gradient_w的维度设置为与w的相同。
将上面计算w和b的梯度的过程，写成Network类的gradient函数，调用定义的gradient函数计算梯度。

（4）保存模型

（5）结果（部分截图）

修改测试：将batch_size值改为20，重新将训练数据进行拆分，每个mini_batch包含20条的数据。

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

（为便于理解新环境，附代码方便对照）

（1）加载飞桨、NumPy和相关类

import paddle #飞桨的主库，paddle 根目录下保留了常用API的别名
from paddle.nn import Linear #Linear：神经网络的全连接层函数
import paddle.nn.functional as F #paddle.nn：组网相关的API
import numpy as np 
import os
import random

（2）数据处理

def load_data():
    # 从文件导入数据
    datafile = './housing.data'
    data = np.fromfile(datafile, sep=' ', dtype=np.float32)

    # 每条数据包括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.8
    offset = int(data.shape[0] * ratio)
    training_data = data[:offset]

    # 计算train数据集的最大值，最小值，平均值
    maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0),                                  training_data.sum(axis=0) / training_data.shape[0]
    
    # 记录数据的归一化参数，在预测时对数据做归一化
    global max_values
    global min_values
    global avg_values
    max_values = maximums
    min_values = minimums
    avg_values = avgs
    # 对数据进行归一化处理
    for i in range(feature_num):
        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])

    # 训练集和测试集的划分比例
    training_data = data[:offset]
    test_data = data[offset:]
    return training_data, test_data

（3）模型设计

模型定义的实质是定义线性回归的网络结构，飞桨建议通过创建Python类的方式完成模型网络的定义，该类需要继承paddle.nn.Layer父类，并且在类中定义init函数和forward函数。forward函数是框架指定实现前向计算逻辑的函数，程序在调用模型实例时会自动执行，forward函数中使用的网络层需要在init函数中声明。
①定义init函数：在类的初始化函数中声明每一层网络的实现函数。在房价预测任务中，只需要定义一层全连接层，模型结构和《使用Python和NumPy构建神经网络模型》章节保持一致；
②定义forward函数：构建神经网络结构，实现前向计算过程，并返回预测结果，在本任务中返回的是房价预测结果。

class Regressor(paddle.nn.Layer):
    # self代表类的实例自身
    def __init__(self):
        # 初始化父类中的一些参数
        super(Regressor, self).__init__()
        
        # 定义一层全连接层，输入维度是13，输出维度是1
        self.fc = Linear(in_features=13, out_features=1)
    
    # 网络的前向计算
    def forward(self, inputs):
        x = self.fc(inputs)
        return x

模型实例有两种状态：训练状态.train()和预测状态.eval()。训练时要执行正向计算和反向传播梯度两个过程，而预测时只需要执行正向计算，为模型指定运行状态，有两点原因：
①部分高级的算子在两个状态执行的逻辑不同，如：Dropout和BatchNorm；
②从性能和存储空间的考虑，预测状态时更节省内存(无需记录反向梯度)，性能更好。

（4）训练配置

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

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

（5）训练过程

此处使用二层循环嵌套方式。

• 内层循环：负责整个数据集的一次遍历，采用分批次方式（batch）。假设数据集样本数量为1000，一个批次有10个样本，则遍历一次数据集的批次数量是1000/10=100，即内层循环需要执行100次。
• 外层循环：定义遍历数据集的次数，通过参数EPOCH_NUM设置。

每次内层循环都需要执行如下步骤：
①数据准备：将一个批次的数据先转换成nparray格式，再转换成Tensor格式；
②前向计算：将一个批次的样本数据灌入网络中，计算输出结果；
③计算损失函数：以前向计算结果和真实房价作为输入，通过损失函数square_error_cost API计算出损失函数值（Loss）。
④反向传播：执行梯度反向传播backward函数，即从后到前逐层计算每一层的梯度，并根据设置的优化算法更新参数(opt.step函数)。

注意：
batch值影响训练效果：过大会增加内存消耗和训练时间，过小计算的梯度方向偏差较大。
本实验中模型训练数据集较小，batch值为10。

EPOCH_NUM = 10   # 设置外层循环次数
    BATCH_SIZE = 10  # 设置batch大小

    # 定义外层循环
    for epoch_id in range(EPOCH_NUM):
        # 在每轮迭代开始之前，将训练数据的顺序随机的打乱
        np.random.shuffle(training_data)
        # 将训练数据进行拆分，每个batch包含10条数据
        mini_batches = [training_data[k:k+BATCH_SIZE] for k in range(0, len(training_data), BATCH_SIZE)]
        # 定义内层循环
        for iter_id, mini_batch in enumerate(mini_batches):
            x = np.array(mini_batch[:, :-1]) # 获得当前批次训练数据
            y = np.array(mini_batch[:, -1:]) # 获得当前批次训练标签（真实房价）
            # 将numpy数据转为飞桨动态图tensor形式
            house_features = paddle.to_tensor(x)
            prices = paddle.to_tensor(y)
            
            # 前向计算
            predicts = model(house_features)
            
            # 计算损失
            loss = 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()
            # 最小化loss,更新参数
            opt.step()
            # 清除梯度
            opt.clear_grad()

改变batch的值，将batch修改为20再做测试：

BATCH_SIZE = 20

（6）保存并测试模型

使用paddle.save API将模型当前的参数数据 model.state_dict() 保存到文件中，用于模型预测或校验的程序调用。

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

测试模型：
①测试一

def load_one_example():
    training_data, test_data = load_data()
    # 从上边已加载的测试集中，随机选择一条作为测试数据
    idx = np.random.randint(0, test_data.shape[0])
    idx = -10
    one_data, label = test_data[idx, :-1], test_data[idx, -1]
    # 修改该条数据shape为[1,13]
    one_data =  one_data.reshape([1,-1])

    return one_data, label
    def validation():
    model = Regressor()
    # 参数为保存模型参数的文件地址
    model_dict = paddle.load('LR_model.pdparams')
    model.load_dict(model_dict)
    model.eval()

    # 参数为数据集的文件地址
    one_data, label = load_one_example()
    # 将数据转为动态图的variable格式 
    one_data = paddle.to_tensor(one_data)
    predict = model(one_data)
    # 对结果做反归一化处理
    predict = predict * (max_values[-1] - min_values[-1]) + avg_values[-1]
    # 对label数据做反归一化处理
    label = label * (max_values[-1] - min_values[-1]) + avg_values[-1]

    print("Inference result is {}, the corresponding label is {}".format(predict.numpy(), label))

②测试二
修改学习率为0.02，外层循环次数为15。

    # 学习率设置为0.02
    opt = paddle.optimizer.SGD(learning_rate=0.02, parameters=model.parameters())

    EPOCH_NUM = 15   # 设置外层循环次数
    BATCH_SIZE = 10  # 设置batch大小

四、实验小结

在使用Python和NumPy实现波士顿房价预测任务中，为方便演示，可以让使用的梯度下降法的过程仅包含w5和w9两个参数。房价预测的完整模型，必须要对所有参数w和b进行求解。这需要将Network中的update和train函数进行修改。由于不在限定参与计算的参数（所有参数均参与计算），修改之后的代码反而更加简洁。