pytorch实战波斯顿房价回归模型-EW帮帮网

系列文章目录

文章目录

系列文章目录
建模过程
一、数据输入
二、网络搭建
三、定义损失函数
四、定义优化器
五、训练与测试

建模过程

就像机器学习一样，我们建模分为：数据处理，网络搭建，损失函数定义、优化、训练。下面我们将逐一用代码实战讲解，为了减少代码冗余，大家把代码按照顺序复制就能实现。至于数据集，点击，大家自取。

一、数据输入

代码：

import torch
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# 一、读入数据
# 1. 加载数据
data = pd.read_csv('boston.csv')
X = data.iloc[:, :-1]  # 所有列除最后一列作为特征
y = data.iloc[:, -1]   # 最后一列作为目标值


# 3. 划分数据集（保持类别分布）
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,        # 测试集占20%
    random_state=42,      # 固定随机种子
    stratify=y if len(y.unique())<10 else None  # 分类问题才分层
)

# 4. 验证划分结果
print(f"训练集形状: {X_train.shape}, 测试集形状: {X_test.shape}")
print(f"训练集目标分布:\n{pd.Series(y_train).value_counts(normalize=True)}")
print(f"测试集目标分布:\n{pd.Series(y_test).value_counts(normalize=True)}")

这是代码的第一个模块，进行数据处理，这个可以作为一个通用的模板。过程氛围三个：

使用 pandas 读入数据

划分特征 X ,和分类或者回归数值 y

划分训练集和测试集

二、网络搭建

代码：

class Net(torch.nn.Module):
    def __init__(self,n_feature,n_output):       # 初始化参数
        super(Net, self).__init__()              # super 继承父类，方便使用其中的函数

        self.predict = torch.nn.Linear(n_feature, n_output) # 定义predict,一个线性函数，也就是回归模型
    # 前向传播
    def forward(self, x):
        out = self.predict(x)  # 计算结果
        return out

    # 初始化网络，第一个是特征的数量，第二个是输出类型的数量
net = Net(13,1)

定义网络，只有一个隐藏层的神经网络，线性关系.需要初始化参数，传入的特征数目和输出值的数目。继承父类是为了方便使用其中的方法，预测向前计算的核心就是 self.predict 这句，前向传播就调用这个方法，然后返回结果。net = Net(13,1) 初始化调用网络。

三、定义损失函数

# 三、定义损失函数,均方误差的损失函数
loss_func = torch.nn.MSELoss()

说是定义损失函数，我们一般研究搭建什么样的网络，损失函数一般根据自己的实际情况进行选择。此处我们选择均方误差的损失函数

四、定义优化器

# 四、定义优化器
optimizer = torch.optim.SGD(net.parameters(),lr=0.01)

优化器采用随机梯度下降算法,具体还是根据自己的情况选择。

五、训练与测试

1. 训练

# 五、训练过程 1000次
for i in range(1000):
    x_data = torch.tensor(X_train.values,dtype=torch.float32) # 把numpy 转化成 Tensor
    y_data = torch.tensor(Y_train.values,dtype=torch.float32)

    # 获取predict，注意在线性模式中，二维的输出，计算loss必须进行维度统一。
    pred = net.forward(x_data)
    pred = torch.squeeze(pred)

    # 计算损失函数
    loss = loss_func(pred, y_data) * 0.001

    # 调用优化器
    # st1. 把梯度归零
    optimizer.zero_grad()
    # 反向传播，优化参数
    loss.backward()
    # 优化好的参数进行网络更新
    optimizer.step()
    # 打印得带次数和loss
    print("item:{},loss:{}\n".format(i,loss))
    print("预测的前十个值：\n",pred[0:10])
    print("真实值：\n",y_data[0:10])

训练的过程很有说法。我们开始读入的数据是 numpy 格式或者是pandas中的格式，pytorch 并不能使用，我们需要把输入数据转化到可训练的 tensor 类型。然后调用前向传播 forward 进行计算，注意这里的维度可能变成二维的输出，会与下一步计算损失函数 loss 发生维度不匹配，因此需要降维。一般而言，维度是两个一维的数据计算 loss。

2. 损失函数

计算损失函数，还要设计到优化问题，步骤如下：

初步前向传播，获得输出，维度统一，计算损失函数。optimizer.zero_grad()

选择优化函数，梯度归零。

后向传播。loss.backward()

优化器更新参数.optimizer.step()

我们把训练的损失函数的值，以及前十个预测数据打印出来和标准数据对比，如图：

