版權宣告：本文為博主ExcelMann的原創文章，未經博主允許不得轉載。

python實現BP神經網路識別Mnist資料集

作者：ExcelMann，轉載需註明。

話不多說，直接貼程式碼，程式碼有註釋。

# Author:Xuangan, Xu
# Data:2020-10-28

"""
BP神經網路
-----------------
利用梯度下降法，實現MNIST手寫體數字識別
資料集：Mnist資料集
"""

import os
import struct
import math
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

def load_mnist(path, kind='train'): # kind預設引數值為'train'
    """
        從指定的路徑path中讀取資料
        :param path:為檔案路徑
        :param kind:為檔案的型別（train/t10k）
        :return images為nxm維的陣列，n為樣本個數，m為樣本的特徵數，也即為畫素個數；
                labels為images對應的標籤；
    """
    labels_path = os.path.join(path,
                               '%s-labels.idx1-ubyte'
                               % kind)
    images_path = os.path.join(path,
                               '%s-images.idx3-ubyte'
                               % kind)
    with open(labels_path, 'rb') as lbpath:
        magic, n = struct.unpack('>II',
                                 lbpath.read(8))
        labels = np.fromfile(lbpath,
                             dtype=np.uint8)

    with open(images_path, 'rb') as imgpath:
        magic, num, rows, cols = struct.unpack('>IIII',
                                               imgpath.read(16))
        images = np.fromfile(imgpath,
                             dtype=np.uint8).reshape(len(labels), 784)

    return images, labels

def sigmoid(x):
    """
    sigmoid函式
    :param x: 輸入值
    :return: 返回啟用函式的值
    """
    return 1.0/(1.0+np.exp(-x))

