(Python)零起步數學+神經網絡入門

時間 2019-12-06

標籤 python 起步數學神經網絡入門欄目 Python 简体版

原文原文鏈接

在這篇文章中，咱們將在Python中從頭開始瞭解用於構建具備各類層神經網絡（徹底鏈接，卷積等）的小型庫中的機器學習和代碼。最終，咱們將可以寫出以下內容：python

假設你對神經網絡已經有必定的瞭解，這篇文章的目的不是解釋爲何構建這些模型，而是要說明如何正確實現。git

逐層github

咱們這裏須要牢記整個框架：網絡

1. 將數據輸入神經網絡架構

2. 在得出輸出以前，數據從一層流向下一層app

3. 一旦獲得輸出，就能夠計算出一個標量偏差。框架

4. 最後，能夠經過相對於參數自己減去偏差的導數來調整給定參數（權重或誤差）。dom

5. 遍歷整個過程。機器學習

最重要的一步是第四步。咱們但願可以擁有任意數量的層，以及任何類型的層。可是若是修改/添加/刪除網絡中的一個層，網絡的輸出將會改變，偏差也將改變，偏差相對於參數的導數也將改變。不管網絡架構如何、激活函數如何、損失如何，都必需要可以計算導數。ide

爲了實現這一點，咱們必須分別實現每一層。

每一個層應該實現什麼

咱們可能構建的每一層（徹底鏈接，卷積，最大化，丟失等）至少有兩個共同點：輸入和輸出數據。

如今重要的一部分

假設給出一個層相對於其輸出（∂E/∂Y）偏差的導數，那麼它必須可以提供相對於其輸入（∂E/∂X）偏差的導數。

咱們可使用鏈規則輕鬆計算∂E/∂X的元素：

爲何是∂E/∂X？

對於每一層，咱們須要相對於其輸入的偏差導數，由於它將是相對於前一層輸出的偏差導數。這很是重要，這是理解反向傳播的關鍵！在這以後，咱們將可以當即從頭開始編寫深度卷積神經網絡！

花樣圖解

基本上，對於前向傳播，咱們將輸入數據提供給第一層，而後每層的輸出成爲下一層的輸入，直到到達網絡的末端。

對於反向傳播，咱們只是簡單使用鏈規則來得到須要的導數。這就是爲何每一層必須提供其輸出相對於其輸入的導數。

這可能看起來很抽象，可是當咱們將其應用於特定類型的層時，它將變得很是清楚。如今是編寫第一個python類的好時機。

抽象基類：Layer

全部其它層將繼承的抽象類Layer會處理簡單屬性，這些屬性是輸入，輸出以及前向和反向方法。

from abc import abstractmethod
# Base class
class Layer:
    def __init__(self):
        self.input = None;
        self.output = None;
        self.input_shape = None;
        self.output_shape = None;
    # computes the output Y of a layer for a given input X
    @abstractmethod
    def forward_propagation(self, input):
        raise NotImplementedError

    # computes dE/dX for a given dE/dY (and update parameters if any)
    @abstractmethod
    def backward_propagation(self, output_error, learning_rate):
        raise NotImplementedError

正如你所看到的，在back_propagation函數中，有一個我沒有提到的參數，它是learning_rate。此參數應該相似於更新策略或者在Keras中調用它的優化器，爲了簡單起見，咱們只是經過學習率並使用梯度降低更新咱們的參數。

全鏈接層

如今先定義並實現第一種類型的網絡層：全鏈接層或FC層。FC層是最基本的網絡層，由於每一個輸入神經元都鏈接到每一個輸出神經元。

前向傳播

每一個輸出神經元的值由下式計算：

使用矩陣，可使用點積來計算每個輸出神經元的值：

當完成前向傳播以後，如今開始作反向傳播。

反向傳播

正如咱們所說，假設咱們有一個矩陣，其中包含與該層輸出相關的偏差導數（∂E/∂Y）。咱們須要：

1.關於參數的偏差導數（∂E/∂W，∂E/∂B）

2.關於輸入的偏差導數（∂E/∂X）

首先計算∂E/∂W，該矩陣應與W自己的大小相同：對於ixj，其中i是輸入神經元的數量，j是輸出神經元的數量。每一個權重都須要一個梯度：

使用前面提到的鏈規則，能夠寫出：

那麼：

這就是更新權重的第一個公式！如今開始計算∂E/∂B：

一樣，∂E/∂B須要與B自己具備相同的大小，每一個誤差一個梯度。咱們能夠再次使用鏈規則：

得出結論：

如今已經獲得∂E/∂W和∂E/∂B，咱們留下∂E/∂X這是很是重要的，由於它將「做用」爲以前層的∂E/∂Y。

再次使用鏈規則：

最後，咱們能夠寫出整個矩陣：

編碼全鏈接層

如今咱們能夠用Python編寫實現：

