devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

线性回归（使用pytorch实现）_pytorch 线性回归

作者：AllinToyou | 2024-02-18 02:19:35

赞

踩

pytorch 线性回归

目录

2.2 线性回归

2.2.1 数据集构建

2.2.2 模型构建

2.2.3 损失函数

2.2.4 模型优化

2.2.5 模型训练

2.2.6 模型评估

2.2.7 样本数量 & 正则化系数

2.3 多项式回归

2.3.1 数据集构建

2.3.2 模型构建

2.3.3 模型训练

2.3.4 模型评估

2.4 Runner类介绍

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

2.5.1.2 数据清洗

2.5.1.3 数据集划分

2.5.1.4 特征工程

2.5.2 模型构建

2.5.3 完善Runner类

2.5.4 模型训练

2.5.5 模型测试

2.5.6 模型预测

总结

2.2 线性回归

2.2.1 数据集构建

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

生成 150 个带噪音的样本，其中 100 个训练样本，50 个测试样本，并打印出训练数据的可视化分布。

  1. import torch
  2. import matplotlib.pyplot as plt
  3.  
  4. # 真实函数的参数缺省值为 w=1.2，b=0.5
  5. def linear_func(x,w=1.2,b=0.5):
  6.     y=w*x + b
  7.     return y
  8. def create_toy_data(func, interval, sample_num, noise = 0.0, add_outlier = False, outlier_ratio = 0.001):
  9.     """
  10.     根据给定的函数，生成样本
  11.     输入：
  12.        - func：函数
  13.        - interval： x的取值范围
  14.        - sample_num： 样本数目
  15.        - noise： 噪声均方差
  16.        - add_outlier：是否生成异常值
  17.        - outlier_ratio：异常值占比
  18.     输出：
  19.        - X: 特征数据，shape=[n_samples,1]
  20.        - y: 标签数据，shape=[n_samples,1]
  21.     """
  22.     # 均匀采样
  23.     # 使用torch.rand在生成sample_num个随机数
  24.     X = torch.rand(size = [sample_num]) * (interval[1]-interval[0]) + interval[0]
  25.     y = func(X)
  26.  
  27.     # 生成高斯分布的标签噪声
  28.     # 使用torch.normal生成0均值，noise标准差的数据
  29.     epsilon = torch.normal(0,noise,y.shape)
  30.     y = y + epsilon
  31.     if add_outlier:     # 生成额外的异常点
  32.         outlier_num = int(len(y)*outlier_ratio)
  33.         if outlier_num != 0:
  34.             # 使用torch.randint生成服从均匀分布的、范围在[0, len(y))的随机Tensor
  35.             outlier_idx = torch.randint(len(y),size = [outlier_num])
  36.             y[outlier_idx] = y[outlier_idx] * 5
  37.     return X, y
  38.  
  39. func = linear_func
  40. interval = (-10,10)
  41. train_num = 100 # 训练样本数目
  42. test_num = 50 # 测试样本数目
  43. noise = 2
  44. X_train, y_train = create_toy_data(func=func, interval=interval, sample_num=train_num, noise = noise, add_outlier = False)
  45. X_test, y_test = create_toy_data(func=func, interval=interval, sample_num=test_num, noise = noise, add_outlier = False)
  46.  
  47. X_train_large, y_train_large = create_toy_data(func=func, interval=interval, sample_num=5000, noise = noise, add_outlier = False)
  48.  
  49. # torch.linspace返回一个Tensor，Tensor的值为在区间start和stop上均匀间隔的num个值，输出Tensor的长度为num
  50. X_underlying = torch.linspace(interval[0],interval[1],train_num)
  51. y_underlying = linear_func(X_underlying)
  52.  
  53. # 绘制数据
  54. plt.scatter(X_train, y_train, marker='*', facecolor="none", edgecolor='#e4007f', s=50, label="train data")
  55. plt.scatter(X_test, y_test, facecolor="none", edgecolor='#f19ec2', s=50, label="test data")
  56. plt.plot(X_underlying, y_underlying, c='#000000', label=r"underlying distribution")
  57. plt.legend(fontsize='x-large') # 给图像加图例
  58. plt.savefig('ml-vis.pdf') # 保存图像到PDF文件中
  59. plt.show()

2.2.2 模型构建

y=wX+b

  1. import torch
  2. torch.seed()  # 设置随机种子
  3. class Op(object):
  4.     def __init__(self):
  5.         pass
  6.  
  7.     def __call__(self, inputs):
  8.         return self.forward(inputs)
  9.  
  10.     def forward(self, inputs):
  11.         raise NotImplementedError
  12.  
  13.     def backward(self, inputs):
  14.         raise NotImplementedError
  15.  
  16. # 线性算子
  17. class Linear(Op):
  18.     def __init__(self, input_size):
  19.         """
  20.         输入：
  21.            - input_size:模型要处理的数据特征向量长度
  22.         """
  23.  
  24.         self.input_size = input_size
  25.  
  26.         # 模型参数
  27.         self.params = {}
  28.         self.params['w'] = torch.randn(self.input_size, 1)
  29.         self.params['b'] = torch.zeros([1])
  30.  
  31.     def __call__(self, X):
  32.         return self.forward(X)
  33.  
  34.     # 前向函数
  35.     def forward(self, X):
  36.         """
  37.         输入：
  38.            - X: tensor, shape=[N,D]
  39.            注意这里的X矩阵是由N个x向量的转置拼接成的，与原教材行向量表示方式不一致
  40.         输出：
  41.            - y_pred： tensor, shape=[N]
  42.         """
  43.  
  44.         N, D = X.shape
  45.  
  46.         if self.input_size == 0:
  47.             return torch.full(shape=[N, 1], fill_value=self.params['b'])
  48.  
  49.         assert D == self.input_size  # 输入数据维度合法性验证
  50.  
  51.         # 使用paddle.matmul计算两个tensor的乘积
  52.         y_pred = torch.matmul(X, self.params['w']) + self.params['b']
  53.  
  54.         return y_pred
  55.  
  56. # 注意这里我们为了和后面章节统一，这里的X矩阵是由N个x向量的转置拼接成的，与原教材行向量表示方式不一致
  57. input_size = 3
  58. N = 2
  59. X = torch.randn(N, input_size)  # 生成2个维度为3的数据
  60. model = Linear(input_size)
  61. y_pred = model(X)
  62. print("y_pred:", y_pred)  # 输出结果的个数也是2个