# 定義神經網路類
class neuralNetwork:

    def __init__(self,inputNodes,hiddenNodes,outputNodes,learningRate):
        """
        :param inputNodes:輸入層節點個數
        :param hiddenNodes:隱藏層結點個數
        :param outputNodes:輸出層結點個數
        :param learningRate:學習率
        """
        self.iNodes = inputNodes
        self.hNodes = hiddenNodes
        self.oNodes = outputNodes
        self.lr = learningRate
        # 初始化網路權重
        self.w_1 = np.random.uniform(-0.5,0.5,(inputNodes,hiddenNodes))
        self.w_2 = np.random.uniform(-0.5, 0.5, (hiddenNodes,outputNodes))
        # 初始化閾值
        #self.thod_1 = np.random.randn(hiddenNodes)
        self.thod_1 = np.random.uniform(-0.5,0.5,hiddenNodes)
        #self.thod_2 = np.random.randn(outputNodes)
        self.thod_2 = np.random.uniform(-0.5,0.5,outputNodes)

    def culMse(self,pre_y,y):
        """
        計算均方誤差
        :param pre_y: 預測值
        :param y: 期望值
        """
        totalError = 0
        for i in range(len(y)):
            totalError += (y[i]-pre_y[i])**2
        return totalError/2.0

    def culCrossEntropyLoss(self,pre_y,y):
        """
        計算交叉熵損失函式
        :param pre_y: 預測值
        :param y: 期望值
        """
        total_error = 0
        for j in range(len(y)):
            total_error += y[j]*math.log(pre_y[j])
        return (-1)*total_error

    def forward(self,input_data):
        """
        前向傳播
        :param input_data:輸入資料（1X784的一維陣列）
        :return: 返回輸出層的資料
        """
        # 計算隱含層的輸入值以及輸出值（用到了sigmoid啟用函式），結果為大小15的陣列
        hidden_input = input_data.dot(self.w_1)
        hidden_output = sigmoid(hidden_input-self.thod_1)

        # 計算輸出層的輸入值以及輸出值（用到了sigmoid啟用函式），結果為大小10的陣列
        final_input = hidden_output.dot(self.w_2)
        final_output = sigmoid(final_input-self.thod_2)
        return final_output,hidden_output

    def backward(self,target,input_data,hidden_output,final_output):
        """
        反向傳播演算法
        """
        g = np.zeros(self.oNodes)  # 第j個輸出層結點對應的廣義偏差
        e = np.zeros(self.hNodes)  # 第h個隱藏層結點對應的廣義偏差
        # 更新隱藏層與輸出層之間的權重w_2
        for h in range(self.hNodes):
            for j in range(self.oNodes):
                # 計算第j個輸出層結點對應的廣義偏差
                g[j] = (target[j]-final_output[j])*final_output[j]*(1-final_output[j])
                # 計算w_hj的權重梯度
                gradient_w_hj = self.lr*g[j]*hidden_output[h]
                # 梯度下降法更新權重引數值
                self.w_2[h][j] = self.w_2[h][j]+gradient_w_hj

        # 更新輸出層的閾值
        for j in range(self.oNodes):
            # 計算第j個輸出層結點的閾值梯度
            gradient_thod_j = (-1) * self.lr * g[j]
            # 梯度下降法更新閾值引數
            self.thod_2[j] = self.thod_2[j] + gradient_thod_j

        # 求第h個隱藏層結點對應的廣義偏差
        for h in range(self.hNodes):
            totalBackValue = 0
            for j in range(self.oNodes):
                totalBackValue += self.w_2[h][j]*g[j]
            e[h] = hidden_output[h]*(1-hidden_output[h])*totalBackValue

        # 更新輸入層與隱藏層之間的權重w_1
        for i in range(self.iNodes):
            for h in range(self.hNodes):
                # 計算w_ih的權重梯度
                gradient_w_ih = self.lr*e[h]*input_data[i]
                # 梯度下降法更新權重引數值
                self.w_1[i][h] = self.w_1[i][h]+gradient_w_ih

        # 更新隱藏層的閾值
        for h in range(self.hNodes):
            # 計算第h個隱藏層結點的閾值梯度
            gradient_thod_h = (-1)*self.lr*e[h]
            # 梯度下降法更新閾值引數
            self.thod_1[h] += gradient_thod_h

    def train(self,input_data,target):
        """
        訓練網路引數
        :param input_data:輸入資料（1X784的一維陣列）
        :param target:標籤陣列（1X10的一維陣列）
        """
        final_output,hidden_output = self.forward(input_data)

        self.backward(target,input_data,hidden_output,final_output)

        return final_output


    def estimate(self,test_data,test_label):
        """
        預測結果
        :param test_data: 輸入資料，nX784維，n為輸入資料個數
        :param test_label: 測試資料的標籤值
        :return: 返回準確率
        """
        correct_num = 0 # 預測正確個數
        for i in range(test_data.shape[0]):
            # 計算得到預測結果，preV為網路模型輸出值
            preV,hiddenV = self.forward(test_data[i])
            pre_y = np.argmax(preV)  # 最大可能性的即為預測的值
            label = np.argmax(test_label[i])
            # 預測結果與標籤值對比，計算準確率
            if(pre_y == label):
                correct_num += 1
        return correct_num/test_data.shape[0]

    def SGD(self,train_data,train_label):
        # 定義迭代次數epochs，並執行訓練過程
        epochs = 200
        # 批處理的量大小
        batch_size = 200
        for e in range(epochs):
            # 從樣本中隨機挑選出100個樣本作為訓練集
            batch_mask = np.random.choice(train_data.shape[0], batch_size)
            batch_data = train_data[batch_mask]
            batch_label = train_label[batch_mask]
            # 遍歷批處理樣本
            for i, data in enumerate(batch_data):
                # 執行模型訓練
                final_output = self.train(data, batch_label[i])
                if (i % 40 == 0):
                    # 計算loss
                    mse = self.culMse(final_output, batch_label[i])
                    print(f'epoch:{e},i:{i},loss:{mse}')

if __name__ == "__main__":
    # 通過tensorflow讀取mnist資料，並對讀取到的資料進行處理
    mnist = tf.keras.datasets.mnist
    (train_x,train_y),(test_x,test_y) = mnist.load_data()
    # 建立以下陣列，用於儲存處理後的訓練和測試資料
    train_data = np.zeros((60000,784))
    train_label = np.zeros((60000,10))
    test_data = np.zeros((10000,784))
    test_label = np.zeros((10000,10))
    # 處理資料，使得影像資料的值範圍為0-1，並將標籤改為one-hot型別
    for i in range(60000):  # 處理訓練資料
        train_data[i] = (np.array(train_x[i]).flatten())/255
        temp = np.zeros(10)
        temp[train_y[i]] = 1
        train_label[i] = temp
    for i in range(10000):  # 處理測試資料
        test_data[i] = (np.array(test_x[i]).flatten())/255
        temp = np.zeros(10)
        temp[test_y[i]] = 1
        test_label[i] = temp

    # 初始化神經網路結點個數和學習率
    input_nodes = 784
    hidden_nodes = 15
    output_nodes = 10
    learningRate = 0.15
    # 建立神經網路物件network
    network = neuralNetwork(input_nodes,hidden_nodes,output_nodes,learningRate)
    # 執行隨機梯度下降演算法
    network.SGD(train_data,train_label)
    
    # 測試階段，輸出精確率
    accuracy = network.estimate(test_data,test_label)
    print(f'test_data_Accuracy:{accuracy}')