Pytorch总结七之 深度学习的正向、反向传播原理+参数初始化+实战房价预测

1. 正向传播、反向传播和计算图

在实现小批量随机梯度下降法训练模型过程中：
我们只提供了模型的正向传播（forward propagation）的计算，即对输⼊计算模型输出，然后通过 autograd 模块来调⽤系统⾃动⽣成的 backward 函数计算梯度。基于反向传播（back-propagation）算法的⾃动求梯度极⼤简化了深度学习模型训练算法的实现。
本节我们将使⽤数学和计算图（computational graph）两个⽅式来描述正向传播和反向传播。具体来说，我们将以带 L2 范数正则化的含单隐藏层的多层感知机为样例模型解释正向传播和反向传播。

1.1 正向传播

正向传播的计算图->

常绘制计算图来可视化运算符和变量在计算中的依赖关系。图3.6绘制了本节中样例模型正向传播的计算图，其中左下⻆是输⼊，右上⻆是输出。可以看到，图中箭头⽅向⼤多是向右和向上，其中⽅框代表变量，圆圈代表运算符，箭头表示从输⼊到输出之间的依赖关系。

1.2 反向传播

1.3 训练模型

2. 数值稳定性和模型初始化

深度模型有关数值稳定性的典型问题是衰减（vanishing）和爆炸（explosion）。

2.1 简介

2.2 随机初始化模型参数

随机初始化模型参数的⽅法有很多。在 线性回归的实现中，我们使⽤ torch.nn.init.normal_() 使模型 net 的权᯿参数采⽤正态分布的随机初始化⽅式。不过，PyTorch中 nn.Module 的模块参数都采取了较为合理的初始化策略（不同类型的layer具体采样的哪⼀种初始化⽅法的可参考源代码），因此⼀般不⽤我们考虑。

Xavier随机初始化

3. 实战KAGGLE⽐赛：房价预测

• 作为深度学习基础篇章的总结，动⼿实战⼀个Kaggle⽐赛：房价预测。
• 本节将提供未经调优的数据的预处理、模型的设计和超参数的选择。

我们可以在房价预测⽐赛的⽹⻚上了解⽐赛信息和参赛者成绩，也可以下载数据集并提交⾃⼰的预测结
果。该⽐赛的⽹⻚地址是https://www.kaggle.com/competitions/house-prices-advanced-regression-techniques

3.1 获取和读取数据集

⽐赛数据分为训练数据集和测试数据集。两个数据集都包括每栋房⼦的特征，如街道类型、建造年份、房顶类型、地下室状况等特征值。这些特征值有连续的数字、离散的标签甚⾄是缺失值“na”。只有训练数据集包括了每栋房⼦的价格，也就是标签。我们可以访问⽐赛⽹⻚，点击下图中的“Data”标签，并下载这些数据集。

其中，训练数据集包括1460个样本、80个特征和1个标签。测试数据集包括1459个样本和80个特征。我们需要将测试数据集中每个样本的标签预测出来。

#1.导入数据集
import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import sys
sys.path.append("..")
import d2lzh_pytorch as d2l
print(torch.__version__)
torch.set_default_tensor_type(torch.FloatTensor)

train_data = pd.read_csv('./data/kaggle_house/train.csv')
test_data = pd.read_csv('./data/kaggle_house/test.csv')
#查看数据集大小：
print("train: ",train_data.shape,"   test: ",test_data.shape)

#output:
# 1.12.1+cpu
# train:  (1460, 81)    test:  (1459, 80)

来查看前4个样本的前4个特征、后2个特征和标签（SalePrice）：

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

***output:
   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

可以看到第⼀个特征是Id，它能帮助模型记住每个训练样本，但难以推⼴到测试样本，所以我们不使⽤
它来训练。我们将所有的训练数据和测试数据的79个特征按样本连结。

all_features = pd.concat((train_data.iloc[:, 1:-1],test_data.iloc[:, 1:]))
print("size : ",all_features.shape)  #size :  (2919, 79)

