实验三 线性回归

目录

一、线性回归

1.数据集构建

2.模型构建

3.损失函数

4.模型优化

5.模型训练

6.模型评估

7.样本数量 & 正则化系数

7.1调整训练数据的样本数量，由 100 调整到 5000，观察对模型性能的影响。

7.2调整正则化系数，观察对模型性能的影响。

二、多项式回归

1.数据集构建

2.模型构建

3.模型训练

4.模型评估

三、Runner类介绍

四、基于线性回归的波士顿房价预测

1.数据处理

1.1数据集介绍

1.2数据清洗

1.3数据集划分

1.4特征工程

2.模型构建

3.完善Runner类

4.模型训练

5.模型测试

6.模型预测

五、问题及感悟

1.问题

2.感悟

七、参考文章

---

一、线性回归

       回归（regression）是能为一个或多个自变量与因变量之间关系建模的一类方法。 在自然科学和社会科学领域，回归经常用来表示输入和输出之间的关系。

       线性回归（linear regression）可以追溯到19世纪初， 它在回归的各种标准工具中最简单而且最流行。 线性回归基于几个简单的假设： 首先，假设自变量x和因变量y之间的关系是线性的， 即y可以表示为x中元素的加权和，这里通常允许包含观测值的一些噪声； 其次，我们假设任何噪声都比较正常，如噪声遵循正态分布。

1.数据集构建

构造一个小的回归数据集：

随机采样输入特征x，并代入上面函数得到输出标签y。为了模拟真实环境中样本通常包含噪声的问题，我们采样过程中加入高斯噪声和异常点。

生成样本数据的函数create_toy_data实现如下：

# 真实函数的参数缺省值为 w=1.2，b=0.5
def linear_func(x,w=1.2,b=0.5):
    y = w*x + b
    return y
import torch

def create_toy_data(func, interval, sample_num, noise = 0.0, add_outlier = False, outlier_ratio = 0.001):
    """
    根据给定的函数，生成样本
    输入：
       - func：函数
       - interval： x的取值范围
       - sample_num： 样本数目
       - noise： 噪声均方差
       - add_outlier：是否生成异常值
       - outlier_ratio：异常值占比
    输出：
       - X: 特征数据，shape=[n_samples,1]
       - y: 标签数据，shape=[n_samples,1]
    """

    # 均匀采样
    # 在生成sample_num个随机数
    X = torch.rand(shape = [sample_num]) * (interval[1]-interval[0]) + interval[0]
    y = func(X)

    # 生成高斯分布的标签噪声
    # 生成0均值，noise标准差的数据
    epsilon = torch.normal(0,noise,torch.to_tensor(y.shape[0]))
    y = y + epsilon
    if add_outlier:     # 生成额外的异常点
        outlier_num = int(len(y)*outlier_ratio)
        if outlier_num != 0:
            # 生成服从均匀分布的、范围在[0, len(y))的随机Tensor
            outlier_idx = torch.randint(len(y),shape = [outlier_num])
            y[outlier_idx] = y[outlier_idx] * 5
    return X, y

生成 150 个带噪音的样本，其中 100 个训练样本，50 个测试样本。

func = linear_func
interval = (-10, 10)
train_num = 100 # 训练样本数目
test_num = 50 # 测试样本数目
noise = 2
X_train, y_train = create_toy_data(func=func, interval=interval, sample_num=train_num, noise = noise, add_outlier = False)
X_test, y_test = create_toy_data(func=func, interval=interval, sample_num=test_num, noise = noise, add_outlier = False)
X_train_large, y_train_large = create_toy_data(func=func, interval=interval, sample_num=5000, noise = noise, add_outlier = False)
X_underlying = torch.linspace(interval[0],interval[1],train_num)
y_underlying = linear_func(X_underlying)

打印出训练数据的可视化分布。

plt.scatter(X_train, y_train, marker='.', facecolor="none", edgecolor='#e4000f', s=50, label="train data")
plt.scatter(X_test, y_test, facecolor="none", edgecolor='#f19ec2', s=50, label="test data")
plt.plot(X_underlying, y_underlying, c='#000000', label=r"underlying distribution")
plt.legend(fontsize='x-large')  # 给图像加图例
plt.savefig('ml-vis.pdf') # 保存图像到PDF文件中
plt.show()

 

2.模型构建