from layer import Layer
import numpy as np

# inherit from base class Layer
class FCLayer(Layer):
    # input_shape = (1,i)   i the number of input neurons
    # output_shape = (1,j)  j the number of output neurons
    def __init__(self, input_shape, output_shape):
        self.input_shape = input_shape;
        self.output_shape = output_shape;
        self.weights = np.random.rand(input_shape[1], output_shape[1]) - 0.5;
        self.bias = np.random.rand(1, output_shape[1]) - 0.5;

    # returns output for a given input
    def forward_propagation(self, input):
        self.input = input;
        self.output = np.dot(self.input, self.weights) + self.bias;
        return self.output;

    # computes dE/dW, dE/dB for a given output_error=dE/dY. Returns input_error=dE/dX.
    def backward_propagation(self, output_error, learning_rate):
        input_error = np.dot(output_error, self.weights.T);
        dWeights = np.dot(self.input.T, output_error);
        # dBias = output_error
        
        # update parameters
        self.weights -= learning_rate * dWeights;
        self.bias -= learning_rate * output_error;
        return input_error;

激活層

到目前爲止所作的計算都徹底是線性的。用這種模型學習是沒有但願的，須要經過將非線性函數應用於某些層的輸出來爲模型添加非線性。

如今咱們須要爲這種新類型的層（激活層）重作整個過程！

不用擔憂，由於此時沒有可學習的參數，過程會快點，只須要計算∂E/∂X。

咱們將f和f'分別稱爲激活函數及其導數。

前向傳播

正如將看到的，它很是簡單。對於給定的輸入X，輸出是關於每一個X元素的激活函數，這意味着輸入和輸出具備相同的大小。

反向傳播

給出∂E/∂Y，須要計算∂E/∂X

注意，這裏咱們使用兩個矩陣之間的每一個元素乘法（而在上面的公式中，它是一個點積）

編碼實現激活層

激活層的代碼很是簡單：

from layer import Layer
# inherit from base class Layer
class ActivationLayer(Layer):
    # input_shape = (1,i)   i the number of input neurons
    def __init__(self, input_shape, activation, activation_prime):
        self.input_shape = input_shape;
        self.output_shape = input_shape;
        self.activation = activation;
        self.activation_prime = activation_prime;

    # returns the activated input
    def forward_propagation(self, input):
        self.input = input;
        self.output = self.activation(self.input);
        return self.output;

    # Returns input_error=dE/dX for a given output_error=dE/dY.
    # learning_rate is not used because there is no "learnable" parameters.
    def backward_propagation(self, output_error, learning_rate):
        return self.activation_prime(self.input) * output_error;

能夠在單獨的文件中編寫一些激活函數以及它們的導數，稍後將使用它們構建ActivationLayer：

import numpy as np
# activation function and its derivative
def tanh(x):
    return np.tanh(x);

def tanh_prime(x):
    return 1-np.tanh(x)**2;

損失函數

到目前爲止，對於給定的層，咱們假設給出了∂E/∂Y（由下一層給出）。可是最後一層怎麼獲得∂E/∂Y？咱們經過簡單地手動給出最後一層的∂E/∂Y，它取決於咱們如何定義偏差。

網絡的偏差由本身定義，該偏差衡量網絡對給定輸入數據的好壞程度。有許多方法能夠定義偏差，其中一種最多見的叫作MSE - Mean Squared Error：

其中y *和y分別表示指望的輸出和實際輸出。你能夠將損失視爲最後一層，它將全部輸出神經元吸取並將它們壓成一個神經元。與其餘每一層同樣，須要定義∂E/∂Y。除了如今，咱們終於獲得E！

如下是兩個python函數，能夠將它們放在一個單獨的文件中，將在構建網絡時使用。

import numpy as np

# loss function and its derivative
def mse(y_true, y_pred):
    return np.mean(np.power(y_true-y_pred, 2));

def mse_prime(y_true, y_pred):
    return 2*(y_pred-y_true)/y_true.size;

網絡類

到如今幾乎完成了！咱們將構建一個Network類來建立神經網絡，很是容易，相似於第一張圖片！

我註釋了代碼的每一部分，若是你掌握了前面的步驟，那麼理解它應該不會太複雜。

from layer import Layer

