神經元
想一想便知道，當一個人捏你一下以至于你會痛得叫起來的力度便是神經元的閾值，而我們構建的時候也是把這種現象抽象成一個函式，叫作激活函式，
而這里便是我們使用sigmoid函式的原因，它是一個很簡單的函式，平滑更接近顯示，
? $$y=\frac{1}{1+e^{-x}}$$
神經網路傳遞信號
神經網路便是通過一個一個神經元連接，使用權值x輸入的和在通過sigmoid函式得到最終的輸出值，然后一層一層的傳遞下去，
\[O = sigmoid(W\cdot I) \]
其中，\(O\)為輸出矩陣，\(W\)為權值矩陣，\(I\)為輸入矩陣，
舉個栗子：
假設我們設定一個三層神經網路，分別為輸入層，隱藏層（注意：不管我們中間有多少層，中間的都叫隱藏層，我們這里隱藏層只有一層），輸出層，
1.輸入層->隱藏層：我們輸入矩陣是一個(3x1)的矩陣，那么我們設定四個權值，那么我們的第一個權值矩陣（就是輸入層->隱藏層的）的維度也就為(4x3)，這時我們相乘也就得到輸出矩陣(4x1)，進行下一步時，這個(4x1)的輸出矩陣就變成了輸入；
2.隱藏層->輸出層：這是我們的輸入矩陣是一個(4x1)的矩陣，然后我們要求輸出層輸出為兩個值，那么我們第二個權值矩陣（就是隱藏層->輸出層的）的維度也就為(2x4)，這時我們相乘也就得到輸出矩陣(2x1)，也就為最終的結果了，
反向傳播
現在我們已經可以收到由前面的層傳輸過來的結果了，但答案肯定是不準的，那么我們該如何進行改進呢？
毫無疑問，首先我們要計算誤差，假設真實值為t，輸出值為o，那么誤差e就為:
\[e=t-o \]
我們按照上圖來進行舉例說明，
1.更新誤差
那么，隱藏層的誤差如何確定呢？
我們使用鏈接\(w_{1,1}\)和鏈接\(w_{2,1}\)上的分割誤差之和來進行更新，也就是
\[e_{hidden,1}=e_{output,1}*\frac{w_{1,1}}{w_{1,1}+w_{2,1}}+e_{output,2}*\frac{w_{1,2}}{w_{1,2}+w_{2,2}} \]
我們也進行帶值進行計算
\[0.8*\frac{2}{2+3}+0.5*\frac{1}{1+4}=0.42 \]
2.使用矩陣進行更新
我們發現上面的公式應用到矩陣運算會很復雜，我們究其本質，最重要的事情是輸出誤差與鏈接權重\(w_{ij}\)的乘法，較大的權重就意味著攜帶較多的輸出誤差給隱藏層，這些分數的分母是一種歸一化因子，如果我們忽略這種因子，那么我們僅僅失去后潰誤差的大小，
也就是這里我們使用\(e_1*w_{1,1}\)來代替\(e_1*w_{1,1}/(w_{1,1}+w_{2,1})\) ，那么我們就可以很容易的進行矩陣運算進行誤差更新了，
\[error_{hidden}=w^T_{hidden\_output}\cdot error_{output} \]
3.更新權重
在神經網路中，我們采用梯度下降法來尋找最優的權重值，神經網路本身的輸出函式部署一個誤差函式，但我們知道，由于誤差是目標訓練值與實際輸出值之間的差值，因此我們可以很容易的構建誤差函式，即
\[(目標值-實際值)^2 \]
為什么我們要構建平方項呢？為何不用絕對值誤差呢？原因有三
- 使用誤差的平方，我們可以很容易的使用代數計算出梯度下降的斜率；
- 誤差函式平滑連續，這是的梯度下降法很好地發揮作用，沒有間斷，也沒有突然的跳躍；
- 越接近最小值，梯度越小，這意味著，如果我們使用這個函式調節步長，超調的風險就會變得很小，
現在我們要更新\(w_{j,k}\)的權值，那么來推導一下它的更新公式：
首先有
\[\frac{\partial E}{\partial W_{j,k}} = \frac{\partial}{\partial W_{j,k}}(t_k-o_k)^2 \]
然后根據鏈式法則得到：
\[\frac{\partial E}{\partial W_{j,k}} = \frac{\partial E}{\partial o_k} \cdot \frac{\partial o_k}{\partial W_{j,k}} \]
然后我們對其求偏導：
\[\frac{\partial E}{\partial W_{j,k}} = -2(t_k-o_k) \cdot \frac{\partial o_k}{\partial W_{j,k}}\\ = -2(t_k-o_k) \cdot \frac{\partial}{\partial W_{j,k}}sigmoid(\sum_{j}w_{j,k}\cdot o_j)\\ = -2(t_k-o_k) \cdot sigmoid(\sum_{j}w_{j,k}\cdot o_j)(1-sigmoid(\sum_{j}w_{j,k}\cdot o_j)) \cdot \frac{\partial}{\partial W_{j,k}}(\sum_{j}w_{j,k}\cdot o_j)\\ = -2(t_k-o_k) \cdot sigmoid(\sum_{j}w_{j,k}\cdot o_j)(1-sigmoid(\sum_{j}w_{j,k}\cdot o_j)) \cdot o_j\]
這樣我們就得到了最后的權重更新公式：
\[new W_{j,k} = oldW_{j,k} - \alpha \cdot \frac{\partial E}{\partial W_{j,k}} \]
其中：
\[\frac{\partial E}{\partial W_{j,k}} = \Delta w_{j,k} = \alpha \cdot E_k \cdot O_k(1-O_k) \cdot O_j^T \]
輸入與輸出
1.輸入
我們觀察sigmoid函式注意到，當輸入值變大，激活函式也就會越來越平坦，權重的改變取決于激活函式的梯度，小梯度也就意味著限制了神經網路的學習能力，這就是所謂的飽和神經網路，因此，我們要盡量保持小的輸入，
但有趣的是，當輸入信號太小，計算機便會損失精度，所以我們要保持輸入范圍在0.0~1.0之間，但輸入為0的話會將\(o_j\)設定為0，這樣的權重更新運算式就會等于0，從而造成學習能力的喪失，我們需要加上一個小小的偏移，例如0.01，避免輸入0帶來的麻煩，
2.輸出
我們使用激活函式得到的值的范圍會被限制在0~1之間，注意：邏輯函式甚至不能取到1.0，只能接近于1.0.數學家們稱之為漸進于1.0.
因此，我們需要調整目標值，匹配激活函式的可能輸出，常見的使用范圍為0.0~1.0之間，但我們是取不到0.0和1.0的，所以這里我們也要進行偏移，例如0.01~0.99.
隨機初始權重
和輸入輸出一樣，初始的權重設定也要遵從同樣地原則，過大的初始權重會造成大的信號傳遞給激活函式，導致網路飽和，從而降低學習到更好的權重的能力，因此應該避免大的初始權重值，
我們可以從-1.0~+1.0之間隨機均勻地挑選初始權重，而我們也希望初始權重的分布是均勻的，經過數學家們的證明，我們有一個比較好的挑選方式，那就是從均值為0、標準方差等于節點傳入鏈接數量平方根倒數的正態分布中進行采樣，
總而言之，我們要禁止將初始權重設定為0或者將初始權重設定為像痛得恒定值，這樣會很糟糕，
代碼實作
import numpy as np
import scipy.special
import matplotlib.pyplot as plt
# neural network class definition
class NeuralNetwork:
def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
# set number of nodes in each input, hidden, output layer
self.inodes = inputnodes
self.hnodes = hiddennodes
self.onodes = outputnodes
# learning rate
self.lr = learningrate
# 初始權重矩陣
self.wih = np.random.normal(0.0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes))
self.who = np.random.normal(0.0, pow(self.onodes, -0.5), (self.onodes, self.hnodes))
# 激活函式
self.activation_function = lambda x: scipy.special.expit(x)
pass
def train(self, inputs_list, targets_list):
# 輸入
inputs = np.array(inputs_list, ndmin=2).T
targets = np.array(targets_list, ndmin=2).T
# 隱藏層計算
hidden_inputs = np.dot(self.wih, inputs)
hidden_outputs = self.activation_function(hidden_inputs)
# 輸出層計算
final_inputs = np.dot(self.who, hidden_outputs)
final_outputs = self.activation_function(final_inputs)
# 誤差計算
output_errors = targets - final_outputs
hidden_errors = np.dot(self.who.T, output_errors)
# 反向傳播更新權值
self.who += self.lr * np.dot((output_errors * final_outputs * (1.0 - final_outputs)), np.transpose(hidden_outputs))
self.wih += self.lr * np.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), np.transpose(inputs))
pass
def query(self, inputs_list):
# 輸入
inputs = np.array(inputs_list, ndmin=2).T
# 隱藏層計算
hidden_inputs = np.dot(self.wih, inputs)
hidden_outputs = self.activation_function(hidden_inputs)
# 輸出層計算
final_inputs = np.dot(self.who, hidden_outputs)
final_outputs = self.activation_function(final_inputs)
return final_outputs
if __name__ == '__main__':
input_nodes = 784
hidden_nodes = 200
output_nodes = 10
learning_rate = 0.2
nn = NeuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate)
# 加載資料
train_data_file = open("./mnist_train.csv", "r")
train_data_list = train_data_file.readlines()
train_data_file.close()
print("資料讀取完畢")
# 可視化
# all_values = train_data_list[0].split(',')
# image_array = np.asfarray(all_values[1:]).reshape((28, 28))
# plt.imshow(image_array, cmap="Greys", interpolation='None')
# plt.show()
epochs = 2
for e in range(epochs):
print("\t===== epochs %d =====\t" % (e+1))
for record in train_data_list:
all_values = record.split(',')
inputs = (np.asfarray(all_values[1:]) / 255 * 0.99) + 0.01
targets = np.zeros(output_nodes) + 0.01
targets[int(all_values[0])] = 0.99
nn.train(inputs, targets)
# 預測
test_data_file = open("./mnist_test.csv", "r")
test_data_list = test_data_file.readlines()
test_data_file.close()
print(len(test_data_list))
t_num = 0
for line in test_data_list:
all_values = line.split(',')
y = all_values[0]
y_pred = np.argmax(nn.query(np.asfarray(all_values[1:]) / 255 * 0.99 + 0.01))
if int(y) == int(y_pred):
t_num += 1
print(t_num)
print(t_num * 1.0 / len(test_data_list))
這份三層神經網路對mnist手寫資料集能達到97%的準確度，
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/47683.html
標籤：其他