來自書籍：TensorFlow深度學習
一、神經網絡介紹
1、全連接層（前向傳播）
（1）張量方式實現：tf.matmul
（2）層方式實現：
① layers.Dense(輸出節點數,激活函數)，輸入節點數函數自動獲取
fc.kernel：獲取權值矩陣 W
fc.bias：獲取偏置向量 b
fc.trainable_variables：返回待優化參數列表
fc.non_trainable_variables：不需要優化的參數列表，如Batch Normalization 層。
fc.variables :返回所有內部張量列表
② Sequence容器：可通過Sequence容器封裝成一個網絡大類對象。
# 導入 Sequential容器 from tensorflow.keras import layers,Sequential # 通過 Sequential容器封裝為一個網絡類 model = Sequential([ layers.Dense(256, activation=tf.nn.relu) , # 創建隱藏層 1 layers.Dense(128, activation=tf.nn.relu) , # 創建隱藏層 2 layers.Dense(64, activation=tf.nn.relu) , # 創建隱藏層 3 layers.Dense(10, activation=None) , # 創建輸出層 ])
out = model(x) # 前向計算得到輸出
2、激活函數
- tf.nn.sigmoid(x)：
- tf.nn.softmax(x)：
- tf.nn.relu(x) ：
- tf.nn.leaky_relu(x,alpha)：
，alpha為p - tf.nn.tanh(x)：
3、誤差計算
- 均方誤差MSE：keras.losses.MSE(y_實際, y_預測) 或者 keras.losses.MeanSquaredError：
o = tf.random.normal([2,10]) # 構造網絡輸出 y_onehot = tf.constant([1,3]) # 構造真實值 y_onehot = tf.one_hot(y_onehot, depth=10) #直接計算 loss = keras.losses.MSE(y_onehot, o) # 計算均方差 loss = tf.reduce_mean(loss) # 計算 batch均方差 #層方式 criteon = keras.losses.MeanSquaredError() loss = criteon(y_onehot,o) # 計算 batch均方差
- 交叉熵誤差：keras.losses.categorical_crossentropy(實際,預測）或者keras.losses.CategoricalCrossentropy(from_logits=True)
z = tf.random.normal([2,10]) # 構造輸出層的輸出 y_onehot = tf.constant([1,3]) # 構造真實值 y_onehot = tf.one_hot(y_onehot, depth=10) # one-hot編碼 # 輸出層未使用 Softmax函數，故 from_logits設置為 True ####方式一 # 這樣 categorical_crossentropy函數在計算損失函數前，會先內部調用 Softmax函數 loss = keras.losses.categorical_crossentropy(y_onehot,z,from_logits=True) loss = tf.reduce_mean(loss) # 計算平均交叉熵損失 ####方式二 # 創建 Softmax與交叉熵計算類，輸出層的輸出 z未使用 softmax criteon = keras.losses.CategoricalCrossentropy(from_logits=True) loss = criteon(y_onehot,z) # 計算損失
4、反向傳播
（1）構建梯度記錄器（梯度跟蹤）： with tf.GradientTape() as tape
（2）記錄梯度信息（非 tf.Variable類型的張量需要人為設置記錄梯度信息 ）：tape.watch([w1, b1, w2, b2])
（3）求解偏導（反向傳播）：grads = tape.gradient(y, [w])[0]
x = tf.constant([4., 0.]) # 初始化參數 for step in range(200):# 循環優化 200次 with tf.GradientTape() as tape: #梯度跟蹤 tape.watch([x]) # 加入梯度跟蹤列表 y = himmelblau(x) # 前向傳播 # 反向傳播 grads = tape.gradient(y, [x])[0] # 更新參數,0.01為學習率 x -= 0.01*grads # 打印優化的極小值 if step % 20 == 19: print ('step {}: x = {}, f(x) = {}' .format(step, x.numpy(), y.numpy()))
二、神經網絡訓練實戰
（1）加載庫
import tensorflow as tf import numpy as np from sklearn.datasets import make_moons from sklearn.model_selection import train_test_split import seaborn as sns import matplotlib.pyplot as plt
（2）加載數據集
######利用scikit-learn 庫的make_moons工具生成 2000 個線性不可分的 2 分類數據集，數據 的特征長度為 2，分布圖如下圖所示##### N_SAMPLES = 2000 # 采樣點數 TEST_SIZE = 0.3 # 測試數量比率 # 利用工具函數直接生成數據集 X, y = make_moons(n_samples = N_SAMPLES, noise=0.2, random_state=100) # 將 2000個點按着 7:3分割為訓練集和測試集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=TEST_SIZE, random_state=42) print(X.shape, y.shape) #######畫數據分布圖,可忽略####### def make_plot(X, y, plot_name, file_name=None, XX=None, YY=None, preds=None, dark=False): if (dark): plt.style.use('dark_background') else: sns.set_style("whitegrid") plt.figure(figsize=(16,12)) axes = plt.gca() axes.set(xlabel="$x_1$", ylabel="$x_2$") plt.title(plot_name, fontsize=30) plt.subplots_adjust(left=0.20) plt.subplots_adjust(right=0.80) if(XX is not None and YY is not None and preds is not None): plt.contourf(XX, YY, preds.reshape(XX.shape), 25, alpha = 1, cmap=cm.Spectral) plt.contour(XX, YY, preds.reshape(XX.shape), levels=[.5], cmap="Greys", vmin=0, vmax=.6) # 繪制散點圖，根據標簽區分顏色 plt.scatter(X[:, 0], X[:, 1], c=y.ravel(), s=40, cmap=plt.cm.Spectral, edgecolors='none') plt.show() plt.close() # 調用 make_plot函數繪制數據的分布，其中 X 為 2D坐標，y為標簽 make_plot(X, y, "Classification Dataset Visualization ")
（3）構建單層全連接層網絡
- 前向傳播式子
- 激活函數輸出
- 激活函數的導數
class Layer: # 全連接網絡層 def __init__(self, n_input, n_neurons, activation=None, weights=None, bias=None): """ :param int n_input: 輸入節點數 :param int n_neurons: 輸出節點數 :param str activation: 激活函數類型 :param weights: 權值張量，默認類內部生成 :param bias: 偏置，默認類內部生成 """ # 通過正態分布初始化網絡權值，初始化非常重要，不合適的初始化將導致網絡不收斂 self.weights = weights if weights is not None else np.random.randn(n_input, n_neurons) * np.sqrt(1 / n_neurons) self.bias = bias if bias is not None else np.random.rand(n_neurons) * 0.1 self.activation = activation # 激活函數類型，如’sigmoid’ self.last_activation = None # 激活函數的輸出值 o self.error = None # 用於計算當前層的 delta變量的中間變量 self.delta = None # 記錄當前層的 delta變量，用於計算梯度 def activate(self, x): # 前向傳播函數 r = np.dot(x, self.weights) + self.bias # X@W+b # 通過激活函數，得到全連接層的輸出 o self.last_activation = self._apply_activation(r) return self.last_activation def _apply_activation(self, r): # 計算激活函數的輸出 if self.activation is None: return r # 無激活函數，直接返回 # ReLU激活函數 elif self.activation == 'relu': return np.maximum(r, 0) # tanh激活函數 elif self.activation == 'tanh': return np.tanh(r) # sigmoid激活函數 elif self.activation == 'sigmoid': return 1 / (1 + np.exp(-r)) return r def apply_activation_derivative(self, r): # 計算激活函數的導數 # 無激活函數，導數為 1 if self.activation is None: return np.ones_like(r) # ReLU函數的導數實現 elif self.activation == 'relu': grad = np.array(r, copy=True) grad[r > 0] = 1. grad[r <= 0] = 0. return grad # tanh函數的導數實現 elif self.activation == 'tanh': return 1 - r ** 2 # Sigmoid函數的導數實現 elif self.activation == 'sigmoid': return r * (1 - r) return r
（4）搭建多層網絡模型
- 前向傳播（多層網絡對象）
- 反向傳播
- 網絡訓練
class NeuralNetwork: # 神經網絡模型大類 def __init__(self): self._layers = [] # 網絡層對象列表 def add_layer(self, layer): # 追加網絡層 self._layers.append(layer) def feed_forward(self, X): # 前向傳播 for layer in self._layers: # 依次通過各個網絡層 X = layer.activate(X) return X def backpropagation(self, X, y, learning_rate): # 反向傳播算法實現 # 前向計算，得到輸出值 output = self.feed_forward(X) for i in reversed(range(len(self._layers))): # 反向循環 layer = self._layers[i] # 得到當前層對象 # 如果是輸出層 if layer == self._layers[-1]: # 對於輸出層 layer.error = y - output # 計算 2分類任務的均方差的導數 # 關鍵步驟：計算最后一層的 delta，參考輸出層的梯度公式 layer.delta = layer.error * layer.apply_activation_derivative(output) else: # 如果是隱藏層 next_layer = self._layers[i + 1] # 得到下一層對象 layer.error = np.dot(next_layer.weights, next_layer.delta) # 關鍵步驟：計算隱藏層的 delta，參考隱藏層的梯度公式 layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation) # 循環更新權值 for i in range(len(self._layers)): layer = self._layers[i] # o_i為上一網絡層的輸出 o_i = np.atleast_2d(X if i == 0 else self._layers[i -1].last_activation) # 梯度下降算法，delta是公式中的負數，故這里用加號 layer.weights += layer.delta * o_i.T * learning_rate def train(self, X_train, X_test, y_train, y_test, learning_rate, max_epochs): # 網絡訓練函數 # one-hot編碼 y_onehot = np.zeros((y_train.shape[0], 2)) y_onehot[np.arange(y_train.shape[0]), y_train] = 1 mses = [] accuracy = [] for i in range(max_epochs): # 訓練 1000個 epoch for j in range(len(X_train)): # 一次訓練一個樣本 self.backpropagation(X_train[j], y_onehot[j], learning_rate) if i % 100 == 0: # 打印出 MSE Loss mse = np.mean(np.square(y_onehot - self.feed_forward(X_train))) mses.append(mse) print('Epoch: #%s, MSE: %f' % (i, float(mse))) # 統計並打印准確率 acc = self.accuracy(self.predict(X_test), y_test.flatten()) print('Accuracy: %.2f%%'% (acc * 100)) accuracy.append(acc*100) return mses , accuracy def accuracy(self, y_output, y_test): return np.mean((np.argmax(y_output, axis=1) == y_test)) def predict(self, X_test): return self.feed_forward(X_test)
（5）執行代碼，網絡性能
learning_rate = 0.01 max_epochs = 1000 nn = NeuralNetwork() # 實例化網絡類 nn.add_layer(Layer(2, 25, 'sigmoid')) # 隱藏層 1, 2=>25 nn.add_layer(Layer(25, 50, 'sigmoid')) # 隱藏層 2, 25=>50 nn.add_layer(Layer(50, 25, 'sigmoid')) # 隱藏層 3, 50=>25 nn.add_layer(Layer(25, 2, 'sigmoid')) # 輸出層, 25=>2 mses, accuracy = nn.train(X_train, X_test, y_train, y_test, learning_rate, max_epochs)
結果：
Epoch: #0, MSE: 0.248481 Accuracy: 49.50% Epoch: #100, MSE: 0.096236 Accuracy: 88.83% Epoch: #200, MSE: 0.096110 Accuracy: 88.83% Epoch: #300, MSE: 0.095975 Accuracy: 88.83% Epoch: #400, MSE: 0.095230 Accuracy: 88.83% Epoch: #500, MSE: 0.092865 Accuracy: 89.17% Epoch: #600, MSE: 0.089827 Accuracy: 90.00% Epoch: #700, MSE: 0.083719 Accuracy: 92.50% Epoch: #800, MSE: 0.080861 Accuracy: 92.67% Epoch: #900, MSE: 0.076932 Accuracy: 92.83%