为了提高预测样本的效率，我们通常会将NN样本归为一组进行成批地预测，这样可以更好地利用GPU设备的并行计算能力。

torch.manual_seed(10)  # 设置随机种子
# 线性算子
class Linear(Op):
    def __init__(self, input_size):
        """
        输入：
           - input_size:模型要处理的数据特征向量长度
        """
        self.input_size = input_size
        # 模型参数
        self.params = {}
        self.params['w'] = torch.randn(size=[self.input_size, 1], dtype=torch.float32)
        self.params['b'] = torch.zeros(size=[1], dtype=torch.float32)

    def __call__(self, X):
        return self.forward(X)

    # 前向函数
    def forward(self, X):
        """
        输入：
           - X: tensor, shape=[N,D]
           注意这里的X矩阵是由N个x向量的转置拼接成的，与原教材行向量表示方式不一致
        输出：
           - y_pred： tensor, shape=[N]
        """
        N, D = X.shape
        if self.input_size == 0:
            return torch.full(([N, 1]), self.params['b'])

        assert D == self.input_size  # 输入数据维度合法性验证
        # 使用torch.matmul计算两个tensor的乘积
        y_pred = torch.matmul(X, self.params['w']) + self.params['b']
        return y_pred

# 这里的X矩阵是由N个x向量的转置拼接成的
input_size = 3
N = 2
X = torch.randn(N, input_size)  # 生成2个维度为3的数据
model = Linear(input_size)
y_pred = model(X)
print("y_pred:", y_pred)  # 输出结果的个数也是2个

 y_pred: tensor([[1.8529],
                          [0.6011]])

3.损失函数

回归任务是对连续值的预测，希望模型能根据数据的特征输出一个连续值作为预测值。因此回归任务中常用的评估指标是均方误差。

均方误差（mean-square error, MSE）是反映估计量与被估计量之间差异程度的一种度量。

def mean_squared_error(y_true, y_pred):
    """
    输入：
       - y_true: tensor，样本真实标签
       - y_pred: tensor, 样本预测标签
    输出：
       - error: float，误差值
    """
    assert y_true.shape[0] == y_pred.shape[0]
    # torch.square计算输入的平方值
    # torch.mean沿 axis 计算 x 的平均值，默认axis是None，则对输入的全部元素计算平均值。
    error = torch.mean(torch.square(y_true - y_pred))
    return error

# 构造一个简单的样例进行测试:[N,1], N=2
y_true = torch.tensor([[-0.2], [4.9]], dtype=torch.float32)
y_pred = torch.tensor([[1.3], [2.5]], dtype=torch.float32)
error = mean_squared_error(y_true=y_true, y_pred=y_pred).item()
print("error:", error)

执行结果：

思考：代码实现中没有除2

在机器学习损失函数中公式中含有平方，后面会涉及到对其进行求导，会多出一个二，所以公式中除以二以简化求导后的结果，所以是否除以二对最终结果并没有影响。

 

4.模型优化

经验风险 （ Empirical Risk ），即在训练集上的平均损失。

采用经验风险最小化，线性回归可以通过最小二乘法求出参数和的解析解。

对上个均方误差的定义式对参数求偏导得到

 其中1为N维的全1向量。为了简单起见省略了均方误差的系数

def optimizer_lsm(model, X, y, reg_lambda=0):
    """
      输入：
         - model: 模型
         - X: tensor, 特征数据，shape=[N,D]
         - y: tensor,标签数据，shape=[N]
         - reg_lambda: float, 正则化系数，默认为0
      输出：
         - model: 优化好的模型
      """
 
    N, D = X.shape
 
    # 对输入特征数据所有特征向量求平均
    x_bar_tran = torch.mean(X, dim=0).T
 
    # 求标签的均值,shape=[1]
    y_bar = torch.mean(y)
 
    # torch.subtract通过广播的方式实现矩阵减向量
    x_sub = torch.subtract(X, x_bar_tran)
 
    # 使用torch.all判断输入tensor是否全0
    if torch.all(x_sub == 0):
        model.params['b'] = y_bar
        model.params['w'] = torch.zeros(size=[D])
        return model
 
    # torch.inverse求方阵的逆
    tmp = torch.inverse(torch.matmul(x_sub.T, x_sub) +
                         reg_lambda * torch.eye(n=(D)))
 
    w = torch.matmul(torch.matmul(tmp, x_sub.T), (y - y_bar))
 
    b = y_bar - torch.matmul(x_bar_tran, w)
 
    model.params['b'] = b
    model.params['w'] = torch.squeeze(w, dim=-1)
 
    return model