2.2.3 损失函数

回归任务中常用的评估指标是均方误差

均方误差是反映估计量与被估计量之间差异程度的一种度量。

令y∈RNy∈RN，y^∈RNy^∈RN分别为NN个样本的真实标签和预测标签，均方误差的定义为：

 其中bb为NN维向量，所有元素取值都为bb。

【注意：代码实现中没有除2】

  1. import torch
  2.  
  3. def mean_squared_error(y_true, y_pred):
  4.     """
  5.     输入：
  6.        - y_true: tensor，样本真实标签
  7.        - y_pred: tensor, 样本预测标签
  8.     输出：
  9.        - error: float，误差值
  10.     """
  11.     assert y_true.shape[0] == y_pred.shape[0]
  12.  
  13.     # torch.square计算输入的平方值
  14.     # torch.mean沿 axis 计算 x 的平均值，默认axis是None，则对输入的全部元素计算平均值。
  15.     error = torch.mean(torch.square(y_true - y_pred))
  16.     return error
  17.  
  18. # 构造一个简单的样例进行测试:[N,1], N=2
  19. y_true = torch.tensor([[-0.2], [4.9]],dtype=torch.float32)
  20. y_pred = torch.tensor([[1.3], [2.5]],dtype=torch.float32)
  21.  
  22. error = mean_squared_error(y_true=y_true, y_pred=y_pred).item()
  23. print("error:", error)

 思考：没有除2合理么？谈谈自己的看法

合理，除2不影响均方误差，后续对有平方的损失函数求导，含1/2更加方便计算。

2.2.4 模型优化

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

  1. import torch
  2.  
  3. def optimizer_lsm(model, X, y, reg_lambda=0):
  4.     """
  5.       输入：
  6.          - model: 模型
  7.          - X: tensor, 特征数据，shape=[N,D]
  8.          - y: tensor,标签数据，shape=[N]
  9.          - reg_lambda: float, 正则化系数，默认为0
  10.       输出：
  11.          - model: 优化好的模型
  12.       """
  13.  
  14.     N, D = X.shape
  15.  
  16.     # 对输入特征数据所有特征向量求平均
  17.     x_bar_tran = torch.mean(X, axis=0).T
  18.  
  19.     # 求标签的均值,shape=[1]
  20.     y_bar = torch.mean(y)
  21.  
  22.     # torch.subtract通过广播的方式实现矩阵减向量
  23.     x_sub = torch.subtract(X, x_bar_tran)
  24.  
  25.     # 使用torch.all判断输入tensor是否全0
  26.     if torch.all(x_sub == 0):
  27.         model.params['b'] = y_bar
  28.         model.params['w'] = torch.zeros(shape=[D])
  29.         return model
  30.  
  31.     # torch.inverse求方阵的逆
  32.     tmp = torch.inverse(torch.matmul(x_sub.T, x_sub) +
  33.                          reg_lambda * paddle.eye(num_rows=(D)))
  34.  
  35.     w = torch.matmul(torch.matmul(tmp, x_sub.T), (y - y_bar))
  36.  
  37.     b = y_bar - torch.matmul(x_bar_tran, w)
  38.  
  39.     model.params['b'] = b
  40.     model.params['w'] = torch.squeeze(w, axis=-1)
  41.  
  42.     return model

思考1. 为什么省略了\frac{1}{N}不影响效果？

1/N是一个常数，不影响效果

思考 2.  什么是最小二乘法 

最小二乘法是一种优化方法，求得目标函数的最优值。并且也可以用于曲线拟合，来解决回归问题

2.2.5 模型训练

在准备了数据、模型、损失函数和参数学习的实现之后，开始模型的训练。

在回归任务中，模型的评价指标和损失函数一致，都为均方误差。

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

  1. input_size = 1
  2. model = Linear(input_size)
  3. model = optimizer_lsm(model,X_train.reshape([-1,1]),y_train.reshape([-1,1]))
  4. print("w_pred:",model.params['w'].item(), "b_pred: ", model.params['b'].item())
  5.  
  6. y_train_pred = model(X_train.reshape([-1,1])).squeeze()
  7. train_error = mean_squared_error(y_true=y_train, y_pred=y_train_pred).item()
  8. print("train error: ",train_error)
  9.  
  10. model_large = Linear(input_size)
  11. model_large = optimizer_lsm(model_large,X_train_large.reshape([-1,1]),y_train_large.reshape([-1,1]))
  12. print("w_pred large:",model_large.params['w'].item(), "b_pred large: ", model_large.params['b'].item())
  13.  
  14. y_train_pred_large = model_large(X_train_large.reshape([-1,1])).squeeze()
  15. train_error_large = mean_squared_error(y_true=y_train_large, y_pred=y_train_pred_large).item()
  16. print("train error large: ",train_error_large)

