Python：基于pytorch深度学习框架实现“多层感知机”(附带详细注释说明）+ 训练结果 + 理论详解_用pytorch实现一个多层感知机, 从零开始实现利用高级api简介实现

1. 相关理论知识
   【Adam】优化算法浅析
   多层感知机入门
   N折交叉验证的作用（如何使用交叉验证）
2. 用多层感知机实现房价预测

''' 多层感知机：房价预测 '''
import hashlib
import os
import tarfile
import zipfile
import requests

DATA_HUB = dict()  # 建立字典DATA_HUB， 它可以将数据集名称的字符串映射到数据集相关的二元组上， 这个二元组包含数据集的url和验证文件完整性的sha-1密钥
DATA_URL = 'http://d2l-data.s3-accelerate.amazonaws.com/'  # 地址为DATA_URL的站点


# 下面的download函数用来下载数据集， 将数据集缓存在本地目录（默认情况下为../data）中， 并返回下载文件的名称。
# 如果缓存目录中已经存在此数据集文件，并且其sha-1与存储在DATA_HUB中的相匹配， 我们将使用缓存的文件，以避免重复的下载。
def download(name, cache_dir=os.path.join('..', 'data')):
    """下载一个DATA_HUB中的文件，返回本地文件名"""
    assert name in DATA_HUB, f"{name} 不存在于 {DATA_HUB}"
    url, sha1_hash = DATA_HUB[name]
    os.makedirs(cache_dir, exist_ok=True)
    fname = os.path.join(cache_dir, url.split('/')[-1])
    if os.path.exists(fname):
        sha1 = hashlib.sha1()
        with open(fname, 'rb') as f:
            while True:
                data = f.read(1048576)
                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)
    with open(fname, 'wb') as f:
        f.write(r.content)
    return fname


def download_extract(name, folder=None):  # @save
    """下载并解压zip/tar文件"""
    fname = download(name)
    base_dir = os.path.dirname(fname)
    data_dir, ext = os.path.splitext(fname)
    if ext == '.zip':
        fp = zipfile.ZipFile(fname, 'r')
    elif ext in ('.tar', '.gz'):
        fp = tarfile.open(fname, 'r')
    else:
        assert False, '只有zip/tar文件可以被解压缩'
    fp.extractall(base_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)


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'))
# 训练数据集包括1460个样本，每个样本80个特征和1个标签， 而测试数据集包含1459个样本，每个样本80个特征。
print(train_data.shape)
print(test_data.shape)
print(train_data.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]])  # 打印四个样本的前四个和最后两个特征，以及相应标签（房价）

# 在每个样本中，第一个特征是ID， 这有助于模型识别每个训练样本。
# 虽然这很方便，但它不携带任何用于预测的信息。 因此，在将数据提供给模型之前，我们将其从数据集中删除。
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))
# 将训练数据中的所有特征除以索引列以外的所有列（从第二列到倒数第一列）和测试数据中的所有特征除以索引列以外的所有列（从第二列到倒数第一列）连接起来，并赋值给变量all_features。

'''  数据预处理  '''
# 若无法获得测试数据，则可根据训练数据计算均值和标准差
numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index
# 通过all_features.dtypes != 'object'过滤掉all_features中非数值类型的列，然后利用索引操作将得到的结果赋值给numeric_features
all_features[numeric_features] = all_features[numeric_features].apply(lambda x: (x - x.mean()) / (x.std()))
# 对所有数据进行标准化
all_features[numeric_features] = all_features[numeric_features].fillna(0)
# 在标准化数据之后，所有均值消失，因此我们可以将缺失值设置为0

all_features = pd.get_dummies(all_features, dummy_na=True)
# 使用get_dummies函数对all_features进行one-hot编码，其中dummy_na参数为True表示当某一特征是NaN时也要创建相应的虚拟类别。最后将处理后的结果赋值给变量all_features。
print(all_features.shape)

n_train = train_data.shape[0]
train_features = torch.tensor(all_features[:n_train].values.astype(float), dtype=torch.float32)
# all_features[:n_train].values数组里的元素是object类型，无法直接将这种类型转换成tensor，要先强制转换成float类型：.astype(float)
test_features = torch.tensor(all_features[n_train:].values.astype(float), dtype=torch.float32)
train_labels = torch.tensor(train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)
# train_data.SalePrice.values.reshape(-1, 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'))  # torch.clamp(input, min, max) 是 PyTorch 中的一个函数，用于将输入 tensor 的值限制在指定的范围内。该函数会返回一个新的 tensor，其中每个元素都等于 input tensor 的相应元素，但被限制在给定的 min 和 max 值之间。如果输入的值小于 min，则输出为 min；如果输入的值大于 max，则输出为 max。
    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):
    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折交叉验证
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\)折交叉验证中训练\(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


# * k: 这是一个整数参数，表示数据集需要分成多少个折叠（也称为“折”）。在这个例子中，我们将数据集分成 5 个部分。
# * num_epochs: 这是一个整数参数，表示训练模型所需的迭代次数。在这个例子中，我们将模型训练 100 次。
# * lr: 这是一个浮点数参数，表示模型的学习率，控制模型更新权重的速度。在这个例子中，模型的学习率为 5。
# * weight_decay: 这是一个浮点数参数，表示正则化项中的权重衰减。它用于防止过拟合，可以通过调整超参数来改进模型性能。在这个例子中，权重衰减设置为 0。
# * batch_size: 这是一个整数参数，表示每次训练使用的样本数量。在这个例子中，我们每次训练使用 64 个样本。
# k_fold 是一个函数，它将数据集划分为 k 份，并对每一部分执行相同的训练和验证过程。
k, num_epochs, lr, weight_decay, batch_size = 5, 100, 10, 0.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}')

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

3. 代码运行结果

(1460, 81)
(1459, 80)
   Id  MSSubClass MSZoning  LotFrontage SaleType SaleCondition  SalePrice
0   1          60       RL         65.0       WD        Normal     208500
1   2          20       RL         80.0       WD        Normal     181500
2   3          60       RL         68.0       WD        Normal     223500
3   4          70       RL         60.0       WD       Abnorml     140000
(2919, 330)

折1，训练log rmse0.148924, 验证log rmse0.147124
折2，训练log rmse0.145217, 验证log rmse0.163633
折3，训练log rmse0.143669, 验证log rmse0.148607
折4，训练log rmse0.147933, 验证log rmse0.146444
折5，训练log rmse0.142516, 验证log rmse0.173860
5-折验证: 平均训练log rmse: 0.145652, 平均验证log rmse: 0.155934
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15