# 如果没有安装pandas，请取消下一行的注释
# !pip install 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]])读数据并且看看特征
二、数据预处理
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))-
pd.concat()：这是Pandas库中的一个函数，用于将多个Pandas对象（如DataFrame或Series）沿着某个轴合并。在这个例子中，它默认沿着行来合并（即上下拼接），因为没有指定axis参数。 -
train_data.iloc[:, 1:-1]：从train_data（一个DataFrame）中选择了除了第一列和最后一列之外的所有列。.iloc[:, 1:-1]表示选择所有行（:）和从第1列到倒数第二列的列（1:-1）。这里的索引是基于位置的，第一列的索引是0，所以1:-1表示跳过第一列，同时也不包括最后一列。 -
test_data.iloc[:, 1:]：从test_data中选择了除了第一列之外的所有列和行。.iloc[:, 1:]同样是基于位置的索引，表示选择所有行（:）和从第1列到最后一列的所有列（1:）。这里也是跳过了第一列。
通过pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))，它实际上是将train_data的中间列和test_data的除第一列外的所有列上下合并起来。这样的操作常见于数据预处理阶段，比如当你想要统一处理训练集和测试集中的特征时，你可以先将它们合并起来，进行必要的处理，然后再分开为训练集和测试集。
# 若无法获得测试数据，则可根据训练数据计算均值和标准差
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)这段代码的目的是在数据预处理阶段处理数值型特征：首先，它将这些特征标准化（即让数据符合均值为0、标准差为1的分布），然后处理缺失值，将它们设置为0。让我们分步骤解释：
-
选取数值型特征：
numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index：这里筛选出了all_featuresDataFrame中所有的数值型特征。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，标准差为1。apply函数对每一个特征（列）应用了给定的函数，这里的lambda x: (x - x.mean()) / (x.std())是一个匿名函数，用于计算标准化值。
-
处理缺失值：
all_features[numeric_features] = all_features[numeric_features].fillna(0)：在数据标准化之后，这行代码将选定特征中的所有缺失值（NaN）替换为0。fillna(0)是Pandas中用于填充缺失值的函数，这里用0来替代所有缺失值，是基于这样的考虑：经过标准化之后，均值为0，因此用0来填充缺失值在某种程度上不会对数据分布产生太大影响。
# “Dummy_na=True”将“na”（缺失值）视为有效的特征值，并为其创建指示符特征
all_features = pd.get_dummies(all_features, dummy_na=True)
all_features.shape这段代码做了什么：
想象一下，我们有一堆表格数据，里面不仅有数字，还有很多文字，比如“颜色”这一列里写的是“红”、“蓝”、“绿”。但是，计算机在处理数据时，特别是在做数学计算的时候，它更喜欢数字而不是文字。所以，我们需要一个方法把这些文字转换成计算机更容易理解的数字。
这就是这段代码做的事情：它把所有的文字标签（比如“红”、“蓝”、“绿”）转换成了一系列的是或否问题（是红色吗？是蓝色吗？是绿色吗？），并用1和0来回答这些问题（1表示“是”，0表示“否”）。这样，原来的一列现在变成了好几列，每一列都代表一个颜色，里面填的是1或0。
而且，如果有的地方原来是空的，没有填写颜色，这个程序还会特别地为这些空白处也创建一列，标记那些原来没有填写的地方。这就是dummy_na=True这个设置的作用，它让我们不忽视那些空白的地方，而是把它们也当成一种特殊的信息来处理。
最后，all_features.shape这一行代码，就是告诉我们经过这番处理后，我们的表格有多大了，即有多少行多少列。这个变化主要是因为列的数量会增加，因为原来的一列文字现在变成了好几列数字。
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)-
获取训练数据的数量：
n_train = train_data.shape[0]：这行代码用来获取train_data（训练数据集）中样本的数量。train_data.shape[0]返回的是train_data的行数，也就是训练集中样本的总数。这个数量被赋值给变量n_train。
-
准备训练特征和测试特征：
train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32)：这里，我们把所有特征（all_features）中的前n_train个样本（对应训练数据集的大小）转换成了PyTorch的张量（tensor），这部分用作训练特征。dtype=torch.float32指定了数据的类型为32位浮点数，这是大多数PyTorch模型预期的数据类型。test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32)：同样地，我们把all_features中剩余的部分（即测试数据集）也转换成了PyTorch的张量，这部分用作测试特征。这样分割是因为all_features中先是放置了训练数据，然后是测试数据。
-
准备训练标签：
train_labels = torch.tensor(train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)：这行代码将训练数据集train_data中的SalePrice列（即我们想要模型预测的目标变量）转换成了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()-
输入参数：
net: 你的神经网络模型，用来对特征进行预测。features: 需要预测的特征数据。labels: 真实的标签数据，即真实值。
-
预测并限制预测值：
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都取对数。这是因为我们想计算的是对数均方根误差，它在评价预测精度时更加关注相对误差而非绝对误差。然后，使用某个损失函数（这里的loss需要在函数外部定义，通常是均方误差）来计算这两个对数值之间的差异，并取平方根得到RMSE。
-
返回结果：
return rmse.item()：最后，rmse.item()将RMSE的值从一个张量转换为Python的浮点数，并返回这个值。
def train(net, train_features, train_labels, test_features, test_labels,
num_epochs, learning_rate, weight_decay, batch_size):
train_ls, test_ls = [], []
train_iter = d2l.load_array((train_features, train_labels), batch_size)
# 这里使用的是Adam优化算法
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.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_lsadam优化器优势：对初始学习率不太敏感
-
初始化损失记录列表：
train_ls, test_ls = [], []：这两个列表用来记录每个训练周期（epoch）结束时，模型在训练集和测试集上的损失。
-
准备训练数据：
train_iter = d2l.load_array((train_features, train_labels), batch_size)：这里使用d2l.load_array（假设是一个辅助函数）将训练数据和标签组合成一个可迭代的数据集，batch_size参数控制了每次迭代提供给模型的样本数量。
-
设置优化器：
optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate, weight_decay=weight_decay)：选择Adam作为优化算法，net.parameters()提供了模型中需要训练的参数，lr和weight_decay分别设置了学习率和权重衰减（这有助于防止过拟合）。
-
训练过程：
- 在每个训练周期（epoch）内，模型会遍历所有的训练数据：
optimizer.zero_grad()：清除之前的梯度。l = loss(net(X), y)：计算预测和实际标签之间的损失。l.backward()：反向传播计算梯度。optimizer.step()：根据计算的梯度更新模型的参数。
- 在每个训练周期（epoch）内，模型会遍历所有的训练数据：
-
记录损失：
- 在每个周期结束时，使用
log_rmse函数（假设是一个自定义函数，用于计算对数均方根误差）来评估模型在训练集和测试集上的性能，并将这些值追加到train_ls和test_ls。
- 在每个周期结束时，使用
-
处理测试集：
- 如果提供了测试标签，也会计算并记录模型在测试集上的损失。这是通过
if test_labels is not None:这个条件判断实现的，确保只有当存在测试数据时才进行评估。
- 如果提供了测试标签，也会计算并记录模型在测试集上的损失。这是通过
-
返回结果：
return train_ls, test_ls：最后，函数返回记录了整个训练过程中模型在训练集和测试集上损失的两个列表。
简而言之，这个train函数概述了一个典型的训练过程，包括数据准备、优化器选择、反复训练模型以及评估模型性能的步骤。通过记录训练和测试损失，我们可以观察模型随着时间的训练是如何改进的。
四、k折交叉验证
def get_k_fold_data(k, i, X, y):
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-
输入参数：
k：把数据分成多少份（"折"）。i：当前是第几份数据作为验证集。X：所有的特征数据。y：所有的标签数据。
-
确保条件：
assert k > 1：这确保了至少要将数据分成两份，因为进行交叉验证至少需要有一个训练集和一个验证集。
-
计算每一份的大小：
fold_size = X.shape[0] // k：这计算了每一份数据的大小。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]：根据上面的索引，我们取出了一份数据作为本轮的X_part和y_part。
- 循环
-
决定哪份是验证集，哪些是训练集：
- 如果
j == i，这意味着当前的这份数据应该被用作验证集。 - 如果
X_train是None，也就是说我们还没有为训练集添加任何数据，我们就把当前的这份数据作为训练集的开始部分。 - 否则，我们将当前的这份数据添加（拼接）到训练集的后面。
- 如果
-
返回结果：
- 最后，函数返回了训练集（
X_train, y_train）和验证集（X_valid, y_valid）。
- 最后，函数返回了训练集（
简单来说，这个函数通过循环和判断，帮助我们从全部数据中，轮流挑出一份作为验证集，剩下的作为训练集，这样就可以在k折交叉验证中使用了。
def k_fold(k, X_train, y_train, num_epochs, learning_rate, weight_decay,
batch_size):
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-
初始化累加器：
train_l_sum, valid_l_sum = 0, 0：这两个变量用来累加每一折（fold）训练集和验证集上的损失，后面会用这些累加的损失来计算平均损失。
-
k折交叉验证循环：
for i in range(k):：这个循环遍历每一折，i是当前的折数。
-
获取当前折的数据：
data = get_k_fold_data(k, i, X_train, y_train)：这行调用前面定义的get_k_fold_data函数，获取当前折的训练数据和验证数据。
-
初始化网络：
net = get_net()：这里假设有一个get_net函数，用于获取（初始化）一个新的网络模型。每一折都会使用一个新的模型，避免前一折的训练结果影响后一折。
-
训练模型并获取损失：
train_ls, valid_ls = train(net, *data, num_epochs, learning_rate, weight_decay, batch_size)：这行调用train函数（需要你自己定义）来训练模型，并返回训练过程中的损失列表。train函数需要接收模型、数据、训练周期（epochs）、学习率、权重衰减（用于正则化）和批量大小作为参数。
-
累加最后一次迭代的损失：
train_l_sum += train_ls[-1]和valid_l_sum += valid_ls[-1]：将当前折训练和验证的最后一次迭代损失加到累加器上。
-
可视化第一折的训练和验证损失：
- 如果是第一折（
i == 0），则绘制训练和验证的损失图。这有助于可视化模型在训练过程中的表现。
- 如果是第一折（
-
打印当前折的结果：
- 打印当前折的训练和验证的对数均方根误差（log rmse）。这给出了模型在当前折上的性能指标。
-
计算并返回平均损失：
return train_l_sum / k, valid_l_sum / k：最后，函数返回所有折上的平均训练和验证损失。这两个平均损失给出了模型在整个k折交叉验证过程中的平均表现。
五、选择模型 参数调优
k, num_epochs, lr, weight_decay, batch_size = 5, 100, 5, 0, 64
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}')-
设置实验参数：
k, num_epochs, lr, weight_decay, batch_size = 5, 100, 5, 0, 64：这行代码设置了交叉验证和训练过程中需要的参数。k = 5：表示数据将被分成5份进行交叉验证。num_epochs = 100：表示每次训练时，数据将被遍历100次。lr = 5：学习率设置为5，控制着模型学习的速度。weight_decay = 0：权重衰减（正则化项）设置为0，表示不使用正则化来避免过拟合。batch_size = 64：每个小批量数据的大小设置为64。
-
执行k折交叉验证：
train_l, valid_l = k_fold(k, train_features, train_labels, num_epochs, lr, weight_decay, batch_size)：这行代码使用上面定义的参数执行k折交叉验证。train_features和train_labels是训练数据和标签。这个过程将返回在所有k个分割上的平均训练损失和平均验证损失。
-
打印结果：
print(f'{k}-折验证: 平均训练log rmse: {float(train_l):f}, 平均验证log rmse: {float(valid_l):f}')：最后，这行代码打印出k折交叉验证的结果，包括平均训练对数均方根误差（log rmse）和平均验证log rmse。这些指标可以帮助你评估模型在不同数据子集上的稳定性和性能。
六、提交
def train_and_pred(train_features, test_features, train_labels, test_data,
num_epochs, lr, weight_decay, 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)
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)-
初始化网络：
net = get_net()：创建或初始化一个神经网络模型。get_net函数的具体实现需要你根据模型的结构来定义。
-
训练模型：
train_ls, _ = train(net, train_features, train_labels, None, None, num_epochs, lr, weight_decay, batch_size)：使用train函数和提供的参数（包括训练特征、标签、训练周期、学习率等）来训练模型。由于这里不需要测试数据，test_features和test_labels参数被设为None。
-
绘制训练损失：
d2l.plot(np.arange(1, num_epochs + 1), [train_ls], xlabel='epoch', ylabel='log rmse', xlim=[1, num_epochs], yscale='log')：这行代码使用训练过程中记录的损失（log rmse）来绘制一个图表，显示模型随着时间（epoch）的训练损失变化。这有助于我们了解模型的学习进度和过拟合情况。
-
打印最终训练损失：
print(f'训练log rmse：{float(train_ls[-1]):f}')：打印出训练过程中最后一个epoch的对数均方根误差（log rmse），作为训练性能的一个指标。
-
预测测试集：
preds = net(test_features).detach().numpy()：使用训练好的模型对测试特征进行预测，然后将预测结果从PyTorch张量转换为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，这个DataFrame就是提交到Kaggle的格式。submission.to_csv('submission.csv', index=False)：将提交的DataFrame保存到CSV文件，这个文件可以上传到Kaggle进行评分。
1772
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