思考：

1.为什么省略了 不影响结果

它只是一个系数并不影响最终结果

2.什么是最小二乘法 （ Least Square Method ， LSM 

最小二乘法（ Least Square Method ， LSM ）：（又称最小平方法）是一种数学优化技术。它通过最小化误差的平方和寻找数据的最佳函数匹配。 利用最小二乘法可 以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。最小二乘法还可用于曲线拟合。

5.模型训练

在准备了数据、模型、损失函数和参数学习的实现之后，开始模型的训练。在回归任务中，模型的评价指标和损失函数一致，都为均方误差。

通过上文实现的线性回归类来拟合训练数据，并输出模型在训练集上的损失。

input_size = 1
model = Linear(input_size)
model = optimizer_lsm(model,X_train.reshape([-1,1]),y_train.reshape([-1,1]))
print("w_pred:",model.params['w'].item(), "b_pred: ", model.params['b'].item())
 
y_train_pred = model(X_train.reshape([-1,1])).squeeze()
train_error = mean_squared_error(y_true=y_train, y_pred=y_train_pred).item()
print("train error: ",train_error)
 
model_large = Linear(input_size)
model_large = optimizer_lsm(model_large,X_train_large.reshape([-1,1]),y_train_large.reshape([-1,1]))
print("w_pred large:",model_large.params['w'].item(), "b_pred large: ", model_large.params['b'].item())
 
y_train_pred_large = model_large(X_train_large.reshape([-1,1])).squeeze()
train_error_large = mean_squared_error(y_true=y_train_large, y_pred=y_train_pred_large).item()
print("train error large: ",train_error_large)

执行结果：

w_pred: 1.2271720170974731 b_pred:  0.37986236810684204
train error:  105.02835083007812
w_pred large: 1.1993684768676758 b_pred large:  0.5421561002731323
train error large:  99.23371124267578

可见和与真实值存在差距

6.模型评估

用训练好的模型预测一下测试集的标签，并计算在测试集上的损失。

y_test_pred = model(X_test.reshape([-1,1])).squeeze()
test_error = mean_squared_error(y_true=y_test, y_pred=y_test_pred).item()
print("test error: ",test_error)
 
y_test_pred_large = model_large(X_test.reshape([-1,1])).squeeze()
test_error_large = mean_squared_error(y_true=y_test, y_pred=y_test_pred_large).item()
print("test error large: ",test_error_large)

执行结果：

test error:  90.84951782226562
test error large:  89.00284576416016

7.样本数量 & 正则化系数

7.1调整训练数据的样本数量，由 100 调整到 5000，观察对模型性能的影响。

train_num = 5000 # 训练样本数目

 w_pred: 1.197505235671997 b_pred:  0.4983460307121277
train error:  99.06513977050781
w_pred large: 1.2121068239212036 b_pred large:  0.5092155933380127
train error large:  99.74403381347656
test error:  83.19195556640625
test error large:  84.21379089355469

训练的样本数目越大，和就越接近真实值，MSE越低。

7.2调整正则化系数，观察对模型性能的影响。

正则化就是要将结构风险最小化的过程

def optimizer_lsm(model, X, y, reg_lambda=5):

w_pred: 1.1974689960479736 b_pred:  0.49835026264190674
train error:  99.06227111816406
w_pred large: 1.2120693922042847 b_pred large:  0.509216845035553
train error large:  99.74108123779297
test error:  83.189453125
test error large:  84.211181640625

调整过后，结果没有什么影响，所以模型没有过拟合。

二、多项式回归

多项式回归是回归任务的一种形式，其中自变量和因变量之间的关系是次多项式的一种线性回归形式，即：

 其中为多项式的阶数=为多项式的系数，为多项式基函数,将原始特征映射为维的向量。当=0时，。

上述公式展示的时特征维度为1的多项式表达，当特征维度大于1时，存在不同特征交互的情况，这是线性回归无法实现。下面公式时当特征维度为2，多项式阶数为2时的多项式回归：

 当自变量和因变量之间并不是线性关系时，我们可以定义非线性基函数对特征进行变换，从而可以使得线性回归算法实现非线性的曲线拟合。

1.数据集构建

构建训练和测试数据，其中：