图 1 训练结果

从结果中可以看出，我们的预测值与真实值之间的差异很大，这种情况叫做欠拟合。为了解决这种方法，通常采取：

加大迭代次数，1000 次改成10000次.

减少学习率

减小 loss,真实的loss还需要乘以相应的倍数还原，用于作图可视化。

3.测试

    x_data = torch.tensor(X_test.values,dtype=torch.float32) # 把numpy 转化成 Tensor
    y_data = torch.tensor(Y_test.values,dtype=torch.float32)
    # 获取predict，注意在线性模式中，二维的输出，计算loss必须进行维度统一。
    pred = net.forward(x_data)
    pred = torch.squeeze(pred)
    # 计算损失函数
    loss = loss_func(pred, y_data) * 0.001
    # 打印得带次数和loss
    print("item:{},loss:{}\n".format(i,loss))

测试和训练差不多，数据 tensor 化，使用训练集的数据。模型的数据已经生成，所以只需要前向传播生成预测数据就行。为了评价预测结果的稳定性和精准性，还需要调用损失函数loss，来预测，在此之前少不了统一维度这一步骤。

4.模型生成与调用

保存模型：

# 保存模型
# 方法一，全部保存
torch.save(net,"model/model.pkl")
# # 使用
# torch.load("model/model")
#
# # 第二种方法,只保存参数
# torch.save(net.state_dict(),"params.pkl")
# # 调用前需要定义网络结构
# torch.load_state_dict(torch.load("params.pkl"))

第一个方法保存的内容要丰富一点，保存了网络的结构，第二个方法仅仅保存了训练好模型的参数。保存模型的文件夹路径一定要存在并且正确。

调用模型：

import torch
import numpy as np
import pandas as pd
import re

from sklearn.model_selection import train_test_split


class Net(torch.nn.Module):
    def __init__(self,n_feature,n_output):       # 初始化参数
        super(Net, self).__init__()              # super 继承父类，方便使用其中的函数
        # 你可以多调用两层，每层计算之后都处理一下。
        self.predict = torch.nn.Linear(n_feature, n_output) # 定义predict,一个线性函数，也就是回归模型
    # 前向传播
    def forward(self, x):
        out = self.predict(x)  # 计算结果
        return out

    # 初始化网络，第一个是特征的数量，第二个是输出类型的数量

# 第一步 解析数据
data = pd.read_csv('../boston.csv')
X = data.iloc[:, :-1]  # 所有列除最后一列作为特征
Y = data.iloc[:, -1]   # 最后一列作为目标值

X_column = data.shape[1] - 1
Y_column = 1
print("x 和 y 的列数",X_column,Y_column)

# 3. 划分数据集（保持类别分布）
X_train, X_test, Y_train, Y_test = train_test_split(
    X,
    Y,
    test_size=0.2,        # 测试集占20%
    random_state=42,      # 固定随机种子
    stratify=Y if len(Y.unique())<10 else None  # 分类问题才分层
)

# 第二步加载模型
net = torch.load("model.pkl")
# 第三步，损失函数
loss_func=torch.nn.MSELoss()

# 测试的过程，直接复制训练的过程
x_data = torch.tensor(X_test.values,dtype=torch.float32) # 把numpy 转化成 Tensor
y_data = torch.tensor(Y_test.values,dtype=torch.float32)
# 获取predict，注意在线性模式中，二维的输出，计算loss必须进行维度统一。
pred = net.forward(x_data)
pred = torch.squeeze(pred)
# 计算损失函数
loss_test = loss_func(pred, y_data) * 0.001
# 优化好的参数进行网络更新
print("loss:{}\n".format(loss_test))

此处采用第一种方法，调用模型的步骤：

定义该网络结构，不用初始化网络。

使用numpy 和 pandas 读入数据进行数据预处理，方式很多，收集模板就行。

加载模型 net = torch.load("model.pkl") ,文件路径要正确。

定义损失函数

测试

我们发现，调用模型，就是直接预测，省去了训练的过程。因为我们训练的过程就是为了调整参数，保存的模型就已经把训练好的参数保存下来，直接调用就行。我们这里的数据太少，只有 500 多条，远远不够，但作为一个学习的例子却是一个好实例。
最后，现在电商太卷了，PDD平台又不给我推流，希望大家看完觉得有帮助，帮我进店看看，点击，可能需要登录PDD，万分感谢！

pytorch实战波斯顿房价回归模型