2.2.6 模型评估

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

  1. #模型评估
  2. y_test_pred = model(X_test.reshape([-1,1])).squeeze()
  3. test_error = mean_squared_error(y_true=y_test, y_pred=y_test_pred).item()
  4. print("test error: ",test_error)
  5. y_test_pred_large = model_large(X_test.reshape([-1,1])).squeeze()
  6. test_error_large = mean_squared_error(y_true=y_test, y_pred=y_test_pred_large).item()
  7. print("test error large: ",test_error_large)

2.2.7 样本数量 & 正则化系数

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

 

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

调整为0.1

 

 

2.3 多项式回归

 2.3.1 数据集构建

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

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

  1. #多项式回归
  2. #数据集构建
  3. import math
  4. import torch
  5. from matplotlib import pyplot as plt # matplotlib 是 Python 的绘图库
  6. # sin函数: sin(2 * pi * x)
  7. def sin(x):
  8.     y = torch.sin(2 * math.pi * x)
  9.     return y
  10.  
  11. def create_toy_data(func, interval, sample_num, noise = 0.0, add_outlier = False, outlier_ratio = 0.001):
  12.     """
  13.     根据给定的函数，生成样本
  14.     输入：
  15.        - func：函数
  16.        - interval： x的取值范围
  17.        - sample_num： 样本数目
  18.        - noise： 噪声均方差
  19.        - add_outlier：是否生成异常值
  20.        - outlier_ratio：异常值占比
  21.     输出：
  22.        - X: 特征数据，shape=[n_samples,1]
  23.        - y: 标签数据，shape=[n_samples,1]
  24.     """
  25.  
  26.     # 均匀采样
  27.     # 使用torch.rand在生成sample_num个随机数
  28.     X = torch.rand(size = [sample_num]) * (interval[1]-interval[0]) + interval[0]
  29.     y = func(X)
  30.     # 生成高斯分布的标签噪声
  31.     # 使用torch.normal生成0均值，noise标准差的数据
  32.     epsilon = torch.normal(0,noise,y.shape)
  33.     y = y + epsilon
  34.     if add_outlier:     # 生成额外的异常点
  35.         outlier_num = int(len(y)*outlier_ratio)
  36.         if outlier_num != 0:
  37.             # 使用paddle.randint生成服从均匀分布的、范围在[0, len(y))的随机Tensor
  38.             outlier_idx = torch.randint(len(y),size = [outlier_num])
  39.             y[outlier_idx] = y[outlier_idx] * 5
  40.     return X, y
  41.  
  42.  
  43. # 生成数据
  44. func = sin
  45. interval = (0,1)
  46. train_num = 15
  47. test_num = 10
  48. noise = 0.5 #0.1
  49. X_train, y_train = create_toy_data(func=func, interval=interval, sample_num=train_num, noise = noise)
  50. X_test, y_test = create_toy_data(func=func, interval=interval, sample_num=test_num, noise = noise)
  51.  
  52. X_underlying = torch.linspace(interval[0],interval[1],steps=100)
  53. y_underlying = sin(X_underlying)
  54.  
  55. # 绘制图像
  56. plt.rcParams['figure.figsize'] = (8.0, 6.0)
  57. plt.scatter(X_train, y_train, facecolor="none", edgecolor='#e4007f', s=50, label="train data")
  58. #plt.scatter(X_test, y_test, facecolor="none", edgecolor="r", s=50, label="test data")
  59. plt.plot(X_underlying, y_underlying, c='#000000', label=r"$\sin(2\pi x)$")
  60. plt.legend(fontsize='x-large')
  61. plt.savefig('ml-vis2.pdf')
  62. plt.show()

2.3.2 模型构建

套用求解线性回归参数的方法来求解多项式回归参数

  1. #模型构建
  2. # 多项式转换
  3. def polynomial_basis_function(x, degree=2):
  4.     """
  5.     输入：
  6.        - x: tensor, 输入的数据，shape=[N,1]
  7.        - degree: int, 多项式的阶数
  8.        example Input: [[2], [3], [4]], degree=2
  9.        example Output: [[2^1, 2^2], [3^1, 3^2], [4^1, 4^2]]
  10.        注意：本案例中,在degree>=1时不生成全为1的一列数据；degree为0时生成形状与输入相同，全1的Tensor
  11.     输出：
  12.        - x_result： tensor
  13.     """
  14.  
  15.     if degree == 0:
  16.         return torch.ones(shape=x.shape, dtype=torch.float32)
  17.  
  18.     x_tmp = x
  19.     x_result = x_tmp
  20.  
  21.     for i in range(2, degree + 1):
  22.         x_tmp = torch.multiply(x_tmp, x)  # 逐元素相乘
  23.         x_result = torch.concat((x_result, x_tmp),-1)
  24.  
  25.     return x_result
  26.  
  27.  
  28. # 简单测试
  29. data = [[2], [3], [4]]
  30. X = torch.tensor(data=data, dtype=torch.float32)
  31. degree = 3
  32. transformed_X = polynomial_basis_function(X, degree=degree)
  33. print("转换前：", X)
  34. print("阶数为", degree, "转换后：", transformed_X)

结果：

2.3.3 模型训练

对于多项式回归，我们可以同样使用前面线性回归中定义的LinearRegression算子、训练函数train、均方误差函数mean_squared_error。

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

 