训练数样本 15 个，测试样本 10 个，高斯噪声标准差为 0.1，自变量范围为 (0,1)。

import math
import torch
from matplotlib import pyplot as plt
# sin函数: sin(2 * pi * x)
def sin(x):
    y = torch.sin(2 * math.pi * x)
    return y
 
def create_toy_data(func, interval, sample_num, noise = 0.0, add_outlier = False, outlier_ratio = 0.001):
    """
    根据给定的函数，生成样本
    输入：
       - func：函数
       - interval： x的取值范围
       - sample_num： 样本数目
       - noise： 噪声均方差
       - add_outlier：是否生成异常值
       - outlier_ratio：异常值占比
    输出：
       - X: 特征数据，shape=[n_samples,1]
       - y: 标签数据，shape=[n_samples,1]
    """
 
    # 均匀采样
    # 使用torch.rand在生成sample_num个随机数
    X = torch.rand(sample_num,1) * (interval[1]-interval[0]) + interval[0]
    y = func(X)
 
    # 生成高斯分布的标签噪声
    # 使用torch.normal生成0均值，noise标准差的数据
    epsilon = torch.normal(0.0,noise,(y.shape[0],1))
    y = y + epsilon
    if add_outlier:     # 生成额外的异常点
        outlier_num = int(len(y)*outlier_ratio)
        if outlier_num != 0:
            # 使用torch.randint生成服从均匀分布的、范围在[0, len(y))的随机Tensor
            outlier_idx = torch.randint(0,len(y),size = [outlier_num])
            y[outlier_idx] = y[outlier_idx] * 5
    return X, y
 
# 生成数据
func = sin
interval = (0,1)
train_num = 15
test_num = 10
noise = 0.5 #0.1
X_train, y_train = create_toy_data(func=func, interval=interval, sample_num=train_num, noise = noise)
X_test, y_test = create_toy_data(func=func, interval=interval, sample_num=test_num, noise = noise)
 
X_underlying = torch.linspace(interval[0],interval[1],100)
y_underlying = sin(X_underlying)
 
# 绘制图像
plt.rcParams['figure.figsize'] = (8.0, 6.0)
plt.scatter(X_train, y_train, facecolor="none", edgecolor='#e4007f', s=50, label="train data")
#plt.scatter(X_test, y_test, facecolor="none", edgecolor="r", s=50, label="test data")
plt.plot(X_underlying, y_underlying, c='#000000', label=r"$\sin(2\pi x)$")
plt.legend(fontsize='x-large')
plt.savefig('ml-vis2.pdf')
plt.show()

执行结果：

 

2.模型构建

通过多项式的定义可以看出，多项式回归和线性回归一样，同样学习参数，只不过需要对输入特征根据多项式阶数进行变换。可以套用求解线性回归参数的方法来求解多项式回归参数。

# 多项式转换
def polynomial_basis_function(x, degree=2):
    """
    输入：
       - x: tensor, 输入的数据，shape=[N,1]
       - degree: int, 多项式的阶数
       example Input: [[2], [3], [4]], degree=2
       example Output: [[2^1, 2^2], [3^1, 3^2], [4^1, 4^2]]
       注意：本案例中,在degree>=1时不生成全为1的一列数据；degree为0时生成形状与输入相同，全1的Tensor
    输出：
       - x_result： tensor
    """
 
    if degree == 0:
        return torch.ones(size=x.shape, dtype=torch.float32)
 
    x_tmp = x
    x_result = x_tmp
 
    for i in range(2, degree + 1):
        x_tmp = torch.multiply(x_tmp, x)  # 逐元素相乘
        x_result = torch.cat((x_result, x_tmp), dim=-1)
 
    return x_result
 
 
# 简单测试
data = [[2], [3], [4]]
X = torch.tensor(data=data, dtype=torch.float32)
degree = 3
transformed_X = polynomial_basis_function(X, degree=degree)
print("转换前：", X)
print("阶数为", degree, "转换后：", transformed_X)

执行结果：

 

3.模型训练

对于多项式回归，我们可以同样使用前面线性回归中定义的LinearRegression算子、训练函数train、均方误差函数mean_squared_error。拟合训练数据的目标是最小化损失函数，同线性回归一样，也可以通过矩阵运算直接求出的值。

plt.rcParams['figure.figsize'] = (12.0, 8.0)
 
