动手学深度学习:实战Kaggle房价预测
作者:admin | 分类:房产资讯 | 浏览:22 | 时间:2023-12-09 22:07:58实战kaggle预测房价
之前我们学习了一些训练深度网络的基本工具和网络正则化的技术（如权重衰减、暂退法等）。本次我们将通过Kaggle比赛，将所学知识付诸实践。Kaggle的房价预测比赛是一个很好的起点。此数据集由Bart de Cock于2011年收集 (De Cock, 2011)， 涵盖了2006-2010年期间亚利桑那州埃姆斯市的房价。这个数据集是相当通用的，不会需要使用复杂模型架构。它比哈里森和鲁宾菲尔德的波士顿房价 数据集要大得多，也有更多的特征。
下载和缓存数据集
这里我们实现几个函数来方便下载数据。首先，我们建立字典DATA_HUB， 它可以将数据集名称的字符串映射到数据集相关的二元组上， 这个二元组包含数据集的url和验证文件完整性的sha-1密钥。所有类似的数据集都托管在地址为DATA_URL的站点上。
# 导入必要的库
import hashlib # 提供哈希函数的库，用于校验文件的完整性
import os # 提供与操作系统相关的功能，例如文件路径处理
import tarfile # 用于解压 tar 文件的库
import zipfile # 用于解压 zip 文件的库
import requests # 用于发送 HTTP 请求的库
# 定义一个全局变量 DATA_HUB，用于存储数据集相关信息
# 这个字典可能包含数据集名称、文件名、下载链接等信息
# 在这里，字典是空的，但可能在后续的代码中被填充
DATA_HUB = dict()
# 定义一个全局变量 DATA_URL，表示数据集的基础 URL
# 后续的数据集下载链接可能基于此 URL 进行拼接
DATA_URL = 'http://d2l-data.s3-accelerate.amazonaws.com/'下面的download函数用来下载数据集， 将数据集缓存在本地目录（默认情况下为../data）中， 并返回下载文件的名称。如果缓存目录中已经存在此数据集文件，并且其sha-1与存储在DATA_HUB中的相匹配， 我们将使用缓存的文件，以避免重复的下载。
def download(name, cache_dir=os.path.join('..', 'data')): # @save
"""下载一个DATA_HUB中的文件，返回本地文件名"""
# 确保指定的数据集名称在 DATA_HUB 中存在，否则抛出断言错误
assert name in DATA_HUB, f"{name} 不存在于 {DATA_HUB}"
# 获取数据集的下载链接和 SHA-1 哈希值
url, sha1_hash = DATA_HUB[name]
# 确保缓存目录存在，如果不存在则创建
os.makedirs(cache_dir, exist_ok=True)
# 构造本地文件名，使用数据集的下载链接的最后一部分作为文件名
fname = os.path.join(cache_dir, url.split('/')[-1])
# 如果本地文件已经存在，并且其 SHA-1 哈希值与预期一致，则直接返回文件名
if os.path.exists(fname):
sha1 = hashlib.sha1()
with open(fname, 'rb') as f:
while True:
data = f.read(1048576) # 每次读取1MB的数据
if not data:
break
sha1.update(data)
if sha1.hexdigest() == sha1_hash:
return fname # 命中缓存
# 如果本地文件不存在或者哈希值不一致，则从网络上下载文件
print(f'正在从{url}下载{fname}...')
r = requests.get(url, stream=True, verify=True)
# 将下载的内容写入本地文件
with open(fname, 'wb') as f:
f.write(r.content)
# 返回下载好的本地文件名
return fname
def download_extract(name, folder=None): # @save
"""下载并解压zip/tar文件"""
# 使用 download 函数下载指定名称的文件，并获取下载后的本地文件名
fname = download(name)
# 获取文件的目录和扩展名
base_dir = os.path.dirname(fname)
data_dir, ext = os.path.splitext(fname)
# 根据文件的扩展名选择相应的解压方式
if ext == '.zip':
fp = zipfile.ZipFile(fname, 'r')
elif ext in ('.tar', '.gz'):
fp = tarfile.open(fname, 'r')
else:
# 如果不是zip/tar文件，抛出错误
assert False, '只有zip/tar文件可以被解压缩'
# 将文件解压到指定的目录（默认为文件所在目录）
fp.extractall(base_dir)
# 返回解压后的数据集目录
return os.path.join(base_dir, folder) if folder else data_dir这个函数的主要功能是下载指定数据集文件并解压缩，返回解压缩后的数据集目录路径。如果文件是zip格式，则使用 zipfile 库解压；如果文件是tar格式，则使用 tarfile 库解压。如果文件不是zip/tar格式，则抛出错误。
def download_all(): # @save
"""下载DATA_HUB中的所有文件"""
# 遍历 DATA_HUB 中的所有数据集名称，并依次调用 download 函数下载
for name in DATA_HUB:
download(name)这个函数的目的是遍历 DATA_HUB 中的所有数据集名称，并依次调用 download 函数下载相应的数据集。
访问和读取数据集
注意，竞赛数据分为训练集和测试集。每条记录都包括房屋的属性值和属性，如街道类型、施工年份、屋顶类型、地下室状况等。这些特征由各种数据类型组成。例如，建筑年份由整数表示，屋顶类型由离散类别表示，其他特征由浮点数表示。这就是现实让事情变得复杂的地方：例如，一些数据完全丢失了，缺失值被简单地标记为“NA”。每套房子的价格只出现在训练集中（毕竟这是一场比赛）。我们将希望划分训练集以创建验证集，但是在将预测结果上传到Kaggle之后， 我们只能在官方测试集中评估我们的模型。
开始之前，我们将使用pandas读入并处理数据。
%matplotlib inline
import numpy as np
import pandas as pd
import torch
from torch import nn
from d2l import torch as d2l为方便起见，我们可以使用上面定义的脚本下载并缓存Kaggle房屋数据集。
# 向 DATA_HUB 字典中添加 'kaggle_house_train' 数据集的信息
DATA_HUB['kaggle_house_train'] = (
DATA_URL + 'kaggle_house_pred_train.csv', # 数据集下载链接
'585e9cc93e70b39160e7921475f9bcd7d31219ce' # 数据集文件的 SHA-1 哈希值
)
# 向 DATA_HUB 字典中添加 'kaggle_house_test' 数据集的信息
DATA_HUB['kaggle_house_test'] = (
DATA_URL + 'kaggle_house_pred_test.csv', # 数据集下载链接
'fa19780a7b011d9b009e8bff8e99922a8ee2eb90' # 数据集文件的 SHA-1 哈希值
)我们使用pandas分别加载包含训练数据和测试数据的两个CSV文件。
train_data = pd.read_csv(download('kaggle_house_train'))
test_data = pd.read_csv(download('kaggle_house_test'))训练数据集包括1460个样本，每个样本80个特征和1个标签， 而测试数据集包含1459个样本，每个样本80个特征。
print(train_data.shape)
print(test_data.shape)
让我们看看前四个和最后两个特征，以及相应标签（房价）。
# 打印 DataFrame train_data 中的特定行和列
# 选取第 0 到 3 行（不包括第 4 行），以及第 0、1、2、3、-3、-2、-1 列
print(train_data.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]])
我们可以看到，在每个样本中，第一个特征是ID， 这有助于模型识别每个训练样本。虽然这很方便，但它不携带任何用于预测的信息。因此，在将数据提供给模型之前，我们将其从数据集中删除。
# 使用 concat 函数将训练集和测试集的特征数据合并成一个新的 DataFrame all_features
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))
数据预处理
# 获取数值类型特征的列索引
numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index
# 对数值类型的特征进行标准化，计算 (x - mean) / std
all_features[numeric_features] = all_features[numeric_features].apply(
lambda x:(x - x.mean()) / (x.std())
)
# 标准化后，每个数值类型的特征的均值变为0，所以可以直接用0来替换缺失值
all_features[numeric_features] = all_features[numeric_features].fillna(0)
# 使用 get_dummies 函数对离散数值进行独热编码
# 参数 dummy_na=True 表示将缺失值视为有效的特征值，并为其创建指示符特征
all_features = pd.get_dummies(all_features, dummy_na=True)
# 将all_features中bool类型转变为数值类型，False为0，True为1
all_features = all_features.astype('float32')
# 输出独热编码后的特征数据的形状
all_features
最后，通过values属性，我们可以 从pandas格式中提取NumPy格式，并将其转换为张量表示用于训练。
# 获取训练集样本数量
n_train = train_data.shape[0]
# 从独热编码后的特征数据中提取训练集和测试集的特征
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_labels = torch.tensor(
train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)
训练
首先，我们训练一个带有损失平方的线性模型。显然线性模型很难让我们在竞赛中获胜，但线性模型提供了一种健全性检查， 以查看数据中是否存在有意义的信息。如果我们在这里不能做得比随机猜测更好，那么我们很可能存在数据处理错误。如果一切顺利，线性模型将作为基线（baseline）模型， 让我们直观地知道最好的模型有超出简单的模型多少。
# 定义均方误差损失函数
loss = nn.MSELoss()
# 获取训练集特征的列数
in_features = train_features.shape[1]
# 定义一个简单的线性回归模型
def get_net():
# 使用nn.Sequential定义一个线性回归模型
net = nn.Sequential(nn.Linear(in_features, 1)) # 输入特征数为in_features，输出特征数为1
# 返回定义好的模型
return net
def log_rmse(net, features, labels):
# 使用模型进行预测
predictions = net(features)
# 为了在取对数时进一步稳定值，将小于1的预测值设置为1
cllipped_preds = torch.clamp(predictions, 1, float('inf')) # 将predictions中的元素限制在1和float('inf')之间，clamp的含义限制
# 计算对数均方根误差
rmse = torch.sqrt(loss(torch.log(cllipped_preds),
torch.log(labels)))
# 返回均方根误差的数值
return rmse.item() # item()函数返回一个元素张量里的元素与前面的部分不同，我们的训练函数将借助Adam优化器。Adam优化器的主要吸引力在于它对初始学习率不那么敏感。
def train(net, train_features, train_labels, test_features, test_labels,
num_epochs, learning_rate, weight_deacy, batch_size):
"""
训练线性回归模型
参数:
net: 线性回归模型
train_features: 训练集特征
train_labels: 训练集标签
test_features: 测试集特征
test_labels: 测试集标签
num_epochs: 训练的轮数
learning_rate: 学习率
weight_decay: 权重衰减（L2正则化）的权重
batch_size: 批量大小
返回:
train_ls: 训练集的对数均方根误差列表
test_ls: 测试集的对数均方根误差列表
"""
# 初始化空列表，用于存储每轮训练后的训练集和测试集的对数均方根误差
train_ls, test_ls = [], []
# 将训练集的特征和标签组合成迭代器
train_iter = d2l.load_array((train_features, train_labels), batch_size)
# 使用 Adam 优化算法，lr 表示学习率，wd 表示权重衰减的权重
optimizer = torch.optim.Adam(net.parameters(),
lr = learning_rate,
weight_decay = weight_decay)
# 训练循环，迭代 num_epochs 轮
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.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
K折交叉验证
我们首先需要定义一个函数, 在 折交叉验证过程中返回第 折的数据。具体地说,它选择第 个切片作为验证数据, 其余部分作为训练数据。注意, 这并不是处理数据的最有效方法, 如果我们的数据集大得多, 会有其他解决办法。
def get_k_fold_data(k, i, X, y):
"""
获取第 i 折的交叉验证数据
参数:
k: 折数
i: 当前折的索引
X: 特征数据
y: 标签数据
返回:
X_train, y_train: 训练集的特征和标签
X_valid, y_valid: 验证集的特征和标签
"""
# 确保折数大于1
assert k > 1
# 计算每一折的大小
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
def k_fold(k, X_train, y_train, num_epochs, learning_rate, weight_decay,
batch_size):
"""
使用 k 折交叉验证进行模型训练和评估
参数:
k: 折数
X_train: 训练集特征
y_train: 训练集标签
num_epochs: 训练的轮数
learning_rate: 学习率
weight_decay: 权重衰减（L2正则化）的权重
batch_size: 批量大小
返回:
train_l_sum / k: k 折交叉验证的平均训练集对数均方根误差
valid_l_sum / k: k 折交叉验证的平均验证集对数均方根误差
"""
# 初始化训练集和验证集的对数均方根误差之和
train_l_sum, valid_l_sum = 0, 0
# 遍历 k 折
for i in range(k):
# 获取第 i 折的训练集和验证集数据
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) # *data表示data是一个元组，元组中的元素分别赋值给train函数的参数
# 累加当前折的对数均方根误差
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}')
# 返回 k 折交叉验证的平均训练集和验证集的对数均方根误差
return train_l_sum / k, valid_l_sum / k
模型选择
在本例中, 我们选择了一组未调优的超参数, 并将其留给读者来改进模型。找到一组调优的超参数可能需要时间, 这取决于一个人优化了多少变量。有了足够大的数据集和合理设置的超参数, 折交叉验证往往对多次测试具有相当的稳定性。然而, 如果我们尝试了不合理的超参数，我们可能会发现验证效果不再代表真正的误差。
# 设置超参数
k, num_epochs, lr, weight_decay, batch_size = 5, 100, 5, 0, 64
# 执行k折交叉验证
train_l, valid_l = k_fold(k, train_features, train_labels, num_epochs, lr,
weight_decay, batch_size)
# 打印平均训练集和验证集的对数均方根误差
print(f'{k}-折验证: 平均训练log rmse: {float(train_l):f}, '
f'平均验证log rmse: {float(valid_l):f}')
请注意, 有时一组超参数的训练误差可能非常低, 但 折交叉验证的误差要高得多, 这表明模型过拟合了。在整个训练过程中, 我们希望监控训练误差和验证误差这两个数字。较少的过拟合可能表明现有数据可以支撑一个更强大的模型, 较大的过拟合可能意味着我们可以通过正则化技术来获益。
在这里，调参侠上线(ﾉ*>∀<)ﾉ，改变简单的线性模型，定义一个多层感知机：
# 获取训练集特征的列数
in_features = train_features.shape[1]
# 定义一个简单的线性回归模型
def get_net():
# 使用nn.Sequential定义一个线性回归模型
net = nn.Sequential(nn.Linear(in_features, 156),
nn.ReLU(),
nn.Linear(156, 1))
# 定义权重初始化函数，这里使用正态分布进行初始化
def init_weight(m):
if type(m) == nn.Linear:
nn.init.normal_(m.weight, std=0.01) # 对权重进行正态分布初始化，标准差为0.01
# 使用apply函数将初始化函数应用到神经网络模型上
net.apply(init_weight)
# 返回定义好的模型
return net
loss = nn.MSELoss()# 设置超参数
k, num_epochs, lr, weight_decay, batch_size = 10, 1000, 3, 3, 64
# 执行k折交叉验证
train_l, valid_l = k_fold(k, train_features, train_labels, num_epochs, lr,
weight_decay, batch_size)
# 打印平均训练集和验证集的对数均方根误差
print(f'{k}-折验证: 平均训练log rmse: {float(train_l):f}, '
f'平均验证log rmse: {float(valid_l):f}')
从上图来看，个人认为，多层感知机比线性模型需要更多次的训练和更多的数据，不然很容易过拟合
提交Kaggle预测
既然我们知道应该选择什么样的超参数, 我们不妨使用所有数据对其进行训练（而不是仅使用交叉验证中使用的 的数据）。然后，我们通过这种方式获得的模型可以应用于测试集。将预测保存在CSV文件中可以简化将结果上传到Kaggle的过程。
def train_and_pred(train_features, test_features, train_labels, test_data,
num_epochs, lr, weight_decay, batch_size):
"""
训练模型，生成预测，并输出预测结果到文件
参数:
train_features: 训练集特征
test_features: 测试集特征
train_labels: 训练集标签
test_data: 测试数据集
num_epochs: 训练的轮数
lr: 学习率
weight_decay: 权重衰减（L2正则化）的权重
batch_size: 批量大小
"""
# 创建线性回归模型
net = get_net()
# 进行模型训练，获取训练集的对数均方根误差列表
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])
submission = pd.concat([test_data['Id'], test_data['SalePrice']], axis=1)
# 将预测结果输出到 CSV 文件
submission.to_csv('submission.csv', index=False)
train_and_pred(train_features, test_features, train_labels, test_data,
num_epochs, lr, weight_decay, batch_size)
