使用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.shapeout:[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_lsAdam相较于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)