1、下载缓存数据集

建立字典DATA_HUB， 它可以将数据集名称的字符串映射到数据集相关的二元组上， 这个二元组包含数据集的url和验证文件完整性的sha-1密钥。 所有类似的数据集都托管在地址为DATA_URL的站点上。

下载文件后，转换为csv文件，便于后续的读取操作。 部分csv内容如下图

2、数据预处理

读取文件后，我们需要得到特征，并将其拼接起来。这里是有讲究的，训练集中的最后一列是price，而测试集无price列。我们需要去除id列和price列，提取出所需要的特征，同时要对缺失值进行相应的操作。

# 有些特征是没用的，比如id，我们将其从数据集中抹去，只保留需要的特征
# 这里拼接特征时有讲究，第一部分抹去了价格，是因为其价格相当于labely，不然就不是输入的特征了，而在test数据集中根本就没有价格这一列，所以不用多余操作
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))
# 读取特征后，进行数据的预处理
numeric_features=all_features.dtype[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)
# 对离散值，使用one-hot编码
# “Dummy_na=True”将“na”（缺失值）视为有效的特征值，并为其创建指示符特征
# get_dummies函数会自动实现独热编码。
all_features = pd.get_dummies(all_features, dummy_na=True)
print(all_features.shape)

# 提取values，并转换为tensor表示
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)

上述内容是对原数据进行预处理：

• 1、数值数据---进行归一化操作
• 2、缺失值---填充
• 3、离散值---one-hot编码

3、模型训练

• 选取均方误差函数
• 选取线性模型，单层线性回归拟合数据
• 对房价的变化，我们更加关注相对变化值，此处采取使用对数后的均方根误差

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()

def train(net, train_features, train_labels, test_features, test_labels,
          num_epochs, learning_rate, weight_decay, batch_size):
          #用于存放loss
    train_ls, test_ls = [], []
    # 传入训练集及batch_size
    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_ls

4、K折交叉验证

# k折交叉验证
# 选择第i个切片作为验证数据，其余部分作为训练数据。
# 返回训练集和验证集
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

# 得到训练和验证误差的平均值
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()
        # *表示解码，传入对应的四个参数。得到训练集和验证集的loss
        train_ls, valid_ls = train(net, *data, num_epochs, learning_rate,
                                   weight_decay, batch_size)
        # 这里取-1表示用最后一个epoch来代表这一次训练的效果
        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

注意上述使用中有个内置函数slice(),用于切片，其返回值就是一个slice对象，表示索引的起始、终点以及step