著作權宣告：本文為博主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}')
轉載請註明出處，本文鏈接：https://www.uj5u.com/qukuanlian/222541.html
標籤：區塊鏈
上一篇：表面模糊濾鏡