观察可视化结果，红色的曲线表示不同阶多项式分布拟合数据的结果：

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

 2.3.4 模型评估

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

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

  1. # 训练误差和测试误差
  2. training_errors = []
  3. test_errors = []
  4. distribution_errors = []
  5.  
  6. # 遍历多项式阶数
  7. for i in range(9):
  8.     model = Linear(i)
  9.  
  10.     X_train_transformed = polynomial_basis_function(X_train.reshape([-1, 1]), i)
  11.     X_test_transformed = polynomial_basis_function(X_test.reshape([-1, 1]), i)
  12.     X_underlying_transformed = polynomial_basis_function(X_underlying.reshape([-1, 1]), i)
  13.  
  14.     optimizer_lsm(model, X_train_transformed, y_train.reshape([-1, 1]))
  15.  
  16.     y_train_pred = model(X_train_transformed).squeeze()
  17.     y_test_pred = model(X_test_transformed).squeeze()
  18.     y_underlying_pred = model(X_underlying_transformed).squeeze()
  19.  
  20.     train_mse = mean_squared_error(y_true=y_train, y_pred=y_train_pred).item()
  21.     training_errors.append(train_mse)
  22.  
  23.     test_mse = mean_squared_error(y_true=y_test, y_pred=y_test_pred).item()
  24.     test_errors.append(test_mse)
  25.  
  26.     # distribution_mse = mean_squared_error(y_true=y_underlying, y_pred=y_underlying_pred).item()
  27.     # distribution_errors.append(distribution_mse)
  28.  
  29. print("train errors: \n", training_errors)
  30. print("test errors: \n", test_errors)
  31. # print ("distribution errors: \n", distribution_errors)
  32.  
  33. # 绘制图片
  34. plt.rcParams['figure.figsize'] = (8.0, 6.0)
  35. plt.plot(training_errors, '-.', mfc="none", mec='#e4007f', ms=10, c='#e4007f', label="Training")
  36. plt.plot(test_errors, '--', mfc="none", mec='#f19ec2', ms=10, c='#f19ec2', label="Test")
  37. # plt.plot(distribution_errors, '-', mfc="none", mec="#3D3D3F", ms=10, c="#3D3D3F", label="Distribution")
  38. plt.legend(fontsize='x-large')
  39. plt.xlabel("degree")
  40. plt.ylabel("MSE")
  41. plt.savefig('ml-mse-error.pdf')
  42. plt.show()
  43.

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

  1. degree = 8 # 多项式阶数
  2. reg_lambda = 0.0001 # 正则化系数
  3.  
  4. X_train_transformed = polynomial_basis_function(X_train.reshape([-1,1]), degree)
  5. X_test_transformed = polynomial_basis_function(X_test.reshape([-1,1]), degree)
  6. X_underlying_transformed = polynomial_basis_function(X_underlying.reshape([-1,1]), degree)
  7.  
  8. model = Linear(degree)
  9.  
  10. optimizer_lsm(model,X_train_transformed,y_train.reshape([-1,1]))
  11.  
  12. y_test_pred=model(X_test_transformed).squeeze()
  13. y_underlying_pred=model(X_underlying_transformed).squeeze()
  14.  
  15. model_reg = Linear(degree)
  16.  
  17. optimizer_lsm(model_reg,X_train_transformed,y_train.reshape([-1,1]),reg_lambda=reg_lambda)
  18.  
  19. y_test_pred_reg=model_reg(X_test_transformed).squeeze()
  20. y_underlying_pred_reg=model_reg(X_underlying_transformed).squeeze()
  21.  
  22. mse = mean_squared_error(y_true = y_test, y_pred = y_test_pred).item()
  23. print("mse:",mse)
  24. mes_reg = mean_squared_error(y_true = y_test, y_pred = y_test_pred_reg).item()
  25. print("mse_with_l2_reg:",mes_reg)
  26.  
  27. # 绘制图像
  28. plt.scatter(X_train, y_train, facecolor="none", edgecolor="#e4007f", s=50, label="train data")
  29. plt.plot(X_underlying, y_underlying, c='#000000', label=r"$\sin(2\pi x)$")
  30. plt.plot(X_underlying, y_underlying_pred, c='#e4007f', linestyle="--", label="$deg. = 8$")
  31. plt.plot(X_underlying, y_underlying_pred_reg, c='#f19ec2', linestyle="-.", label="$deg. = 8, \ell_2 reg$")
  32. plt.ylim(-1.5, 1.5)
  33. plt.annotate("lambda={}".format(reg_lambda), xy=(0.82, -1.4))
  34. plt.legend(fontsize='large')
  35. plt.savefig('ml-vis4.pdf')
  36. plt.show()

2.4 Runner类介绍

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

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

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

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

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

  1. class Runner(object):
  2.     def __init__(self, model, optimizer, loss_fn, metric):
  3.         self.model = model         # 模型
  4.         self.optimizer = optimizer # 优化器
  5.         self.loss_fn = loss_fn     # 损失函数   
  6.         self.metric = metric       # 评估指标
  7.  
  8.     # 模型训练
  9.     def train(self, train_dataset, dev_dataset=None, **kwargs):
  10.         pass
  11.  
  12.     # 模型评价
  13.     def evaluate(self, data_set, **kwargs):
  14.         pass
  15.  
  16.     # 模型预测
  17.     def predict(self, x, **kwargs):
  18.         pass
  19.  
  20.     # 模型保存
  21.     def save_model(self, save_path):
  22.         pass
  23.  
  24.     # 模型加载
  25.     def load_model(self, model_path):
  26.         pass

