秃姐学AI系列之：实战Kaggle比赛：预测房价

最新推荐文章于 2024-08-08 14:28:23 发布

不是很强但是很秃

最新推荐文章于 2024-08-08 14:28:23 发布

阅读量1k

点赞数 9

分类专栏：神经网络文章标签：人工智能机器学习深度学习算法

本文链接：https://blog.csdn.net/m0_62415132/article/details/140998889

版权

神经网络专栏收录该内容

4 篇文章 0 订阅

订阅专栏

使用pandas读入并处理数据

%matplotlib inline
import numpy as np
import pandas as pd
import torch
from torch import nn
from d2l import torch as d2l

DATA_HUB['kaggle_house_train'] = (  #@save
    DATA_URL + 'kaggle_house_pred_train.csv',
    '585e9cc93e70b39160e7921475f9bcd7d31219ce')
 
DATA_HUB['kaggle_house_test'] = (  #@save
    DATA_URL + 'kaggle_house_pred_test.csv',
    'fa19780a7b011d9b009e8bff8e99922a8ee2eb90')

train_data = pd.read_csv(download('kaggle_house_train'))
test_data = pd.read_csv(download('kaggle_house_test'))
print(train_data.shape)
print(test_data.shape)
print(train_data.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]])

数据预处理

1、去除数据集中第一列无用的ID

all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))

.iloc[:, 1:-1]：表示选择所有行（:）和从第1列到倒数第二列的列（1:-1）。这里的索引是基于位置的，第一列的索引是0，所以1:-1表示跳过第一列，同时也不包括最后一列（因为iloc()函数左闭右开），因为这里的最后一列是labels。
test_data.iloc[:, 1:]：从test_data中选择了除了第一列之外的所有列和行。.iloc[:, 1:]同样是基于位置的索引，表示选择所有行（:）和从第1列到最后一列的所有列（1:）。这里也是跳过了第一列，但是包括了最后一列。

这样的操作常见于数据预处理阶段，当你想要统一处理训练集和测试集中的特征时，你可以先将它们合并起来，进行必要的处理，然后再分开为训练集和测试集。

2、在数据预处理阶段处理数值型特征：首先，它将这些特征标准化（即让数据符合均值为0、标准差为1的分布），然后处理缺失值，将它们设置为0。

numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index
all_features[numeric_features] = all_features[numeric_features].apply(
    lambda x: (x - x.mean()) / (x.std()))
# 在标准化数据之后，所有均值消失，因此我们可以将缺失值设置为0
all_features[numeric_features] = all_features[numeric_features].fillna(0)

all_features.dtypes：获得每一列数据的类型进行返回
all_features.dtypes != ‘object’：判断各列数据是否不为object对象。不为则返回True，是则返回False
all_features.dtypes[all_features.dtypes != ‘object’]：把数据类型不为object的各列取出来
all_features.dtypes[all_features.dtypes != 'object'].index：取出各列的列名
apply()函数对每一个特征（列）应用了给定的函数，这里的lambda x: (x - x.mean()) / (x.std())是一个匿名函数，用于计算标准化值 -> 使用的是减去均值后除以标准差的方法，这种处理使得处理后的数据的均值为0，标准差为1。
fillna(0)：在数据标准化之后，这行代码将选定特征中的所有缺失值（NaN）替换为0。经过标准化之后，均值为0，因此用0来填充缺失值在某种程度上不会对数据分布产生太大影响。

这是在Kaggle竞赛，可以直接获得测试数据，在实际中可能不能和训练数据同步获得测试数据

若无法获得测试数据，则可根据训练数据计算均值和标准差

3、处理离散值，用单热编码替换他们

all_features = pd.get_dummies(all_features, dummy_na=True)
all_features.shape

out:[2919，331]

这样处理完会发现feature变得大了很多

get_dummies：转为one-hot编码
“Dummy_na=True：”将 “na”（缺失值）视为有效的特征值，并为其创建指示符特征。它让我们不忽视那些空白的地方，而是把它们也当成一种特殊的信息来处理。

4、从pandas格式中提取Numpy格式，并将其转换为张量表示

# 获取train_data（训练数据集）中样本的数量
n_train = train_data.shape[0]
# 把所有特征（all_features）中的前n_train个样本（对应训练数据集的大小）
# 转换成了PyTorch的张量——tensor
train_features = torch.tensor(
    all_features[:n_train].values, dtype=torch.float32)
