动手学深度学习-15

敖炜 Lv5
  2023-08-16 09:25:12 2023-08-16 09:25:12 创建   2024-04-19 09:28:25 2024-04-19 09:28:25 更新      4.7k 字  18 分钟  

实战Kaggle比赛：预测房价

下载和缓存数据集

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import hashlib
import os
import tarfile
import zipfile
import requests

#@save
DATA_HUB = dict()
DATA_URL = 'http://d2l-data.s3-accelerate.amazonaws.com/'
```  

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

```python
def download(name, cache_dir=os.path.join('..', 'data')):  #@save
    """下载一个DATA_HUB中的文件，返回本地文件名"""
    assert name in DATA_HUB, f"{name} 不存在于 {DATA_HUB}" # 判断文件名是否在DATA_HUB中
    url, sha1_hash = DATA_HUB[name] # 获取相关信息
    os.makedirs(cache_dir, exist_ok=True) # 如果指定的缓存目录不存在，就创建它。exist_ok=True 表示如果目录已经存在也不会引发错误。
    fname = os.path.join(cache_dir, url.split('/')[-1]) # 构建保存文件的完整路径，将缓存目录和从下载链接中获取的文件名拼接在一起。
    if os.path.exists(fname): # 检查文件是否已经存在于缓存中。
        # 下面的代码块对缓存文件的完整性进行检查
        sha1 = hashlib.sha1() # 创建一个 SHA-1 哈希对象
        with open(fname, 'rb') as f: # 以二进制只读模式打开缓存文件
            while True: # 循环读取文件内容。
                data = f.read(1048576) # 每次读取 1048576 字节（1MB）的内容
                if not data: # 如果已经读取到文件末尾，则退出循环。
                    break
                sha1.update(data) #将读取的内容更新到 SHA-1 哈希对象中。
        if sha1.hexdigest() == sha1_hash: # 检查文件的 SHA-1 哈希值是否与预期的一致。如果一致，说明文件完整。
            return fname  # 命中缓存
    
    # 如果缓存文件不完整或不存在，会执行以下代码块来下载文件
    print(f'正在从{url}下载{fname}...')

    # 使用 requests 库发起 HTTP GET 请求，stream=True 表示以流的方式下载，verify=True 表示验证 SSL 证书。
    r = requests.get(url, stream=True, verify=True)

    # 以二进制写入模式打开缓存文件。
    with open(fname, 'wb') as f:
        # 将下载的内容写入缓存文件。
        f.write(r.content)
    return fname

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# name 表示要下载并解压缩的文件名，folder 表示要解压缩到的目标文件夹。如果不指定 folder，则解压缩到与压缩文件相同的目录
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) # 使用 os.path.splitext 函数分离文件名和扩展名，得到不带扩展名的文件名 data_dir 和扩展名 ext

    # 下面的代码块根据扩展名来判断压缩文件的类型，并进行解压缩操作
    if ext == '.zip': #如果扩展名是 .zip，则使用 zipfile.ZipFile 打开压缩文件。
        fp = zipfile.ZipFile(fname, 'r')
    elif ext in ('.tar', '.gz'): # 如果扩展名是 .tar 或 .gz，则使用 tarfile.open 打开压缩文件。
        fp = tarfile.open(fname, 'r')
    else: # 如果扩展名是 .tar 或 .gz，则使用 tarfile.open 打开压缩文件。
        assert False, '只有zip/tar文件可以被解压缩'

    fp.extractall(base_dir) # 调用 extractall 方法，将压缩文件中的内容解压缩到 base_dir 目录。

    return os.path.join(base_dir, folder) if folder else data_dir # 最后，根据是否指定了 folder 参数，返回解压缩后的目标文件夹路径（如果指定了）或数据文件夹路径。
    # 假设你有一个名为 data.zip 的压缩文件，其中包含了一个名为 my_data 的子文件夹。你可以这样使用 download_extract 函数来下载并解压缩该文件，并指定 folder 参数为 my_data。如果你没有指定 folder 参数，函数会默认返回解压缩后的根目录，而不会返回特定的子文件夹。

def download_all():  #@save
    """下载DATA_HUB中的所有文件"""
    for name in DATA_HUB:
        download(name)

Kaggle

Kaggle是一个当今流行举办机器学习比赛的平台， 每场比赛都以至少一个数据集为中心

访问和读取数据集