for i, degree in enumerate([0, 1, 3, 8]):  # []中为多项式的阶数
    model = Linear(degree)
    X_train_transformed = polynomial_basis_function(X_train.reshape([-1, 1]), degree)
    X_underlying_transformed = polynomial_basis_function(X_underlying.reshape([-1, 1]), degree)
 
    model = optimizer_lsm(model, X_train_transformed, y_train.reshape([-1, 1]))  # 拟合得到参数
 
    y_underlying_pred = model(X_underlying_transformed).squeeze()
 
    print(model.params)
 
    # 绘制图像
    plt.subplot(2, 2, i + 1)
    plt.scatter(X_train, y_train, facecolor="none", edgecolor='#e4007f', s=50, label="train data")
    plt.plot(X_underlying, y_underlying, c='#000000', label=r"$\sin(2\pi x)$")
    plt.plot(X_underlying, y_underlying_pred, c='#f19ec2', label="predicted function")
    plt.ylim(-2, 1.5)
    plt.annotate("M={}".format(degree), xy=(0.95, -1.4))
 
# plt.legend(bbox_to_anchor=(1.05, 0.64), loc=2, borderaxespad=0.)
plt.legend(loc='lower left', fontsize='x-large')
plt.savefig('ml-vis3.pdf')
plt.show()

执行结果：

{'w': tensor([0.]), 'b': tensor(-0.1441)}
{'w': tensor([-0.9384]), 'b': tensor([0.3150])}
{'w': tensor([ 12.5144, -34.8418,  23.1784]), 'b': tensor([-0.3165])}
{'w': tensor([ 3.7056e+00,  2.0793e+02, -1.7501e+03,  5.1039e+03, -5.8384e+03,
         4.3806e+02,  3.8396e+03, -2.0028e+03]), 'b': tensor([-1.5398])}

 当 M=0 或 M=1 时，拟合曲线较简单，模型欠拟合；
 当 M=8 时，拟合曲线较复杂，模型过拟合；
 当 M=3 时，模型拟合最为合理。

4.模型评估

通过均方误差来衡量训练误差、测试误差以及在没有噪音的加入下sin函数值与多项式回归值之间的误差，更加真实地反映拟合结果。多项式分布阶数从0到8进行遍历。

对于模型过拟合的情况，可以引入正则化方法，通过向误差函数中添加一个惩罚项来避免系数倾向于较大的取值。

# 训练误差和测试误差
training_errors = []
test_errors = []
distribution_errors = []
 
# 遍历多项式阶数
for i in range(9):
    model = Linear(i)
 
    X_train_transformed = polynomial_basis_function(X_train.reshape([-1, 1]), i)
    X_test_transformed = polynomial_basis_function(X_test.reshape([-1, 1]), i)
    X_underlying_transformed = polynomial_basis_function(X_underlying.reshape([-1, 1]), i)
 
    optimizer_lsm(model, X_train_transformed, y_train.reshape([-1, 1]))
 
    y_train_pred = model(X_train_transformed).squeeze()
    y_test_pred = model(X_test_transformed).squeeze()
    y_underlying_pred = model(X_underlying_transformed).squeeze()
 
    train_mse = mean_squared_error(y_true=y_train, y_pred=y_train_pred).item()
    training_errors.append(train_mse)
 
    test_mse = mean_squared_error(y_true=y_test, y_pred=y_test_pred).item()
    test_errors.append(test_mse)
 
    # distribution_mse = mean_squared_error(y_true=y_underlying, y_pred=y_underlying_pred).item()
    # distribution_errors.append(distribution_mse)
 
print("train errors: \n", training_errors)
print("test errors: \n", test_errors)
# print ("distribution errors: \n", distribution_errors)
 
# 绘制图片
plt.rcParams['figure.figsize'] = (8.0, 6.0)
plt.plot(training_errors, '-.', mfc="none", mec='#e4007f', ms=10, c='#e4007f', label="Training")
plt.plot(test_errors, '--', mfc="none", mec='#f19ec2', ms=10, c='#f19ec2', label="Test")
# plt.plot(distribution_errors, '-', mfc="none", mec="#3D3D3F", ms=10, c="#3D3D3F", label="Distribution")
plt.legend(fontsize='x-large')
plt.xlabel("degree")
plt.ylabel("MSE")
plt.savefig('ml-mse-error.pdf')
plt.show()