test_features = torch.tensor(
    all_features[n_train:].values, dtype=torch.float32)
# 将训练数据集train_data中的SalePrice列转换成了PyTorch张量，作为训练标签
train_labels = torch.tensor(
    train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)

train_data.shape[0]返回的是train_data的行数，也就是训练集中样本的总数。
python默认numpy是float64，转化成float32，这是大多数pytorch模型预测用的数据类型
.reshape(-1, 1)：确保了标签的形状是一个二维数组，其中有n_train行和1列，这通常是用于回归任务的标准格式。

训练

loss = nn.MSELoss()
in_features = train_features.shape[1]
 
def get_net():
    net = nn.Sequential(nn.Linear(in_features,1))
    return net

def log_rmse(net, features, labels):
    # 为了在取对数时进一步稳定该值，将小于1的值设置为1
    clipped_preds = torch.clamp(net(features), 1, float('inf'))
    rmse = torch.sqrt(loss(torch.log(clipped_preds),
                           torch.log(labels)))
    return rmse.item()

在房价预测中，因为不同的房子价格差异太大了，导致如果按照之前简单的：预测标签-真实标签就会导致贵价的房子权重更大，解决这个问题的一种方法是用价格预测的对数来衡量差异——log_rmse：将预测值和真实值都开个根号，然后做正常的线性回归

clipped_preds = torch.clamp(net(features), 1, float('inf'))：使用模型net对特征features进行预测。然后使用torch.clamp函数确保所有的预测值至少为1（将小于1的所有预测值设置为1）。这样做的目的是为了后面取对数时避免数学错误（因为对0或负数取对数是未定义的）。
rmse = torch.sqrt(loss(torch.log(clipped_preds), torch.log(labels)))：对预测值 clipped_preds 和真实值 labels 都取对数。丢到MSE里面
sqrt()：开根号

设置Adam优化器

def train(net, train_features, train_labels, test_features, test_labels,
          num_epochs, learning_rate, weight_decay, batch_size):
    # 初始化损失记录列表
    train_ls, test_ls = [], []
    # 将训练数据和标签组合成一个可迭代的数据集，batch_size参数控制了每次迭代提供给模型的样本数量
    train_iter = d2l.load_array((train_features, train_labels), batch_size)
    # 这里使用的是Adam优化算法
    # net.parameters()提供了模型中需要训练的参数
    # lr和weight_decay分别设置了学习率和权重衰减（这有助于防止过拟合）。
    optimizer = torch.optim.Adam(net.parameters(),
                                 lr = learning_rate,
                                 weight_decay = weight_decay)
    for epoch in range(num_epochs):
        for X, y in train_iter:
            # 清除之前的梯度
            optimizer.zero_grad()
            # 计算预测标签与实际值之间的损失
            l = loss(net(X), y)
            # 反向传播计算梯度
            l.backward()
            # 根据计算的梯度计算模型参数
            optimizer.step()

        # 评估模型在训练集和测试集上的性能，并将这些值追加到train_ls和test_ls
        train_ls.append(log_rmse(net, train_features, train_labels))
        # 如果提供了测试标签，也会计算并记录模型在测试集上的损失。
        if test_labels is not None:
            test_ls.append(log_rmse(net, test_features, test_labels))
    return train_ls, test_ls

Adam相较于SGD的优势是，它对于学习率没有那么敏感

这个train函数概述了一个典型的训练过程，包括数据准备、优化器选择、反复训练模型以及评估模型性能的步骤。通过记录训练和测试损失，我们可以观察模型随着时间的训练是如何改进的。

K折交叉验证

下面这段函数简单来说就是构造一份用于交叉验证的数据集，包括特征数据集、标签数据集、验证特征数据集、验证标签数据集