注意，竞赛数据分为训练集和测试集。每条记录都包括房屋的属性值和属性，如街道类型、施工年份、屋顶类型、地下室状况等。这些特征由各种数据类型组成。

例如，建筑年份由整数表示，屋顶类型由离散类别表示，其他特征由浮点数表示。
这就是现实让事情变得复杂的地方：例如，一些数据完全丢失了，缺失值被简单地标记为“NA”。每套房子的价格只出现在训练集中（毕竟这是一场比赛）。我们将希望划分训练集以创建验证集，但是在将预测结果上传到Kaggle之后，我们只能在官方测试集中评估我们的模型。

使用pandas读入并处理数据

1
2
3
4
5
6
7
8
9
# 如果没有安装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房屋数据集。

1
2
3
4
5
6
7
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文件。

1
2
train_data = pd.read_csv(download('kaggle_house_train'))
test_data = pd.read_csv(download('kaggle_house_test'))

训练数据集包括1460个样本，每个样本80个特征和1个标签，
而测试数据集包含1459个样本，每个样本80个特征。

前四个和最后两个特征，以及相应标签（房价）。

1
print(train_data.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]])

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
"""这行代码使用了 pandas 库中的 concat 函数，将训练数据集和测试数据集中的一部分特征列连接起来，形成一个新的 DataFrame。让我们逐步解释代码：

1. all_features：这是一个新的 DataFrame，用于存储连接后的特征数据。

2. pd.concat(...)：这是 pandas 库中的函数，用于连接两个或多个 DataFrame。

3. (train_data.iloc[:, 1:-1], test_data.iloc[:, 1:])：这是一个元组，其中包含了两个部分。第一个部分 train_data.iloc[:, 1:-1] 表示从训练数据集中选择除了第 0 列（通常是标签列）和最后一列（可能也是标签列）之外的所有列作为特征。第二个部分 test_data.iloc[:, 1:] 表示从测试数据集中选择除了第 0 列之外的所有列作为特征。

4. ,：这个逗号将两个部分分开，将它们传递给 pd.concat 函数。

5. all_features：这是连接后的特征数据，即训练数据和测试数据中的特征列合并在一起的 DataFrame。

总之，这行代码将训练数据集和测试数据集中的特征列合并成一个新的 DataFrame，用于进行特征预处理和模型训练。"""
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))

数据预处理

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

其中和分别表示均值和标准差。
现在，这些特征具有零均值和单位方差，即 和。
直观地说，我们标准化数据有两个原因：首先，它方便优化。其次，因为我们不知道哪些特征是相关的，所以我们不想让惩罚分配给一个特征的系数比分配给其他任何特征的系数更大。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 这段代码是进行特征预处理的一部分，涉及到对特征数据进行标准化和处理缺失值

# 若无法获得测试数据，则可根据训练数据计算均值和标准差

# 这行代码用于获取所有数值类型的特征列的索引。它通过检查 all_features DataFrame 中的数据类型，排除了数据类型为 'object' 的列，从而得到数值特征列的索引。
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

# 这一行代码将标准化后的数值特征中的缺失值（NaN）替换为 0。
all_features[numeric_features] = all_features[numeric_features].fillna(0)

接下来处理离散值，我们用独热编码替换它们。pandas软件包会自动为我们实现这一点。

1
2
3
4
5
6
7
8
9
10
11
# 这段代码是使用 pandas 库中的 get_dummies 函数进行独热编码（One-Hot Encoding）的操作


# “Dummy_na=True”将“na”（缺失值）视为有效的特征值，并为其创建指示符特征

# 这一行代码调用 pd.get_dummies 函数，将所有离散特征进行独热编码。参数 dummy_na=True 表示将缺失值（NaN）视为有效的特征值，并为其创建指示符特征。
all_features = pd.get_dummies(all_features, dummy_na=True)

all_features.shape

# 这段代码的目的是将特征数据进行虚拟变量编码，将离散的特征列转换为二进制的虚拟变量列。

最后，通过values属性，我们可以从pandas格式中提取NumPy格式，并将其转换为张量表示用于训练。

1
2
3
4
5
6
7
8
9
10
11
n_train = train_data.shape[0] # 获取训练样本集样本数量

train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32) # 将预处理后的特征数据的前 n_train 行转换为 PyTorch 张量。使用 torch.tensor 函数将 NumPy 数组转换为张量，同时指定数据类型为 torch.float32。