Runner类的流程如下图所示，可以分为 4 个阶段：
初始化阶段：传入模型、损失函数、优化器和评价指标。
模型训练阶段：基于训练集调用train()函数训练模型，基于验证集通过evaluate()函数验证模型。通过save_model()函数保存模型。
模型评价阶段：基于测试集通过evaluate()函数得到指标性能。

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

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

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

  • 数据处理：包括数据清洗（缺失值和异常值处理）、数据集划分，以便数据可以被模型正常读取，并具有良好的泛化性;
  • 模型构建：定义线性回归模型类；
  • 训练配置:训练相关的一些配置，如：优化算法、评价指标等；
  • 组装训练框架Runner:Runner用于管理模型训练和测试过程；
  • 模型训练和测试:利用Runner进行模型训练和测试。
  1. import pandas as pd # 开源数据分析和操作工具
  2.  
  3. # 利用pandas加载波士顿房价的数据集
  4. data=pd.read_csv("boston_house_prices.csv")
  5. # 预览前5行数据
  6. print(data.head())

2.5.1.2 数据清洗

缺失值分析：通过isna()方法判断数据中各元素是否缺失，然后通过sum()方法统计每个字段缺失情况

  1. import pandas as pd # 开源数据分析和操作工具
  2.  
  3. # 利用pandas加载波士顿房价的数据集
  4. data=pd.read_csv("boston_house_prices.csv")
  5. # 查看各字段缺失值统计情况
  6. print(data.isna().sum())

从输出结果看，波士顿房价预测数据集中不存在缺失值的情况。

  • 异常值处理

异常值分析：通过箱线图直观的显示数据分布，并观测数据中的异常值。箱线图一般由五个统计值组成：最大值、上四分位、中位数、下四分位和最小值。一般来说，观测到的数据大于最大估计值或者小于最小估计值则判断为异常值，其中：
最大估计值=上四分位+1.5∗(上四分位−下四分位)
最小估计值=下四分位−1.5∗(上四分位−下四分位)

  1. import matplotlib.pyplot as plt  # 可视化工具
  2. import pandas as pd  # 开源数据分析和操作工具
  3.  
  4. # 利用pandas加载波士顿房价的数据集
  5. data = pd.read_csv("boston_house_prices.csv")
  6.  
  7. # 箱线图查看异常值分布
  8. def boxplot(data, fig_name):
  9.     # 绘制每个属性的箱线图
  10.     data_col = list(data.columns)
  11.  
  12.     # 连续画几个图片
  13.     plt.figure(figsize=(5, 5), dpi=300)
  14.     # 子图调整
  15.     plt.subplots_adjust(wspace=0.6)
  16.     # 每个特征画一个箱线图
  17.     for i, col_name in enumerate(data_col):
  18.         plt.subplot(3, 5, i + 1)
  19.         # 画箱线图
  20.         plt.boxplot(data[col_name],
  21.                     showmeans=True,
  22.                     meanprops={"markersize": 1, "marker": "D", "markeredgecolor": '#f19ec2'},  # 均值的属性
  23.                     medianprops={"color": '#e4007f'},  # 中位数线的属性
  24.                     whiskerprops={"color": '#e4007f', "linewidth": 0.4, 'linestyle': "--"},
  25.                     flierprops={"markersize": 0.4},
  26.                     )
  27.         # 图名
  28.         plt.title(col_name, fontdict={"size": 5}, pad=2)
  29.         # y方向刻度
  30.         plt.yticks(fontsize=4, rotation=90)
  31.         plt.tick_params(pad=0.5)
  32.         # x方向刻度
  33.         plt.xticks([])
  34.     plt.savefig(fig_name)
  35.     plt.show()
  36.  
  37. boxplot(data, 'ml-vis5.pdf')

 使用四分位值筛选出箱线图中分布的异常值，并将这些数据视为噪声，其将被临界值取代，代码实现如下：

  1. # 四分位处理异常值
  2. num_features=data.select_dtypes(exclude=['object','bool']).columns.tolist()
  3.  
  4. for feature in num_features:
  5.     if feature =='CHAS':
  6.         continue
  7.     
  8.     Q1  = data[feature].quantile(q=0.25) # 下四分位
  9.     Q3  = data[feature].quantile(q=0.75) # 上四分位
  10.     
  11.     IQR = Q3-Q1 
  12.     top = Q3+1.5*IQR # 最大估计值
  13.     bot = Q1-1.5*IQR # 最小估计值
  14.     values=data[feature].values
  15.     values[values > top] = top # 临界值取代噪声
  16.     values[values < bot] = bot # 临界值取代噪声
  17.     data[feature] = values.astype(data[feature].dtypes)
  18.  
  19. # 再次查看箱线图，异常值已被临界值替换（数据量较多或本身异常值较少时，箱线图展示会不容易体现出来）
  20. boxplot(data, 'ml-vis6.pdf')

 

2.5.1.3 数据集划分

由于本实验比较简单，将数据集划分为两份：训练集和测试集，不包括验证集。

具体代码如下：

  1. import torch
  2.  
  3. torch.seed()
  4.  
  5.  
  6. # 划分训练集和测试集
  7. def train_test_split(X, y, train_percent=0.8):
  8.     n = len(X)
  9.     shuffled_indices = torch.randperm(n)  # 返回一个数值在0到n-1、随机排列的1-D Tensor
  10.     train_set_size = int(n * train_percent)
  11.     train_indices = shuffled_indices[:train_set_size]
  12.     test_indices = shuffled_indices[train_set_size:]
  13.  
  14.     X = X.values
  15.     y = y.values
  16.  
  17.     X_train = X[train_indices]
  18.     y_train = y[train_indices]
  19.  
  20.     X_test = X[test_indices]
  21.     y_test = y[test_indices]
  22.  
  23.     return X_train, X_test, y_train, y_test
  24.  
  25.  
  26. X = data.drop(['MEDV'], axis=1)
  27. y = data['MEDV']
  28.  
  29. X_train, X_test, y_train, y_test = train_test_split(X, y)  # X_train每一行是个样本，shape[N,D]

