反向傳播（BP）網絡的mnist實例

BP網絡——前饋神經網絡

（Back Propgation Networks）

本文將實現一個最簡單的三層神經網絡

其中，損失函數是線性函數，激勵函數是sigmoid函數。

代碼的實現中，採用的是隨機梯度下降法。

計算導數的方法可以參考圖片，有興趣的小夥伴可以參考，自行推導：

隨機梯度下降法的原理

代碼如下所示：

#!/user/bin/env python3
# -*- coding: utf-8 -*-
import random

import numpy as np

#定義神經網絡結構
class Network(object):
    def __init__(self, sizes):
        # 網絡層數
        self.num_layers = len(sizes)
        # 每層神經元的個數
        self.sizes = sizes
        # 初始化每層的偏置
        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
        # 初始化每層的權重
        self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]

    def feedforward(self, a):
        for b, w in zip(self.biases, self.weights):
            a = sigmoid(np.dot(w, a) + b)
        return a

    # 梯度下降
    def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None):
        if test_data:
            n_test = len(test_data)
        # 訓練數據總個數
        n = len(training_data)

        # 開始訓練，循環每一個epochs
        for j in range(epochs):  # 在python2.7中爲xrange
            # 洗牌 打亂訓練數據
            random.shuffle(training_data)

            # mini_batch
            mini_batches = [training_data[k:k+mini_batch_size] for k in range(0, n, mini_batch_size)]

            # 訓練mini_batch
            for mini_batch in mini_batches:
                self.update_mini_batch(mini_batch, eta)

            if test_data:
                print("Epoch {0}: {1} / {2}".format(j, self.evaluate(test_data), n_test))
            print("Epoch {0} complete".format(j))

    def update_mini_batch(self, mini_batch, eta):
        # 保存每層偏導
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]

        # 訓練一個mini_batch
        for x, y in mini_batch:
            delta_nabla_b, delta_nabla_w = self.update(x, y)

            # 保存一次訓練網絡中每層的偏導
            nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
            nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]

        # 更新權重和偏置 Wn+1 = Wn - eta * nw
        self.weights = [w - (eta / len(mini_batch)) * nw for w, nw in zip(self.weights, nabla_w)]
        self.biases = [b - (eta / len(mini_batch)) * nb for b, nb in zip(self.biases, nabla_b)]

    # 前向傳播
    def update(self, x, y):
        # 保存每層偏導
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        activation = x  # 保存的輸入（訓練數據）

        # 保存每一層的激勵值a=sigmoid(z)
        activations = [x]

        # 保存每一層的z=wx+b
        zs = []
        # 前向傳播
        for b, w in zip(self.biases, self.weights):
            # 計算每層的z
            z = np.dot(w, activation) + b

            # 保存每層的z
            zs.append(z)

            # 計算每層的a
            activation = sigmoid(z)

            # 保存每一層的a
            activations.append(activation)
        # 反向更新
        # 計算最後一層的誤差
        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])

        # 最後一層權重和偏置的導數
        nabla_b[-1] = delta
        nabla_w[-1] = np.dot(delta, activations[-2].T)

        # 倒數第二層一直到第一層 權重和偏置的導數
        for l in range(2, self.num_layers):
            z = zs[-l]

            sp = sigmoid_prime(z)

            # 當前層的誤差
            delta = np.dot(self.weights[-l+1].T, delta) * sp

            # 當前層的偏置和權重的導數
            nabla_b[-l] = delta
            nabla_w[-l] = np.dot(delta, activations[-l-1].T)

        return (nabla_b, nabla_w)

    def evaluate(self, test_data):
        test_results = [(np.argmax(self.feedforward(x)), y) for (x, y) in test_data]
        return  sum(int(x == y) for x, y in test_results)

    def cost_derivative(self, output_activation, y):
        return (output_activation - y)

# sigmoid激勵函數
def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))

def sigmoid_prime(z):
    return sigmoid(z) * (1-sigmoid(z))

if __name__ == "__main__":
    import mnist_loader

    training_data, validation_data, test_data = mnist_loader.load_data_wrapper()

    # 28*28=784個像素， 可以定義30個神經元， 共有10種分類
    net = Network([784, 30, 10])
    net.SGD(training_data, 30, 10, 0.5, test_data=test_data)

由於進行預測的時候用的是mnist數據集
所以需要下載mnist.pkl.gz

mnist.pkl.gz下載地址爲：mnist.pkl.gz

小夥伴千萬不要下錯哦，之前我下的就是個數據不夠的，結果害得我查了好久爲什麼代碼會出錯，哭唧唧。。。

注：mnist_loader.py是一個python文件（如下）

#!/user/bin/env python3
# -*- coding: utf-8 -*-
"""
mnist_loader
~~~~~~~~~~~~

A library to load the MNIST image data.  For details of the data
structures that are returned, see the doc strings for ``load_data``
and ``load_data_wrapper``.  In practice, ``load_data_wrapper`` is the
function usually called by our neural network code.
"""

#### Libraries
# Standard library
import pickle
import gzip

import numpy as np
def load_data():
    f = gzip.open('data/mnist.pkl.gz', 'rb')
    training_data, validation_data, test_data = pickle.load(f, encoding='bytes')
    f.close()
    return (training_data, validation_data, test_data)

def load_data_wrapper():
    tr_d, va_d, te_d = load_data()
    training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]
    training_results = [vectorized_result(y) for y in tr_d[1]]
    training_data = list(zip(training_inputs, training_results))
    validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]
    validation_data = list(zip(validation_inputs, va_d[1]))
    test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]
    test_data = list(zip(test_inputs, te_d[1]))
    return (training_data, validation_data, test_data)

def vectorized_result(j):
    e = np.zeros((10, 1))
    e[j] = 1.0
    return e

大家一定要注意python版本的問題，我用的是python3，和python2還是有差別的，比如以下幾點：

①python3中沒有xrange，python3中的range實際上等同於python2中的xrange。

②好像pickle的使用也有所不同，在python2中是cpickle，但python3中是pickle；
很多人出現了一個問題，就是python3使用pickle.load()方法時，需要加上pickle.load(f, encoding='bytes')encoding編碼方式才能解決。

③python2中的zip方法和python3不同，python3的zip()不是列表，所以在上述代碼的load_data_wrapper()方法中，zip出現的地方需要加上list()方法。

注：

代碼仍然有很多可以進行提升的部分，見下一篇博客：反向傳播（BP）網絡的mnist實例（提升篇）