train errors: 
 [0.6441656947135925, 0.8283544778823853, 0.9778935313224792, 1.087277889251709, 1.0901203155517578, 1.1170716285705566, 1.0674344301223755, 2.0862534046173096, 3.8148746490478516]
test errors: 
 [0.6824741959571838, 1.1624795198440552, 2.524428606033325, 1.041847586631775, 1.0281134843826294, 1.130333662033081, 1.6590303182601929, 4.540024280548096, 8.942521095275879]

 当阶数较低的时候，模型的表示能力有限，训练误差和测试误差都很高，代表模型欠拟合；
 当阶数较高的时候，模型表示能力强，但将训练数据中的噪声也作为特征进行学习，一般情况下   训练误差继续降低而测试误差显著升高，代表模型过拟合。

 对于模型过拟合的情况，可以引入正则化方法，通过向误差函数中添加一个惩罚项来避免系数倾   向于较大的取值。下面加入l2正则化项，查看拟合结果。

degree = 8 # 多项式阶数
reg_lambda = 0.0001 # 正则化系数
 
X_train_transformed = polynomial_basis_function(X_train.reshape([-1,1]), degree)
X_test_transformed = polynomial_basis_function(X_test.reshape([-1,1]), degree)
X_underlying_transformed = polynomial_basis_function(X_underlying.reshape([-1,1]), degree)
 
model = Linear(degree)
 
optimizer_lsm(model,X_train_transformed,y_train.reshape([-1,1]))
 
y_test_pred=model(X_test_transformed).squeeze()
y_underlying_pred=model(X_underlying_transformed).squeeze()
 
model_reg = Linear(degree)
 
optimizer_lsm(model_reg,X_train_transformed,y_train.reshape([-1,1]),reg_lambda=reg_lambda)
 
y_test_pred_reg=model_reg(X_test_transformed).squeeze()
y_underlying_pred_reg=model_reg(X_underlying_transformed).squeeze()
 
mse = mean_squared_error(y_true = y_test, y_pred = y_test_pred).item()
print("mse:",mse)
mes_reg = mean_squared_error(y_true = y_test, y_pred = y_test_pred_reg).item()
print("mse_with_l2_reg:",mes_reg)
 
# 绘制图像
plt.scatter(X_train, y_train, facecolor="none", edgecolor="#e4007f", s=50, label="train data")
plt.plot(X_underlying, y_underlying, c='#000000', label=r"$\sin(2\pi x)$")
plt.plot(X_underlying, y_underlying_pred, c='#e4007f', linestyle="--", label="$deg. = 8$")
plt.plot(X_underlying, y_underlying_pred_reg, c='#f19ec2', linestyle="-.", label="$deg. = 8, \ell_2 reg$")
plt.ylim(-1.5, 1.5)
plt.annotate("lambda={}".format(reg_lambda), xy=(0.82, -1.4))
plt.legend(fontsize='large')
plt.savefig('ml-vis4.pdf')
plt.show()

mse: 3.1271579265594482
mse_with_l2_reg: 0.3700985610485077

 

三、Runner类介绍

机器学习方法流程包括数据集构建、模型构建、损失函数定义、优化器、模型训练、模型评价、模型预测等环节。

为了更方便地将上述环节规范化，我们将机器学习模型的基本要素封装成一个Runner类。

除上述提到的要素外，再加上模型保存、模型加载等功能。

Runner类的成员函数定义如下：

• __init__函数：实例化Runner类，需要传入模型、损失函数、优化器和评价指标等；
• train函数：模型训练，指定模型训练需要的训练集和验证集；
• evaluate函数：通过对训练好的模型进行评价，在验证集或测试集上查看模型训练效果；
• predict函数：选取一条数据对训练好的模型进行预测；
• save_model函数：模型在训练过程和训练结束后需要进行保存；
• load_model函数：调用加载之前保存的模型。

Runner类的流程如下图可以分为四个阶段：

1. 初始化阶段：传入模型、损失函数、优化器和评价指标。
2. 模型训练阶段：基于训练集调用train()函数训练模型，基于验证集通过evaluate()函数验证模型。通过save_model()函数保存模型。
3. 模型评价阶段：基于测试集通过evaluate()函数得到指标性能。
4. 模型预测阶段：给定样本，通过predict()函数得到该样本标签。