def get_k_fold_data(k, i, X, y):
    # 这确保了至少要将数据分成两份，因为进行交叉验证至少需要有一个训练集和一个验证集
    assert k > 1
    # 这计算了每一份数据的大小
    # X.shape[0]是数据中的样本总数（行数），除以k得到每份数据的样本数
    fold_size = X.shape[0] // k
    # 初始化训练集和验证集
    X_train, y_train = None, None
    for j in range(k):
        # 定义了当前份数据的索引范围
        idx = slice(j * fold_size, (j + 1) * fold_size)
        X_part, y_part = X[idx, :], y[idx]
        # 判断当前这份数据是否是验证集
        if j == i:
            X_valid, y_valid = X_part, y_part
        # 如果还没有为训练集添加任何数据，就把当前的这份数据作为训练集的开始部分
        elif X_train is None:
            X_train, y_train = X_part, y_part
        # 否则就用拼贴的方式加入训练集
        else:
            X_train = torch.cat([X_train, X_part], 0)
            y_train = torch.cat([y_train, y_part], 0)
    return X_train, y_train, X_valid, y_valid

参数：

k：数据分成几份
i：当前是第 i 份数据作为验证集
X：所有特征数据
y：所有标签数据

返回训练和验证误差的平均值

给定各种超参数，做一次k折交叉验证，返回平均损失和平均验证损失

def k_fold(k, X_train, y_train, num_epochs, learning_rate, weight_decay,
           batch_size):
    # 用来累加每一折（fold）训练集和验证集上的损失，后面会用这些累加的损失来计算平均损失
    train_l_sum, valid_l_sum = 0, 0
    for i in range(k):
        # 获取当前折的数据集和验证集
        data = get_k_fold_data(k, i, X_train, y_train)
        # 每一折都会使用一个新的模型，避免因为前一折而影响了这一折
        net = get_net()
        # 训练模型获取损失
        train_ls, valid_ls = train(net, *data, num_epochs, learning_rate,
                                   weight_decay, batch_size)
        # 当前折训练和验证的最后一次迭代损失加到累加器上
        train_l_sum += train_ls[-1]
        valid_l_sum += valid_ls[-1]
        # 可视化第一折损失
        if i == 0:
            d2l.plot(list(range(1, num_epochs + 1)), [train_ls, valid_ls],
                     xlabel='epoch', ylabel='rmse', xlim=[1, num_epochs],
                     legend=['train', 'valid'], yscale='log')
        print(f'折{i + 1}，训练log rmse{float(train_ls[-1]):f}, '
              f'验证log rmse{float(valid_ls[-1]):f}')
    # 返回平均损失
    return train_l_sum / k, valid_l_sum / k

提交你的Kaggle预测

def train_and_pred(train_features, test_features, train_labels, test_data,
                   num_epochs, lr, weight_decay, batch_size):
    net = get_net()
    # 由于这里不需要测试数据，test_features和test_labels参数被设为None
    train_ls, _ = train(net, train_features, train_labels, None, None,
                        num_epochs, lr, weight_decay, batch_size)
    # 绘制训练损失
    d2l.plot(np.arange(1, num_epochs + 1), [train_ls], xlabel='epoch',
             ylabel='log rmse', xlim=[1, num_epochs], yscale='log')
    # 打印最终训练损失
    print(f'训练log rmse：{float(train_ls[-1]):f}')
    # 将网络应用于测试集。
    preds = net(test_features).detach().numpy()
    # 将其重新格式化以导出到Kaggle
    test_data['SalePrice'] = pd.Series(preds.reshape(1, -1)[0])
    # 将预测结果添加到test_data的SalePrice列
    submission = pd.concat([test_data['Id'], test_data['SalePrice']], axis=1)
    # 创建一个新的DataFrame，包含Id和预测的SalePrice
    submission.to_csv('submission.csv', index=False)
# 将提交的DataFrame保存到CSV文件，这个文件可以上传到Kaggle进行评分
train_and_pred(train_features, test_features, train_labels, test_data,
               num_epochs, lr, weight_decay, batch_size)

不是很强但是很秃

关注

9
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
秃姐学AI系列之：实战Kaggle比赛：预测房价

在房价预测中，因为不同的房子价格差异太大了，导致如果按照之前简单的：预测标签-真实标签就会导致贵价的房子权重更大，解决这个问题的一种方法是用价格预测的对数来衡量差异——log_rmse：将预测值和真实值都开个根号，然后做正常的线性回归。2、在数据预处理阶段处理数值型特征：首先，它将这些特征标准化（即让数据符合均值为0、标准差为1的分布），然后处理缺失值，将它们设置为0。阶段，当你想要统一处理训练集和测试集中的特征时，你可以先将它们合并起来，进行必要的处理，然后。3、处理离散值，用单热编码替换他们。
复制链接

扫一扫