2.5.1.4 特征工程

为了消除纲量对数据特征之间影响，在模型训练前，需要对特征数据进行归一化处理，将数据缩放到[0, 1]区间内，使得不同特征之间具有可比性。

代码实现如下：

  1. import torch
  2.  
  3. X_train = torch.tensor(X_train,dtype=torch.float32)
  4. X_test = torch.tensor(X_test,dtype=torch.float32)
  5. y_train = torch.tensor(y_train,dtype=torch.float32)
  6. y_test = torch.tensor(y_test,dtype=torch.float32)
  7.  
  8. X_min = torch.min(X_train)
  9. X_max = torch.max(X_train)
  10. X_train = (X_train-X_min)/(X_max-X_min)
  11.  
  12. X_test  = (X_test-X_min)/(X_max-X_min)
  13.  
  14.  
  15. # 训练集构造
  16. train_dataset=(X_train,y_train)
  17. # 测试集构造
  18. test_dataset=(X_test,y_test)
  19. print(train_dataset)
  20. print(test_dataset)
  1. (tensor([[4.7243e-05, 4.3952e-02, 4.1491e-03,  ..., 3.5443e-01, 2.5738e-02,
  2.          2.7848e-03],
  3.         [7.8496e-03, 0.0000e+00, 2.5457e-02,  ..., 9.3671e-01, 2.8411e-02,
  4.          2.2813e-02],
  5.         [9.4502e-04, 0.0000e+00, 1.1449e-02,  ..., 4.3179e-01, 2.9536e-02,
  6.          2.0830e-02],
  7.         ...,
  8.         [4.2076e-04, 2.8129e-02, 9.7890e-03,  ..., 3.1364e-01, 2.6160e-02,
  9.          1.8284e-02],
  10.         [5.7848e-05, 3.5162e-02, 6.8354e-03,  ..., 3.9522e-01, 2.6723e-02,
  11.          7.4402e-03],
  12.         [5.2996e-05, 4.3952e-02, 2.1378e-03,  ..., 4.6273e-01, 1.8565e-02,
  13.          9.3108e-03]]), tensor([34.9000, 14.3000, 16.6000, 31.1000, 10.5000, 22.0000, 23.9000, 16.1000,
  14.         23.6000, 27.5000,  7.2000, 20.8000, 22.9000, 20.6000, 13.4000, 26.2000,
  15.         23.1000, 20.3000, 21.1000, 10.5000, 11.3000, 25.0000, 18.7000, 19.4000,
  16.         28.2000, 14.2000, 17.2000, 31.5000, 13.0000, 31.5000, 36.9625, 23.3000,
  17.         10.4000, 18.7000, 19.7000, 10.2000, 13.1000, 19.4000, 13.3000, 17.8000,
  18.         36.9625, 21.7000, 18.5000,  7.0000, 22.7000, 26.6000, 23.1000, 15.2000,
  19.         24.7000, 36.9625, 36.9625, 23.9000, 12.7000, 36.5000, 13.4000, 13.3000,
  20.         14.8000, 22.1000, 27.5000, 35.2000, 15.4000, 25.0000, 24.4000, 20.1000,
  21.         13.8000, 19.3000, 25.2000, 24.6000, 22.0000, 36.9625, 13.8000, 14.5000,
  22.         28.5000, 22.9000, 21.4000, 17.0000, 17.4000, 15.4000, 27.1000, 24.1000,
  23.         18.4000, 19.1000, 24.5000, 28.7000, 19.6000,  5.0625, 29.6000, 15.1000,
  24.         30.3000, 11.8000, 32.7000, 19.9000, 12.7000, 19.6000, 19.9000, 20.6000,
  25.         24.4000, 18.4000, 36.9625, 31.6000, 22.9000, 22.9000, 23.1000, 25.0000,
  26.         26.6000, 27.1000, 34.7000, 17.5000, 23.4000,  5.0625, 36.9625, 36.9625,
  27.         21.7000, 13.6000, 36.9625,  8.3000, 23.0000, 36.9625, 20.8000, 23.2000,
  28.         19.3000,  8.3000, 14.4000, 23.1000, 20.1000, 17.4000, 23.7000, 19.2000,
  29.         18.9000, 23.1000, 22.2000, 26.4000, 21.9000, 22.2000, 32.5000, 17.3000,
  30.         35.1000, 29.4000, 19.8000, 19.5000, 17.6000, 23.0000,  7.2000, 19.9000,
  31.         21.6000, 12.1000, 22.4000, 24.3000,  8.4000, 11.7000, 17.1000, 17.9000,
  32.         36.9625, 20.4000, 20.3000, 18.1000, 30.7000, 13.8000, 18.6000, 22.3000,
  33.         20.5000, 36.9625, 28.4000, 19.4000, 13.1000, 12.0000, 36.1000, 22.0000,
  34.         16.1000, 24.7000, 36.9625, 19.0000, 24.0000, 18.2000, 30.1000, 24.5000,
  35.          7.2000, 19.8000, 10.9000, 36.9625, 23.2000, 19.4000, 19.3000, 36.9625,
  36.         21.7000, 28.7000, 15.0000, 14.1000, 15.6000,  7.5000, 33.0000, 20.9000,
  37.         20.6000,  8.8000, 19.2000, 16.2000, 29.8000, 18.0000, 19.3000, 20.0000,
  38.         20.2000, 21.5000, 17.1000, 17.2000, 33.4000, 36.9625, 20.0000, 16.5000,
  39.         36.9625, 21.6000, 21.7000, 20.0000, 22.2000, 20.5000, 21.7000, 32.2000,
  40.         18.9000, 28.7000, 14.6000, 16.7000, 16.6000, 21.7000, 25.0000, 13.5000,
  41.         13.9000, 15.2000, 15.3000, 14.9000, 32.0000, 29.6000, 21.8000, 23.9000,
  42.         24.5000, 23.3000, 22.2000, 12.5000, 28.4000, 29.9000, 14.1000, 22.5000,
  43.         20.4000, 23.7000, 33.3000, 33.2000, 21.0000,  8.4000, 32.9000, 27.9000,
  44.         23.8000, 21.4000, 36.9625, 19.1000, 20.0000, 23.7000, 13.8000, 24.4000,
  45.         20.3000, 16.0000, 22.7000, 32.0000, 20.3000, 14.9000, 23.9000, 26.5000,
  46.         22.8000, 24.8000, 16.8000, 33.1000, 23.6000, 16.4000, 25.3000, 31.6000,
  47.         24.4000,  8.5000, 22.6000, 17.8000, 16.3000, 18.9000, 21.7000, 23.8000,
  48.         10.2000, 30.1000, 23.2000, 36.2000, 36.9625, 36.9625, 24.8000, 15.2000,
  49.         24.6000, 22.6000, 11.8000, 34.9000, 22.0000, 36.9625, 23.1000, 33.1000,
  50.         24.3000, 14.4000, 36.9625, 24.1000, 16.1000, 36.9625, 13.8000, 18.5000,
  51.         34.9000, 15.0000, 36.4000, 19.0000, 16.7000, 36.9625, 36.9625, 21.4000,
  52.         21.2000, 20.0000, 18.2000, 12.6000, 36.9625, 20.8000, 11.0000, 18.6000,
  53.          7.4000, 17.8000, 33.2000, 18.5000, 20.9000, 20.1000, 23.4000, 24.1000,
  54.         21.8000, 23.3000, 15.6000, 11.9000, 24.8000,  8.7000, 31.0000, 11.9000,
  55.         22.5000, 20.6000, 13.1000, 13.3000, 28.6000, 22.2000, 21.2000, 22.0000,
  56.          8.5000, 19.5000, 18.2000, 20.7000, 21.2000, 23.0000, 35.4000, 29.1000,
  57.          8.8000, 16.8000, 20.4000, 19.5000, 30.1000, 36.9625, 23.7000, 10.8000,
  58.         19.6000, 18.4000, 21.4000,  8.1000, 18.8000, 22.8000, 19.4000, 19.8000,
  59.         21.5000, 17.8000, 24.3000, 20.7000, 29.0000, 20.1000, 21.0000, 17.8000,
  60.         31.2000, 25.0000, 16.2000, 22.0000, 17.5000, 13.2000, 25.1000, 22.8000,
  61.         15.6000, 25.0000, 17.5000, 22.3000, 19.7000, 10.2000, 20.4000, 20.6000,
  62.         33.8000, 28.1000, 17.7000, 22.6000, 17.1000, 25.0000, 20.5000, 36.9625,
  63.         20.6000, 21.1000, 28.0000, 34.6000]))
  64. (tensor([[3.0910e-04, 0.0000e+00, 9.7187e-03,  ..., 3.2771e-01, 2.5176e-02,
  65.          2.2785e-02],
  66.         [6.5114e-04, 0.0000e+00, 8.7201e-03,  ..., 4.3179e-01, 2.4473e-02,
  67.          7.3840e-03],
  68.         [1.1822e-03, 0.0000e+00, 1.1449e-02,  ..., 4.3179e-01, 2.9536e-02,
  69.          2.3221e-02],
  70.         ...,
  71.         [2.4098e-04, 0.0000e+00, 1.4079e-02,  ..., 6.0759e-01, 2.5035e-02,
  72.          2.2166e-02],
  73.         [1.2756e-02, 0.0000e+00, 2.5457e-02,  ..., 9.3671e-01, 2.8411e-02,
  74.          2.5387e-02],
  75.         [1.1984e-03, 0.0000e+00, 1.1449e-02,  ..., 4.3179e-01, 2.9536e-02,
  76.          1.9451e-02]]), tensor([19.4000, 31.7000, 13.9000, 22.4000, 25.0000, 21.4000, 18.7000, 15.0000,
  77.         18.5000, 14.3000, 18.8000, 22.0000, 30.5000, 19.3000, 22.6000, 22.6000,
  78.         26.4000, 13.4000, 36.9625, 36.9625, 26.7000, 23.8000, 27.9000, 24.7000,
  79.         19.1000, 22.5000, 26.6000, 20.2000, 27.5000,  6.3000, 12.3000, 19.9000,
  80.         29.8000, 30.8000, 21.0000, 36.0000,  7.0000, 15.6000, 36.2000, 23.9000,
  81.         36.9625, 21.2000, 13.4000, 23.0000, 27.5000, 23.5000, 14.5000, 23.1000,
  82.         36.9625, 13.6000, 19.6000, 21.9000, 17.4000, 15.6000, 23.8000, 14.5000,
  83.         16.5000, 14.6000, 20.1000, 13.1000, 24.0000, 15.7000, 14.0000, 35.4000,
  84.         36.9625, 18.9000, 23.3000, 36.9625, 11.7000, 24.8000, 13.5000, 36.9625,
  85.         12.7000, 19.5000, 14.9000, 33.4000, 21.2000, 36.9625, 21.9000, 19.1000,
  86.         12.8000, 10.9000, 11.5000, 22.8000, 32.4000, 27.0000, 10.4000, 29.0000,
  87.         29.1000, 18.3000,  5.6000, 36.9625, 23.2000, 17.2000, 14.1000,  9.5000,
  88.         36.9625,  9.7000, 24.2000, 18.3000,  9.6000, 19.6000]))
  89.