class Runner(object):
    def __init__(self, model, optimizer, loss_fn, metric):
        # 优化器和损失函数为None,不再关注
        # 模型
        self.model = model
        # 评估指标
        self.metric = metric
        # 优化器
        self.optimizer = optimizer

    def train(self, dataset, reg_lambda, model_dir):
        X, y = dataset
        self.optimizer(self.model, X, y, reg_lambda)

        # 保存模型
        self.save_model(model_dir)

    def evaluate(self, dataset, **kwargs):
        X, y = dataset

        y_pred = self.model(X)
        result = self.metric(y_pred, y)

        return result

    def predict(self, X, **kwargs):
        return self.model(X)

    def save_model(self, model_dir):
        if not os.path.exists(model_dir):
            os.makedirs(model_dir)

        params_saved_path = os.path.join(model_dir, 'params.pdtensor')
        torch.save(model.params, params_saved_path)

    def load_model(self, model_dir):
        params_saved_path = os.path.join(model_dir, 'params.pdtensor')
        self.model.params = torch.load(params_saved_path)

optimizer = optimizer_lsm
# 实例化Runner
runner = Runner(model, optimizer=optimizer, loss_fn=None, metric=mse_loss)

四、基于线性回归的波士顿房价预测

使用线性回归来对马萨诸塞州波士顿郊区的房屋进行预测。

实验流程主要包含如下5个步骤：

• 数据处理：包括数据清洗（缺失值和异常值处理）、数据集划分，以便数据可以被模型正常读取，并具有良好的泛化性;
• 模型构建：定义线性回归模型类；
• 训练配置:训练相关的一些配置，如：优化算法、评价指标等；
• 组装训练框架Runner:Runner用于管理模型训练和测试过程；
• 模型训练和测试:利用Runner进行模型训练和测试。

1.数据处理

1.1数据集介绍

# 提前下载boston数据集
data = pd.read_csv('boston.csv')

1.2数据清洗

print(data.head())
# 查看各字段缺失值统计情况
print(data.isna().sum())

      CRIM    ZN  INDUS  CHAS    NOX  ...  TAX  PTRATIO       B  LSTAT  MEDV
0  0.00632  18.0   2.31     0  0.538  ...  296     15.3  396.90   4.98  24.0
1  0.02731   0.0   7.07     0  0.469  ...  242     17.8  396.90   9.14  21.6
2  0.02729   0.0   7.07     0  0.469  ...  242     17.8  392.83   4.03  34.7
3  0.03237   0.0   2.18     0  0.458  ...  222     18.7  394.63   2.94  33.4
4  0.06905   0.0   2.18     0  0.458  ...  222     18.7  396.90   5.33  36.2

[5 rows x 14 columns]
CRIM       0
ZN         0
INDUS      0
CHAS       0
NOX        0
RM         0
AGE        0
DIS        0
RAD        0
TAX        0
PTRATIO    0
B          0
LSTAT      0
MEDV       0
dtype: int64

可得数据集并不存在缺失值

1.3数据集划分

torch.manual_seed(10)  # 随机种子

# 划分训练集和测试集
def train_test_split(X, y, train_percent=0.8):
    n = len(X)
    shuffled_indices = torch.randperm(n)  # 返回一个数值在0到n-1、随机排列的1-D Tensor
    train_set_size = int(n * train_percent)
    train_indices = shuffled_indices[:train_set_size]
    test_indices = shuffled_indices[train_set_size:]

    X = X.values
    y = y.values
    X_train = X[train_indices]
    y_train = y[train_indices]
    X_test = X[test_indices]
    y_test = y[test_indices]

    return X_train, X_test, y_train, y_test

X = data.drop(['MEDV'], axis=1)
y = data['MEDV']

X_train, X_test, y_train, y_test = train_test_split(X, y)  # X_train每一行是个样本，shape[N,D]

1.4特征工程

X_train = torch.tensor(X_train)
X_train = X_train.to(torch.float32)
X_test = torch.tensor(X_test)
X_train = X_train.to(torch.float32)
y_train = torch.tensor(y_train)
X_train = X_train.to(torch.float32)
y_test = torch.tensor(y_test)
X_train = X_train.to(torch.float32)
X_min = torch.min(X_train)
X_max = torch.max(X_train)
X_train = (X_train-X_min)/(X_max-X_min)
X_test = (X_test-X_min)/(X_max-X_min)
# 训练集构造
train_dataset = (X_train, y_train)
# 测试集构造
test_dataset = (X_test, y_test)