3.2 预处理数据集

#标准化
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，所以可以直接⽤0来替换缺失值
all_features = all_features.fillna(0)

接下来将离散数值转成指示特征。举个例⼦，假设特征MSZoning⾥⾯有两个不同的离散值RL和RM，那么这⼀步转换将去掉MSZoning特征，并新加两个特征MSZoning_RL和MSZoning_RM，其值为0或1。如果⼀个样本原来在MSZoning⾥的值为RL，那么有MSZoning_RL=1且MSZoning_RM=0。

# dummy_na=True将缺失值也当作合法的特征值并为其创建指示特征
all_features = pd.get_dummies(all_features, dummy_na=True)
all_features.shape # (2919, 354)

n_train = train_data.shape[0]
train_features = torch.tensor(all_features[:n_train].values,dtype=torch.float)
test_features = torch.tensor(all_features[n_train:].values,dtype=torch.float)
train_labels = torch.tensor(train_data.SalePrice.values,dtype=torch.float).view(-1, 1)

3.3 训练模型

• 使⽤⼀个基本的线性回归模型和平⽅损失函数来训练模型。

loss = torch.nn.MSELoss()
def get_net(feature_num):
    net = nn.Linear(feature_num, 1)
    for param in net.parameters():
        nn.init.normal_(param, mean=0, std=0.01)  #初始化模型参数
    return net

def log_rmse(net, features, labels):
    with torch.no_grad():
     # 将⼩于1的值设成1，使得取对数时数值更稳定
         clipped_preds = torch.max(net(features), torch.tensor(1.0))
         rmse = torch.sqrt(2 * loss(clipped_preds.log(),labels.log()).mean())
     return rmse.item()

下⾯的训练函数使⽤了Adam优化算法。相对之前使⽤的⼩批量随机梯度下降，它对学习率相对不那么敏感。

def train(net, train_features, train_labels, test_features,test_labels,
 num_epochs, learning_rate, weight_decay, batch_size):
     train_ls, test_ls = [], []
     dataset = torch.utils.data.TensorDataset(train_features,train_labels)
     train_iter = torch.utils.data.DataLoader(dataset, batch_size,shuffle=True)
     # 这⾥使⽤了Adam优化算法
     optimizer = torch.optim.Adam(params=net.parameters(),
     lr=learning_rate, weight_decay=weight_decay)
     net = net.float()
     for epoch in range(num_epochs):
         for X, y in train_iter:
             l = loss(net(X.float()), y.float())
             optimizer.zero_grad()
             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

3.4 折交叉验证

在模型选择、⽋拟合和过拟合）中介绍了 折交叉验证。它将被⽤来选择模型设计并调节超参数。下⾯实现了⼀个函数，它返回第 i 折交叉验证时所需要的训练和验证数据。

def get_k_fold_data(k, i, X, y):
    # 返回第i折交叉验证时所需要的训练和验证数据
    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), dim=0)
        y_train = torch.cat((y_train, y_part), dim=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(X_train.shape[1])
        #  *data ==   data[0],data[1],data[2],data[3]
        train_ls, valid_ls = train(net, *data, num_epochs,learning_rate,weight_decay, batch_size)
        if len(train_ls)>1 :
            train_l_sum += train_ls[-1]
        if len(valid_ls)>1:
            valid_l_sum += valid_ls[-1]
        if i == 0:
            d2l.semilogy(range(1, num_epochs + 1), train_ls,'epochs', 'rmse',
                range(1, num_epochs + 1), valid_ls,['train', 'valid'])
        print('fold %d, train rmse %f, valid rmse %f' % (i,train_ls[-1], valid_ls[-1]))
    return train_l_sum / k, valid_l_sum / k

我们使⽤⼀组未经调优的超参数并计算交叉验证误差。可以改动这些超参数来尽可能减⼩平均测试误差。

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('%d-fold validation: avg train rmse %f, avg valid rmse %f' % (k, train_l, valid_l))

结果如下所示：

weight_decay=0.2

weight_decay=1