test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32) # 预处理后的特征数据的后部分（对应测试数据集）转换为 PyTorch 张量。


train_labels = torch.tensor(
    train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32) # 将训练数据集的标签（销售价格）转换为 PyTorch 张量。使用 values 属性将标签列的值提取为 NumPy 数组，然后使用 .reshape(-1, 1) 将标签变形为列向量的形式，最后转换为张量。

"""train_features 是用于训练的特征数据，test_features 是用于测试的特征数据，train_labels 是训练数据的标签。"""

训练

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

1
2
3
4
5
6
loss = nn.MSELoss()
in_features = train_features.shape[1]

def get_net():
    net = nn.Sequential(nn.Linear(in_features,1))
    return net

房价就像股票价格一样，我们关心的是相对数量，而不是绝对数量。房价就像股票价格一样，我们关心的是相对数量，而不是绝对数量。因此，我们更关心相对误差，而不是绝对误差。例如，如果我们在俄亥俄州农村地区估计一栋房子的价格时，假设我们的预测偏差了10万美元，然而那里一栋典型的房子的价值是12.5万美元，那么模型可能做得很糟糕。另一方面，如果我们在加州豪宅区的预测出现同样的10万美元的偏差，（在那里，房价中位数超过400万美元）这可能是一个不错的预测。

解决这个问题的一种方法是用价格预测的对数来衡量差异。
事实上，这也是比赛中官方用来评价提交质量的误差指标。
即将 for
转换为。
这使得预测价格的对数与真实标签价格的对数之间出现以下均方根误差（均方根误差是一种常见的回归问题评估指标，可以用来衡量预测值与真实值之间的误差大小）：

1
2
3
4
5
6
7
# 接受神经网络模型 net、特征数据 features 和标签数据 labels 作为参数。
def log_rmse(net, features, labels):
    # 为了在取对数时进一步稳定该值，将小于1的值设置为1
    clipped_preds = torch.clamp(net(features), 1, float('inf')) # 这一行代码首先使用神经网络模型 net 对特征数据 features 进行预测，然后使用 torch.clamp 函数将预测值进行截断，将小于 1 的值设置为 1，避免在取对数时出现无穷大。
    rmse = torch.sqrt(loss(torch.log(clipped_preds),
                           torch.log(labels)))
    return rmse.item() # 返回计算得到的对数均方根误差值，并使用 item() 方法将张量的值转换为 Python 标量。

我们的训练函数将借助Adam优化器，Adam优化器的主要吸引力在于它对初始学习率不那么敏感

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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_ls

K折交叉验证

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# k（折数）、i（当前折的索引）、特征数据 X 和标签数据 y
def get_k_fold_data(k, i, X, y):
    assert k > 1 # 这行代码使用断言确保 k 大于 1，确保交叉验证折数合理。
    fold_size = X.shape[0] // k # 计算每折的样本数量，即特征数据的总样本数除以 k。
    X_train, y_train = None, 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)  # 将当前折的特征数据与之前的训练集特征数据进行连接。

            y_train = torch.cat([y_train, y_part], 0) # 将当前折的标签数据与之前的训练集标签数据进行连接。

    # 返回训练集特征数据、训练集标签数据、验证集特征数据和验证集标签数据。
    return X_train, y_train, X_valid, y_valid

在折交叉验证中训练次后，返回训练和验证误差的平均值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
     # 返回平均训练误差和平均验证误差。

模型选择

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

提交Kaggle预测

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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)

小结

  • 真实数据通常混合了不同的数据类型，需要进行预处理。
  • 常用的预处理方法：将实值数据重新缩放为零均值和单位方法；用均值替换缺失值。
  • 将类别特征转化为指标特征，可以使我们把这个特征当作一个独热向量来对待。
  • 我们可以使用折交叉验证来选择模型并调整超参数。
  • 对数对于相对误差很有用。
  • 标题: 动手学深度学习-15
  • 作者: 敖炜
  • 创建于 : 2023-08-16 09:25:12
  • 更新于 : 2024-04-19 09:28:25
  • 链接: https://ao-wei.github.io/2023/08/16/动手学深度学习-15/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
评论
此页目录
动手学深度学习-15
  1. 下载和缓存数据集
  2. Kaggle
  3. 访问和读取数据集
  4. 数据预处理
  5. 训练
  6. K折交叉验证
  7. 模型选择
  8. 提交Kaggle预测
  9. 小结