2.模型构建

模型实例化

input_size = 12
model=Linear(input_size)

3.完善Runner类

class Runner(object):
    def __init__(self, model, optimizer, loss_fn, metric):
        # 优化器和损失函数为None,不再关注
        # 模型
        self.model = model
        # 评估指标
        self.metric = metric
        # 优化器
        self.optimizer = optimizer

    def train(self, dataset, reg_lambda, model_dir):
        X, y = dataset
        self.optimizer(self.model, X, y, reg_lambda)

        # 保存模型
        self.save_model(model_dir)

    def evaluate(self, dataset, **kwargs):
        X, y = dataset

        y_pred = self.model(X)
        result = self.metric(y_pred, y)

        return result

    def predict(self, X, **kwargs):
        return self.model(X)

    def save_model(self, model_dir):
        if not os.path.exists(model_dir):
            os.makedirs(model_dir)

        params_saved_path = os.path.join(model_dir, 'params.pdtensor')
        torch.save(model.params, params_saved_path)

    def load_model(self, model_dir):
        params_saved_path = os.path.join(model_dir, 'params.pdtensor')
        self.model.params = torch.load(params_saved_path)

optimizer = optimizer_lsm
# 实例化Runner
runner = Runner(model, optimizer=optimizer, loss_fn=None, metric=mse_loss)

4.模型训练

在组装完成Runner之后，我们将开始进行模型训练、评估和测试。首先，我们先实例化Runner，然后开始进行装配训练环境，接下来就可以开始训练。

# 模型保存到文件夹中
saved_dir = 'pythonPoject'
# 启动训练
runner.train(train_dataset, reg_lambda=0, model_dir=saved_dir)

打印权重

columns_list = data.columns.to_list()
weights = runner.model.params['w'].tolist()
b = runner.model.params['b'].item()
for i in range(len(weights)):
    print(columns_list[i], "weight:", weights[i])

print("b:", b)

CRIM weight: -6.7268967628479
ZN weight: 1.28081214427948
INDUS weight: -0.4696650803089142
CHAS weight: 2.235346794128418
NOX weight: -7.0105814933776855
RM weight: 9.76220417022705
AGE weight: -0.8556219339370728
DIS weight: -9.265738487243652
RAD weight: 7.973038673400879
TAX weight: -4.365403175354004
PTRATIO weight: -7.105883598327637
LSTAT weight: -13.165120124816895
b: 32.12007522583008

从结果看出：

CRIM、PTRATIO等的权重为负数，表示人均犯罪率与房价呈负相关，学生与教师比例越大，房价越低；
RAD和CHAS等为正，表示到径向公路的可达性指数越高，房价越高；临近Charles River房价高。

5.模型测试

# 加载模型权重
runner.load_model(saved_dir)

mse = runner.evaluate(test_dataset)
print('MSE:', mse.item())

执行结果：

MSE: 12.345974922180176

6.模型预测

runner.load_model(saved_dir)
pred = runner.predict(X_test[:1])
print("真实房价：",y_test[:1].item())
print("预测的房价：",pred.item())

执行结果：

真实房价： 33.099998474121094
预测的房价： 33.04654312133789

五、问题及感悟

1.问题

问题1：使用类实现机器学习模型的基本要素有什么优点？

与函数不同的是在继续引用时很方便，如果想要加入其他的内容也更容易去扩展，可以应用到各个方面，维护也易操作。

问题2：算子op、优化器opitimizer放在单独的文件中，主程序在使用时调用该文件。这样做有什么优点？

在调用的时候更加方便，不需要再复制粘贴，更不宜错。

问题3：线性回归通常使用平方损失函数，能否使用交叉熵损失函数？为什么？

首先平方损失函数对每一个输出结果都很看重，而交叉熵损失函数更看重正确分类的结果。其次平方数损失函数假设最终结果都服从高斯分布，而高斯分布实际上是一个连续变量，并不是一个离散变量。

2.感悟

经过本次线性回归和波士顿房价的预测实验，对上学期机械学习所学习的知识进行了熟悉，同时又对一些新的事物有了一些了解，但本身对于深度学习这方面的欠缺还是太多，希望在后面的学习中找到更大的收获。

七、参考文章

NNDL 实验2（上） - HBU_DAVID - 博客园

NNDL 实验2（下） - HBU_DAVID - 博客园