2.5.2 模型构建

  1. from nndl.op import Linear
  2.  
  3. # 模型实例化
  4. input_size = 12
  5. model=Linear(input_size)
  6. print(model)

运行结果

  1. <nndl.op.Linear object at 0x00000169EB199070>
  2.  
  3. Process finished with exit code 0


2.5.3 完善Runner类


模型定义好后，围绕模型需要配置损失函数、优化器、评估、测试等信息，以及模型相关的一些其他信息（如模型存储路径等）。

在本章中使用的Runner类为V1版本。其中训练过程通过直接求解解析解的方式得到模型参数，没有模型优化及计算损失函数过程，模型训练结束后保存模型参数。

训练配置中定义:

训练环境，如GPU还是CPU，本案例不涉及；
优化器，本案例不涉及；
损失函数，本案例通过平方损失函数得到模型参数的解析解；
评估指标，本案例利用MSE评估模型效果。
在测试集上使用MSE对模型性能进行评估。

  1. import torch.nn as nn
  2. mse_loss = nn.MSELoss()
  3.  
  4. import torch
  5. import os
  6. from nndl.opitimizer import optimizer_lsm
  7.  
  8.  
  9. class Runner(object):
  10.     def __init__(self, model, optimizer, loss_fn, metric):
  11.         # 优化器和损失函数为None,不再关注
  12.  
  13.         # 模型
  14.         self.model = model
  15.         # 评估指标
  16.         self.metric = metric
  17.         # 优化器
  18.         self.optimizer = optimizer
  19.  
  20.     def train(self, dataset, reg_lambda, model_dir):
  21.         X, y = dataset
  22.         self.optimizer(self.model, X, y, reg_lambda)
  23.  
  24.         # 保存模型
  25.         self.save_model(model_dir)
  26.  
  27.     def evaluate(self, dataset, **kwargs):
  28.         X, y = dataset
  29.  
  30.         y_pred = self.model(X)
  31.         result = self.metric(y_pred, y)
  32.  
  33.         return result
  34.  
  35.     def predict(self, X, **kwargs):
  36.         return self.model(X)
  37.  
  38.     def save_model(self, model_dir):
  39.         if not os.path.exists(model_dir):
  40.             os.makedirs(model_dir)
  41.  
  42.         params_saved_path = os.path.join(model_dir, 'params.pdtensor')
  43.         torch.save(model.params, params_saved_path)
  44.  
  45.     def load_model(self, model_dir):
  46.         params_saved_path = os.path.join(model_dir, 'params.pdtensor')
  47.         self.model.params = torch.load(params_saved_path)
  48.  
  49.  
  50. optimizer = optimizer_lsm
  51.  
  52. # 实例化Runner
  53. runner = Runner(model, optimizer=optimizer, loss_fn=None, metric=mse_loss)
  54. print(runner)

