tensorflow 2.0 學習 （七） 反向傳播代碼逐步實現

數據集為：

代碼為：

# encoding: utf-8

import tensorflow as tf
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
# from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split

N_SAMPLES = 2000  # 采樣點數
TEST_SIZE = 0.3  # 測試數量比率

# 產生一個簡單的樣本數據集，半環形圖，類似的有make_circles,環形數據
X, y = make_moons(n_samples=N_SAMPLES, noise=0.2, random_state=100)  # (2000, 2),(2000, 1)
# X, y = make_circles(n_samples = N_SAMPLES, noise=0.2, random_state=100)
# 將矩陣隨機划分訓練集和測試集 (1400,2),(600,2),(1400,1),(600,1)
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)

# 繪制數據集分布，X為2D坐標，y為數據點標簽


def make_plot(X, y, plot_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_l$", 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.shape(XX.shape), 25, alpha=1, cmap=plt.cm.Spectral)
        plt.contour(XX, YY, preds.reshape(XX.shape), levels=[1.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.savefig('data_set.png')
    plt.close()


make_plot(X, y, "Classification DataSet Visualization")
plt.show()


class Layer:
    # 全連接層網絡
    def __init__(self, n_input, n_neurons, activation=None, weights=None, bias=None):
        """
        : int n_input: 輸入節點數
        ：int n_neurons: 輸出節點數
        ：str activation: 激活函數類型
        : weights: 權值張量，內部生成
        ： 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.randn(n_neurons) * 0.1
        self.activation = activation
        self.last_activation = None
        self.error = None
        self.delta = None

    # 網絡的前向傳播
    def activate(self, x):
        r = np.dot(x, self.weights) + self.bias  # X@w + b
        self.last_activation = self._apply_activation(r)  # 激活函數
        return self.last_activation

    # 不同類型的激活函數
    def _apply_activation(self, r):
        if self.activation is None:
            return r
        elif self.activation == 'relu':
            return np.maximum(r, 0)
        elif self.activation == 'tanh':
            return np.tanh(r)
        elif self.activation == 'sigmoid':
            return 1 / (1 + np.exp(-r))
        return r

        # 不同類型激活函數的導數實現
    def apply_activation_derivation(self, r):
        if self.activation is None:
            return np.ones_like(r)
        elif self.activation == 'relu':
            grad = np.array(r, copy=True)
            grad[r > 0] = 1.
            grad[r <= 0] = 0.
            return grad
        elif self.activation == 'tanh':
            return 1 - r**2
        elif self.activation == 'sigmoid':
            return r * (1 - r)
        return r


# 神經網絡模型
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
                layer.delta = layer.error * layer.apply_activation_derivation(output)
            else:  # 計算隱藏層
                next_layer = self._layers[i + 1]  # 得到下一層對象
                layer.error = np.dot(next_layer.weights, next_layer.delta)  # 矩陣乘法
                layer.delta = layer.error *\
                              layer.apply_activation_derivation(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)  # 將數據視為2維數據
            layer.weights += layer.delta * o_i.T * learning_rate  # .T是轉置

    # 網絡的訓練
    def train(self, X_train, X_test, y_train, y_test, learning_rate, max_epochs):
        temp1 = y_train.shape[0]
        y_onehot = np.zeros((temp1, 2))
        temp2 = np.arange(y_train.shape[0])  # 線性 0 - 1399
        y_onehot[temp2, y_train] = 1
        mses = []
        accuracy = []
        for i in range(max_epochs):
            for j in range(len(X_train)):  # 一次訓練一個樣本
                self.backpropagation(X_train[j], y_onehot[j], learning_rate)
            if i % 10 == 0:
                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)


# 4層全連接網絡 實例化訓練和預測
nn = NeuralNetwork()  # 實列化網絡
nn.add_layer(Layer(2, 25, 'sigmoid'))  # 2 --> 25
nn.add_layer(Layer(25, 50, 'sigmoid'))  # 25 --> 50
nn.add_layer(Layer(50, 25, 'sigmoid'))  # 50 --> 25
nn.add_layer(Layer(25, 2, 'sigmoid'))  # 25 --> 2
learning_rate = 0.01
max_epochs = 1000
mses, accuracy = nn.train(X_train, X_test, y_train, y_test, learning_rate, max_epochs)

plt.figure()
plt.plot(mses, 'b', label='MSE Loss')
plt.xlabel('Epoch')
plt.ylabel('MSE')
plt.legend()
plt.savefig('exam5.2 MSE Loss.png')
plt.show()

plt.figure()
plt.plot(accuracy, 'r', label='Accuracy rate')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.savefig('exam5.2 Accuracy.png')
plt.show()

 

誤差為：

准確率為：

這個例子的目的是為讓讀者更進一步了解反向傳播，包括數學上的理解和代碼上的理解。

大體上還是能理解文中的含義，只是細節上要自己動手去算，故使用tensorflow封裝好的函數，會簡化很多代碼，

會使學習者的成就感增加，否者的話，看到這么多數學公式以及代碼的實現，早就放棄了！

下一次，我想更新關於tensorboard可視化的一些學習代碼和感興趣的東西。

但是下一次更新也不知道是好久，因為要做Geant4模擬，還有模擬內容相關的圖像重建算法研究，

所以不知道什么時候可以繼續學習tensorflow，但是也不能放棄，一定要把這本書過一遍！

最近solidorks的學習也遇到困難了，也不知道下一次更新是什么時候，可能2019年的更新就這些內容了！

不過對於我來說，也算開了個頭！