《动手学深度学习》笔记1.11——实战Kaggle比赛：预测房价+详细代码讲解

目录

[0. 前言](#0. 前言)

原书正文

[1. 下载和缓存数据集](#1. 下载和缓存数据集)

[1.1 download() 下载数据集](#1.1 download() 下载数据集)

[1.2 download_extract() 解压缩](#1.2 download_extract() 解压缩)

[2. Kaggle 简介](#2. Kaggle 简介)

[3. 访问和读取数据集](#3. 访问和读取数据集)

[4. 数据预处理](#4. 数据预处理)

[5. 训练（核心难点）](#5. 训练（核心难点）)

[5.1 get_net() 定义模型-线性回归](#5.1 get_net() 定义模型-线性回归)

[5.2 log_rmse() 对数均方根误差](#5.2 log_rmse() 对数均方根误差)

[5.3 train() 核心函数](#5.3 train() 核心函数)

[6. K折交叉验证](#6. K折交叉验证)

[6.1 get_k_fold_data() 拿数据](#6.1 get_k_fold_data() 拿数据)

[6.2 k_fold() 返回训练误差](#6.2 k_fold() 返回训练误差)

[7. 模型选择（调参-重要操作）](#7. 模型选择（调参-重要操作）)

[8. 提交Kaggle预测](#8. 提交Kaggle预测)

[8.1 train_and_pred() 训出模型来预测](#8.1 train_and_pred() 训出模型来预测)

[8.2 上传.csv 看得分](#8.2 上传.csv 看得分)

[9. 小结](#9. 小结)

[10. 练习](#10. 练习)

---

0. 前言

• 课程全部代码（pytorch版）已上传到附件
• 本节的代码位置：chapter_multilayer-perceptrons/kaggle-house-price.ipynb
• 本节的视频链接：15 实战：Kaggle房价预测 + 课程竞赛：加州2020年房价预测【动手学深度学习v2】_哔哩哔哩_bilibili
• 整个pipeline：用最基础的线性回归，来熟悉比赛的全流程（pipeline）
• 如何读懂代码：一开始看代码有很多看不懂，一点一点问deepseek（不错的代码GPT）
• 用好GPT：其实GPT回答得并不易懂，用GPT来确认思路比较好
• 提问的例子（这行代码在本节的最后生成.csv预测房价结果那里）：

原书正文

之前几节我们学习了一些训练深度网络的基本工具和网络正则化的技术（如权重衰减、暂退法等）。 本节我们将通过Kaggle比赛，将所学知识付诸实践。 Kaggle的房价预测比赛是一个很好的起点。 此数据集由Bart de Cock于2011年收集 :cite:De-Cock.2011， 涵盖了2006-2010年期间亚利桑那州埃姆斯市的房价。 这个数据集是相当通用的，不会需要使用复杂模型架构。 它比哈里森和鲁宾菲尔德的波士顿房价 数据集要大得多，也有更多的特征。

本节我们将详细介绍数据预处理、模型设计和超参数选择。 通过亲身实践，你将获得一手经验，这些经验将有益数据科学家的职业成长。

1. 下载和缓存数据集

在整本书中，我们将下载不同的数据集，并训练和测试模型。 这里我们(实现几个函数来方便下载数据 )。 首先，我们建立字典DATA_HUB， 它可以将数据集名称的字符串映射到数据集相关的二元组上， 这个二元组包含数据集的url和验证文件完整性的sha-1密钥。 所有类似的数据集都托管在地址为DATA_URL的站点上。

import hashlib  # 计算SHA1哈希值
import os  # 与操作系统进行交互
import tarfile  # 处理.tar文件
import zipfile  # 处理.zip文件
import requests  # 发送HTTP请求

#@save
DATA_HUB = dict()  # 创建一个字典，用于存储数据集的URL和SHA1哈希值
DATA_URL = 'http://d2l-data.s3-accelerate.amazonaws.com/'

1.1 download() 下载数据集

下面的download函数用来下载数据集， 将数据集缓存在本地目录（默认情况下为../data）中， 并返回下载文件的名称。 如果缓存目录中已经存在此数据集文件，并且其sha-1与存储在DATA_HUB中的相匹配， 我们将使用缓存的文件，以避免重复的下载。

def download(name, cache_dir=os.path.join('..', 'data')):  #@save
    """下载一个DATA_HUB中的文件，返回本地文件名"""
    # name: 要下载的数据集的名称；cache_dir: 下载文件的缓存目录
    assert name in DATA_HUB, f"{name} 不存在于 {DATA_HUB}"  # 断言：判断为false的时候触发异常，直接报错
    url, sha1_hash = DATA_HUB[name]  # SHA-1曾广泛用于确保数据完整性（文件传输或存储前后的值来对比）
    os.makedirs(cache_dir, exist_ok=True)  # 创建缓存目录，如果目录已存在则忽略
    fname = os.path.join(cache_dir, url.split('/')[-1])  # 构建完整的本地文件路径
    if os.path.exists(fname):  # 如果文件已存在于本地
        sha1 = hashlib.sha1()  # 创建一个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)  # 发送GET请求下载文件
    with open(fname, 'wb') as f:  # 以二进制写入模式打开文件
        f.write(r.content)  # 将下载的内容写入文件
    return fname  # 返回下载后的文件名

1.2 download_extract() 解压缩

我们还需实现两个实用函数： 一个将下载并解压缩一个zip或tar文件， 另一个是将本书中使用的所有数据集从DATA_HUB下载到缓存目录中。

def download_extract(name, folder=None):  #@save
    """下载并解压zip/tar文件"""
    fname = download(name)  # 调用之前定义的download函数来下载文件
    base_dir = os.path.dirname(fname)  # 获取下载文件所在的目录
    data_dir, ext = os.path.splitext(fname)  # 分离文件名和扩展名
    if ext == '.zip':
        fp = zipfile.ZipFile(fname, 'r')  # 如果是.zip文件，则创建一个ZipFile对象用于解压
    elif ext in ('.tar', '.gz'):
        fp = tarfile.open(fname, 'r')  # 如果是.tar或.gz文件，则创建一个tarfile对象用于解压
    else:
        assert False, '只有zip/tar文件可以被解压缩'  # 如果文件既不是.zip也不是.tar或.gz，则抛出异常
    fp.extractall(base_dir)  # 解压文件到base_dir目录
    # 如果提供了folder参数，则返回base_dir与folder的组合路径，否则返回data_dir
    return os.path.join(base_dir, folder) if folder else data_dir  

def download_all():  #@save
    """下载DATA_HUB中的所有文件"""
    for name in DATA_HUB:
        download(name)  # 对DATA_HUB字典中的每个数据集名称，调用download函数下载文件

2. Kaggle 简介

Kaggle是一个当今流行举办机器学习比赛的平台， 每场比赛都以至少一个数据集为中心。 许多比赛有赞助方，他们为获胜的解决方案提供奖金。 该平台帮助用户通过论坛和共享代码进行互动，促进协作和竞争。 虽然排行榜的追逐往往令人失去理智： 有些研究人员短视地专注于预处理步骤，而不是考虑基础性问题。 但一个客观的平台有巨大的价值：该平台促进了竞争方法之间的直接定量比较，以及代码共享。 这便于每个人都可以学习哪些方法起作用，哪些没有起作用。 如果我们想参加Kaggle比赛，首先需要注册一个账户（见 :numref:fig_kaggle）。

:width:400px :label:fig_kaggle

在房价预测比赛页面（如 :numref:fig_house_pricing 所示）的"Data"选项卡下可以找到数据集。我们可以通过下面的网址提交预测，并查看排名：

House Prices - Advanced Regression Techniques | Kaggle

:width:400px :label:fig_house_pricing

3. 访问和读取数据集

注意，竞赛数据分为训练集和测试集。 每条记录都包括房屋的属性值和属性，如街道类型、施工年份、屋顶类型、地下室状况等。 这些特征由各种数据类型组成。 例如，建筑年份由整数表示，屋顶类型由离散类别表示，其他特征由浮点数表示。 这就是现实让事情变得复杂的地方：例如，一些数据完全丢失了，缺失值被简单地标记为"NA"。 每套房子的价格只出现在训练集中（毕竟这是一场比赛）。 我们将希望划分训练集以创建验证集，但是在将预测结果上传到Kaggle之后， 我们只能在官方测试集中评估我们的模型。 在 :numref:fig_house_pricing 中，"Data"选项卡有下载数据的链接。

开始之前，我们将[使用pandas读入并处理数据 ]， 这是我们在 :numref:sec_pandas中引入的。 因此，在继续操作之前，我们需要确保已安装pandas。 幸运的是，如果我们正在用Jupyter阅读该书，可以在不离开笔记本的情况下安装pandas。

# 如果没有安装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

为方便起见，我们可以使用上面定义的脚本下载并缓存Kaggle房屋数据集。

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

我们使用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.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]])  # 最后一个是真实房价（标签），得把它拿出来
print(test_data.iloc[0:4, [0, 1, 2, 3, -2, -1]])

我们可以看到，(在每个样本中，第一个特征是ID， ) 这有助于模型识别每个训练样本。 虽然这很方便，但它不携带任何用于预测的信息。 因此，在将数据提供给模型之前，(我们将其从数据集中删除)。

# 将train_data和test_data(实际是validate集)合并成all_features，方便下面算均值和方差
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))  # 第一列是ID，把它拿掉

4. 数据预处理

如上所述，我们有各种各样的数据类型。 在开始建模之前，我们需要对数据进行预处理。 首先，我们[将所有缺失的值替换为相应特征的平均值。 ]然后，为了将所有特征放在一个共同的尺度上， 我们(通过将特征重新缩放到零均值和单位方差来标准化数据)：

# 因为kaggle比赛有测试集，这里咱把train和test集拿到一起算均值和方差；如果是写论文，只能在训练集上拿均值
# pandas的object是python里的str
numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index  # 返回数据类型!=object的列索引
all_features[numeric_features] = all_features[numeric_features].apply(
    lambda x: (x - x.mean()) / (x.std()))  # 数值型数据标准化：均值为0，方差为1
# 在标准化数据之后，所有均值消失(均值已经是0啦），可将缺失值设置为0
all_features[numeric_features] = all_features[numeric_features].fillna(0)   # fillna(0)：将所有缺失值替换为0

接下来，我们[处理离散值。 ] 这包括诸如"MSZoning"之类的特征。 (我们用独热编码替换它们 )， 方法与前面将多类别标签转换为向量的方式相同 （请参见 :numref:subsec_classification-problem）（在softmax那节）。 例如，"MSZoning"包含值"RL"和"Rm"。 我们将创建两个新的指示器特征"MSZoning_RL"和"MSZoning_RM"，其值为0或1。 根据独热编码，如果"MSZoning"的原始值为"RL"， 则："MSZoning_RL"为1，"MSZoning_RM"为0。 pandas软件包会自动为我们实现这一点。

# get_dummies 函数通常用于将分类变量(categorical variables)转换为一系列的二进制（0和1）列，也称为独热编码
# "Dummy_na=True"将"na"（缺失值）视为有效的特征值，并为其创建指示符特征（一个额外的二进制列）
all_features = pd.get_dummies(all_features, dummy_na=True)
all_features.shape

可以看到此转换会将特征的总数量从79个增加到331个。 最后，通过values属性，我们可以 [从pandas格式中提取NumPy格式，并将其转换为张量表示]用于训练。

all_features = all_features.astype(float)  # 强制转换，原本的代码里没有这一行，报错np的'object'不能转成torch

n_train = train_data.shape[0]  # 获取 train_data 数据框的行数
train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32)  # train和test上面合并了
test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32)  # 预处理后，这里再拆回来
train_labels = torch.tensor(  # 测试集没有真实房价，需要咱来预测和提交，因此没有test_labels
    train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)  # 把train集的SalePrice列拿出来

5. 训练（核心难点）

首先，我们训练一个带有损失平方的线性模型。 显然线性模型很难让我们在竞赛中获胜，但线性模型提供了一种健全性检查， 以查看数据中是否存在有意义的信息。 如果我们在这里不能做得比随机猜测更好，那么我们很可能存在数据处理错误。 如果一切顺利，线性模型将作为基线（baseline）模型， 让我们直观地知道最好的模型有超出简单的模型多少。

5.1 get_net() 定义模型-线性回归

loss = nn.MSELoss()  # 均方误差损失
in_features = train_features.shape[1]  # 获取列（特征）数，331

def get_net():  # 咱就用最简单的单层线性回归
    net = nn.Sequential(nn.Linear(in_features,1))  # 331个输入，1个输出（预测的房价）
    return net

5.2 log_rmse() 对数均方根误差

def log_rmse(net, features, labels):  # 评估模型性能的指标：log rmse 对数均方根误差（衡量相对差异）
    # clamp 函数将预测值net(features)中的所有小于1的值都被设置为1  # inf代表无穷大（infinity的缩写）
    # 预测值（房价）用clamp剪裁到1至正无穷，到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()  # 返回计算得到的均方根误差  # .item() 方法用于从包含单个数值的张量中提取该数值

5.3 train() 核心函数

与前面的部分不同，[我们的训练函数将借助Adam优化器] （我们将在后面章节更详细地描述它）。 Adam优化器的主要吸引力在于它对初始学习率不那么敏感。

def train(net, train_features, train_labels, test_features, test_labels,  # 在本节里的test_features和labels
          num_epochs, learning_rate, weight_decay, batch_size): # 真实输入的都是valid_features和labels
    train_ls, test_ls = [], []  # 初始化训练集和测试（实际上是验证）集的损失列表
    train_iter = d2l.load_array((train_features, train_labels), batch_size)  # 迭代器，每次迭代返回一个batch
    # 这里使用的是Adam优化算法（以往常用的是小批量随机梯度下降SGD，Adam可以理解为比较平滑的SGD）
    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  # 在本节里，在训练调参期间test_ls实际输出的是valid_ls，k_fold()里调用
    # 最后的测试集预测用不上test_ls，函数里的test只是为了区别于train，真实的输入并不是test（这个思想很重要）

• 在本节里的train()函数的输入test_features&labels，实际上是是valid_features&labels
• 最后的测试集预测房价用不上test_ls，函数里的test只是为了区别于train，真实的输入并不是test（这个思想很重要，需要深入理解这个函数）

6. K折交叉验证

6.1 get_k_fold_data() 拿数据

本书在讨论模型选择的部分（ :numref:sec_model_selection） 中介绍了[K折交叉验证]， 它有助于模型选择和超参数调整。 我们首先需要定义一个函数，在𝐾𝐾折交叉验证过程中返回第𝑖𝑖折的数据。 具体地说，它选择第𝑖𝑖个切片作为验证数据，其余部分作为训练数据。 注意，这并不是处理数据的最有效方法，如果我们的数据集大得多，会有其他解决办法。

def get_k_fold_data(k, i, X, y):  # ：指定第i份作为验证集，其余的作为训练集
    assert k > 1  # 确保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:  # 如果当前折是第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)  # 沿着第 0 维（行）拼接训练集data
            y_train = torch.cat([y_train, y_part], 0)  # 拼接训练集label
    return X_train, y_train, X_valid, y_valid  # 返回训练集+验证集的data+label

6.2 k_fold() 返回训练误差

当我们在𝐾折交叉验证中训练𝐾次后，[返回训练和验证误差的平均值]。

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):  # 做k次
        data = get_k_fold_data(k, i, X_train, y_train)  # 每次拿到第i折
        net = get_net()
        train_ls, valid_ls = train(net, *data, num_epochs, learning_rate,  # *data输入的是train和valid数据
                                   weight_decay, batch_size)  # 每次训练拿到两个loss
        train_l_sum += train_ls[-1]
        valid_l_sum += valid_ls[-1]  # 将最后一个 epoch 的训练损失加到总训练损失中
        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  # 求平均误差

7. 模型选择（调参-重要操作）

在本例中，我们选择了一组未调优的超参数，并将其留给读者来改进模型。 找到一组调优的超参数可能需要时间，这取决于一个人优化了多少变量。 有了足够大的数据集和合理设置的超参数，𝐾𝐾折交叉验证往往对多次测试具有相当的稳定性。 然而，如果我们尝试了不合理的超参数，我们可能会发现验证效果不再代表真正的误差。

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-折交叉验证的结果图，train和valid重合得比较好，说明没有over fitting
# 同学们要做的就是不断地去调第一行的几个超参数，看平均验证log rmse（核心指标），损失越小越好

输出：

李沐老师：

• 看K-折交叉验证的结果图，train和valid重合得比较好，说明没有over fitting
• 同学们要做的就是不断地去调第一行的几个超参数，看平均验证log rmse（核心指标），损失越小越好
• 调个10-20多次，取最好的一组超参数

请注意，有时一组超参数的训练误差可能非常低，但𝐾折交叉验证的误差要高得多， 这表明模型过拟合了。 在整个训练过程中，我们希望监控训练误差和验证误差这两个数字。 较少的过拟合可能表明现有数据可以支撑一个更强大的模型， 较大的过拟合可能意味着我们可以通过正则化技术来获益。

8. 提交Kaggle预测

8.1 train_and_pred() 训出模型来预测

既然我们知道应该选择什么样的超参数， 我们不妨使用所有数据对其进行训练 （而不是仅使用交叉验证中使用的1−1/𝐾的数据）。 然后，我们通过这种方式获得的模型可以应用于测试集。 将预测保存在CSV文件中可以简化将结果上传到Kaggle的过程。

def 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,  # 这次不用算验证误差,因此" _"和None
                        num_epochs, lr, weight_decay, batch_size)  # train()里定义了判断是否有test集
    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}')  # 训练出模型（得到权重，用于后几行预测）
    
    # net(测试集)：给前几行训练出的模型传入测试集，输出预测结果（房价）；测试集没有真实label的，得咱来算
    preds = net(test_features).detach().numpy()  # 用detach()拿出预测结果(确保代码健壮性)，转为NumPy数组
    # 将结果重新格式化以导出到Kaggle
    # 在原本的test_data上新建一列，名为SalePrice
    test_data['SalePrice'] = pd.Series(preds.reshape(1, -1)[0])  # reshape成形状(1,n)，[0]就是拿出唯一一行
    # 原本test_data有很多列，但这里只拿出'Id'和'SalePrice'，放到新的submission容器里
    submission = pd.concat([test_data['Id'], test_data['SalePrice']], axis=1)  # axis=1 表示沿着列来拼接
    submission.to_csv('submission.csv', index=False)  # 结果存在submission.csv文件，kaggle上提交csv有得分

如果测试集上的预测与𝐾折交叉验证过程中的预测相似， 那就是时候把它们上传到Kaggle了。 下面的代码将生成一个名为submission.csv的文件。

train_and_pred(train_features, test_features, train_labels, test_data,  # train features和labels用来训模型
               num_epochs, lr, weight_decay, batch_size)  # 训出来的模型导入test_features跑出预测值

输出：

8.2 上传.csv 看得分

接下来，如 :numref:fig_kaggle_submit2中所示， 我们可以提交预测到Kaggle上，并查看在测试集上的预测与实际房价（标签）的比较情况。 步骤非常简单。

• 登录Kaggle网站，访问房价预测竞赛页面。
• 点击"Submit Predictions"或"Late Submission"按钮（在撰写本文时，该按钮位于右侧）。
• 点击页面底部虚线框中的"Upload Submission File"按钮，选择要上传的预测文件。
• 点击页面底部的"Make Submission"按钮，即可查看结果。

:width:400px :label:fig_kaggle_submit2

9. 小结

• 真实数据通常混合了不同的数据类型，需要进行预处理。
• 常用的预处理方法：将实值数据重新缩放为零均值和单位方法；用均值替换缺失值。
• 将类别特征转化为指标特征，可以使我们把这个特征当作一个独热向量来对待。
• 我们可以使用𝐾𝐾折交叉验证来选择模型并调整超参数。
• 对数对于相对误差很有用。

10. 练习

1. 把预测提交给Kaggle，它有多好？
2. 能通过直接最小化价格的对数来改进模型吗？如果试图预测价格的对数而不是价格，会发生什么？
3. 用平均值替换缺失值总是好主意吗？提示：能构造一个不随机丢失值的情况吗？
4. 通过𝐾𝐾折交叉验证调整超参数，从而提高Kaggle的得分。
5. 通过改进模型（例如，层、权重衰减和dropout）来提高分数。
6. 如果我们没有像本节所做的那样标准化连续的数值特征，会发生什么？