动手学深度学习(tensorflow)---学习笔记整理（六、传播相关问题+实战篇）

有关公式、基本理论等大量内容摘自《动手学深度学习》(TF2.0版)）

正向传播

通过刚刚的学习，我们会发现数据从输入层到输出层之间，会对各层的矩阵做矩阵乘法，然后加上偏置项，然后可能还需要加上激活函数，可能还需要L2范式正则化，然后继续输入到下一层，循环往复。

下面看一下材料的说法

反向传播

反向传播其实就是计算出损失函数，求出梯度后，从输出层向输入层反向的更新各层的参数矩阵和偏置项。

看一下正规的说法

正向传播和反向传播的关系

数据稳定性

主要有两个问题：衰减和爆炸

数据初始化

如果不随机初始化，那么对于同一种模型来说其训练过程是一样的。

实战

样例来自Kaggle的房价预测：https://www.kaggle.com/c/house-prices-advanced-regression-techniques

import tensorflow as tf
from tensorflow import keras
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from tensorflow import initializers as init
print(tf.__version__)
#加载数据集
train_data = pd.read_csv('/Users/ren/PycharmProjects/入组学习/动手学深度学习/house-prices-advanced-regression-techniques/train.csv')
test_data = pd.read_csv('/Users/ren/PycharmProjects/入组学习/动手学深度学习/house-prices-advanced-regression-techniques/test.csv')
#输出形状看一看
print(train_data.shape)
print(test_data.shape)
#输出前四个样本的前四个和后两个特征
print(train_data.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]])
#由于id这个属性对于训练毫无意义，所以将所有的训练数据和测试数据的其他79个特征按样本连结
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))
#数据预处理
#我们对连续数值的特征做标准化（standardization）
#设该特征在整个数据集上的均值为μ，标准差为σ。
# 那么，我们可以将该特征的每个值先减去μ再除以σ得到标准化后的每个特征值。对于缺失的特征值，我们将其替换成该特征的均值
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将缺失值也当作合法的特征值并为其创建指示特征
#get_dummies可以将特征转换为独热编码
all_features = pd.get_dummies(all_features, dummy_na=True)
print(all_features.shape)
#通过values属性得到NumPy格式的数据，并转成NDArray方便后面的训练
n_train = train_data.shape[0]
train_features = np.array(all_features[:n_train].values,dtype=np.float)
test_features = np.array(all_features[n_train:].values,dtype=np.float)
train_labels = np.array(train_data.SalePrice.values.reshape(-1, 1),dtype=np.float)
#线性回归模型
def get_net():
    net = keras.models.Sequential()
    net.add(keras.layers.Dense(1))
    return net
#数均方根误差的实现
log_rmse=tf.keras.losses.mean_squared_logarithmic_error
#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):
        #slice() 函数实现切片对象
        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 = tf.concat([X_train, X_part], axis=0)
            y_train = tf.concat([y_train, y_part], axis=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):
        # create model
        data = get_k_fold_data(k, i, X_train, y_train)
        net=get_net()
        # Compile model
        net.compile(loss=tf.keras.losses.mean_squared_logarithmic_error, optimizer=tf.keras.optimizers.Adam(learning_rate))
        # Fit the model
        history=net.fit(data[0], data[1],validation_data=(data[2], data[3]), epochs=num_epochs, batch_size=batch_size,validation_freq=1,verbose=0)
        loss = history.history['loss']
        val_loss = history.history['val_loss']
        print('fold %d, train rmse %f, valid rmse %f'
              % (i, loss[-1], val_loss[-1]))
    plt.subplot(1, 2, 2)
    plt.plot(loss, label='train')
    plt.plot(val_loss, label='valid')
    plt.legend(loc='upper right')
    plt.title('Training and Validation Loss')
    plt.show()
#调用
k, num_epochs, lr, weight_decay, batch_size = 5, 100, 5, 0, 64
k_fold(k, train_features, train_labels, num_epochs,lr, weight_decay, batch_size)
#定义完成模型并训练
x_train=tf.convert_to_tensor(train_features,dtype=tf.float32)
y_train=tf.convert_to_tensor(train_labels,dtype=tf.float32)
x_test=tf.convert_to_tensor(test_features,dtype=tf.float32)
model=tf.keras.models.Sequential([
  tf.keras.layers.Dense(1)
])
adam=tf.keras.optimizers.Adam(0.5)
model.compile(optimizer=adam,
              loss=tf.keras.losses.mean_squared_logarithmic_error,
              metrics=['accuracy']
              )
model.fit(x_train, y_train, epochs=200,batch_size=32,verbose=0)
#预测
preds=np.array(model.predict(x_test))
print(preds)

结果如图：