class Network:
    def __init__(self):
        self.layers = [];
        self.loss = None;
        self.loss_prime = None;

    # add layer to network
    def add(self, layer):
        self.layers.append(layer);

    # set loss to use
    def use(self, loss, loss_prime):
        self.loss = loss;
        self.loss_prime = loss_prime;

    # predict output for given input
    def predict(self, input):
        # sample dimension first
        samples = len(input);
        result = [];

        # run network over all samples
        for i in range(samples):
            # forward propagation
            output = input[i];
            for layer in self.layers:
                # output of layer l is input of layer l+1
                output = layer.forward_propagation(output);
            result.append(output);

        return result;

    # train the network
    def fit(self, x_train, y_train, epochs, learning_rate):
        # sample dimension first
        samples = len(x_train);

        # training loop
        for i in range(epochs):
            err = 0;
            for j in range(samples):
                # forward propagation
                output = x_train[j];
                for layer in self.layers:
                    output = layer.forward_propagation(output);

                # compute loss (for display purpose only)
                err += self.loss(y_train[j], output);

                # backward propagation
                error = self.loss_prime(y_train[j], output);
                # loop from end of network to beginning
                for layer in reversed(self.layers):
                    # backpropagate dE
                    error = layer.backward_propagation(error, learning_rate);

            # calculate average error on all samples
            err /= samples;
            print('epoch %d/%d   error=%f' % (i+1,epochs,err));

構建一個神經網絡

最後！咱們可使用咱們的類來建立一個包含任意數量層的神經網絡！爲了簡單起見，我將向你展現如何構建......一個XOR。

from network import Network
from fc_layer import FCLayer
from activation_layer import ActivationLayer
from losses import *
from activations import *
import numpy as np

# training data
x_train = np.array([[[0,0]], [[0,1]], [[1,0]], [[1,1]]]);
y_train = np.array([[[0]], [[1]], [[1]], [[0]]]);

# network
net = Network();
net.add(FCLayer((1,2), (1,3)));
net.add(ActivationLayer((1,3), tanh, tanh_prime));
net.add(FCLayer((1,3), (1,1)));
net.add(ActivationLayer((1,1), tanh, tanh_prime));

# train
net.use(mse, mse_prime);
net.fit(x_train, y_train, epochs=1000, learning_rate=0.1);

# test
out = net.predict(x_train);
print(out);

一樣，我認爲不須要強調不少事情，只須要仔細訓練數據，應該可以先得到樣本維度。例如，對於xor問題，樣式應爲（4,1,2）。

結果

$ python xor.py epoch 1/1000 error=0.322980 epoch 2/1000 error=0.311174 epoch 3/1000 error=0.307195 ... epoch 998/1000 error=0.000243 epoch 999/1000 error=0.000242 epoch 1000/1000 error=0.000242 [array([[ 0.00077435]]), array([[ 0.97760742]]), array([[ 0.97847793]]), array([[-0.00131305]])]

卷積層

這篇文章開始很長，因此我不會描述實現卷積層的全部步驟。可是，這是我作的一個實現：

from layer import Layer
from scipy import signal
import numpy as np

# inherit from base class Layer
# This convolutional layer is always with stride 1
class ConvLayer(Layer):
    # input_shape = (i,j,d)
    # kernel_shape = (m,n)
    # layer_depth = output depth
    def __init__(self, input_shape, kernel_shape, layer_depth):
        self.input_shape = input_shape;
        self.input_depth = input_shape[2];
        self.kernel_shape = kernel_shape;
        self.layer_depth = layer_depth;
        self.output_shape = (input_shape[0]-kernel_shape[0]+1, input_shape[1]-kernel_shape[1]+1, layer_depth);
        self.weights = np.random.rand(kernel_shape[0], kernel_shape[1], self.input_depth, layer_depth) - 0.5;
        self.bias = np.random.rand(layer_depth) - 0.5;

    # returns output for a given input
    def forward_propagation(self, input):
        self.input = input;
        self.output = np.zeros(self.output_shape);

        for k in range(self.layer_depth):
            for d in range(self.input_depth):
                self.output[:,:,k] += signal.correlate2d(self.input[:,:,d], self.weights[:,:,d,k], 'valid') + self.bias[k];

        return self.output;

    # computes dE/dW, dE/dB for a given output_error=dE/dY. Returns input_error=dE/dX.
    def backward_propagation(self, output_error, learning_rate):
        in_error = np.zeros(self.input_shape);
        dWeights = np.zeros((self.kernel_shape[0], self.kernel_shape[1], self.input_depth, self.layer_depth));
        dBias = np.zeros(self.layer_depth);

        for k in range(self.layer_depth):
            for d in range(self.input_depth):
                in_error[:,:,d] += signal.convolve2d(output_error[:,:,k], self.weights[:,:,d,k], 'full');
                dWeights[:,:,d,k] = signal.correlate2d(self.input[:,:,d], output_error[:,:,k], 'valid');
            dBias[k] = self.layer_depth * np.sum(output_error[:,:,k]);

        self.weights -= learning_rate*dWeights;
        self.bias -= learning_rate*dBias;
        return in_error;

它背後的數學實際上並不複雜！這是一篇很好的文章，你能夠找到∂E/∂W，∂E/∂B和∂E/∂X的解釋和計算。

若是你想驗證你的理解是否正確，請嘗試本身實現一些網絡層，如MaxPooling，Flatten或Dropout

GitHub庫

你能夠在GitHub庫中找到用於該文章的完整代碼。

原文連接