运行结果

  1. <__main__.Runner object at 0x00000189388E6640>
  2.  
  3. Process finished with exit code 0

2.5.4 模型训练
 

  1. columns_list = data.columns.to_list()
  2. weights = runner.model.params['w'].tolist()
  3. b = runner.model.params['b'].item()
  4.  
  5. for i in range(len(weights)):
  6.     print(columns_list[i],"weight:",weights[i])
  7.  
  8. print("b:",b)

运行结果

  1. CRIM weight: -545.2598266601562
  2. ZN weight: 22.065792083740234
  3. INDUS weight: -8.44003677368164
  4. CHAS weight: 1530.1904296875
  5. NOX weight: -8955.4931640625
  6. RM weight: 2347.146484375
  7. AGE weight: -5.644048690795898
  8. DIS weight: -707.4413452148438
  9. RAD weight: 271.2647705078125
  10. TAX weight: -6.599415302276611
  11. PTRATIO weight: -592.3955688476562
  12. LSTAT weight: -313.0545654296875
  13. b: 35.074371337890625
  14.  
  15. Process finished with exit code 0


2.5.5 模型测试

  1. # 加载模型权重
  2. runner.load_model(saved_dir)
  3.  
  4. mse = runner.evaluate(test_dataset)
  5. print('MSE:', mse.item())

运行结果

MSE: 14.380061149597168

2.5.6 模型预测

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

运行结果

  1. 真实房价： 10.899999618530273
  2. 预测的房价： 15.171201705932617

从输出结果看，预测房价接近真实房价。


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

简单，易于理解

既可以用来做分类也可以用来做回归

提高效率


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

避免了重复定义的错误，便于处理。


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

不能，交叉熵损失函数

对于回归问题，均方误差求解比交叉熵求解更方便。

总结

对线性回归及多项式回归中模型处理过程及相关函数有了一定的了解。掌握了损失函数的原理。熟悉了如何使用类编程，感受到类编程的好处。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/103704
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号