神經網絡框架使用方法及設計思想
- 在框自己手寫架上基本模仿pytorch，用以學習神經網絡的基本算法，如前向傳播、反向傳播、各種層、各種激活函數
- 采用面向對象的思想進行編程，思路較為清晰
- 想要神經網絡的同學們可以參考一下
- 代碼大體框架較為清晰，但不否認存在丑陋的部分，以及對于pytorch的拙劣模仿
項目介紹
手寫數字識別，使用MINST數據集
訓練30輪可以達到93%準確度，訓練500輪左右達到95%準確度無法繼續上升
使用循環神經網絡RNN，用sin的曲線預測cos的曲線
目前仍有bug，無法正常訓練
框架介紹
- 與框架有關的代碼都放在了mtorch文件夾中
- 使用流程
與pytorch相似，需要定義自己的神經網絡、損失函數、梯度下降的優化算法等等
在每一輪的訓練中，先獲取樣本輸入將其輸入到自己的神經網絡中獲取輸出。然后將預測結果和期望結果交給損失函數計算loss，并通過loss進行梯度的計算，最后通過優化器對神經網絡的參數進行更新。
結合代碼理解更佳👇：
以下是使用MINST數據集的手寫數字識別的主體代碼
# 定義網絡 define neural network
class DigitModule(Module):
def __init__(self):
# 計算順序就會按照這里定義的順序進行
sequential = Sequential([
layers.Linear2(in_dim=ROW_NUM * COLUM_NUM, out_dim=16, coe=2),
layers.Relu(16),
layers.Linear2(in_dim=16, out_dim=16, coe=2),
layers.Relu(16),
layers.Linear2(in_dim=16, out_dim=CLASS_NUM, coe=1),
layers.Sigmoid(CLASS_NUM)
])
super(DigitModule, self).__init__(sequential)
module = DigitModule() # 創建模型 create module
loss_func = SquareLoss(backward_func=module.backward) # 定義損失函數 define loss function
optimizer = SGD(module, lr=learning_rate) # 定義優化器 define optimizer
for i in range(EPOCH_NUM): # 共訓練EPOCH_NUM輪
trainning_loss = 0 # 計算一下當前一輪訓練的loss值，可以沒有
for data in train_loader: # 遍歷所有樣本，train_loader是可迭代對象，保存了數據集中所有的數據
imgs, targets = data # 將數據拆分成圖片和標簽
outputs = module(imgs) # 將樣本的輸入值輸入到自己的神經網絡中
loss = loss_func(outputs, targets, transform=True) # 計算loss / calculate loss
trainning_loss += loss.value
loss.backward() # 通過反向傳播計算梯度 / calculate gradiant through back propagation
optimizer.step() # 通過優化器調整模型參數 / adjust the weights of network through optimizer
if i % TEST_STEP == 0: # 每訓練TEST_STEP輪就測試一下當前訓練的成果
show_effect(i, module, loss_func, test_loader, i // TEST_STEP)
print("{} turn finished, loss of train set = {}".format(i, trainning_loss))
接下來逐個介紹編寫的類，這些類在pytorch中都有同名同功能的類，是仿照pytorch來的：
與pytorch不同，只能有一個Sequential類（序列），在該類中定義好神經網絡的各個層和順序，然后傳給Module類的構造函數
正向傳播：調用Sequential的正向傳播
反向傳播：調用Sequential的反向傳播
目前為止，這個類的大部分功能與Sequential相同，只是套了個殼保證與pytorch相同
有不同的loss函數，構造函數需要給他指定自己定義的神經網絡的反向傳播函數
調用loss函數會返回一個Loss類的對象，該類記錄了loss值。
通過調用Loss類的.backward()方法就可以實現反向傳播計算梯度
內部機制：
內部其實就是調用了自己定義的神經網絡的反向傳播函數
也算是對于pytorch的一個拙劣模仿，完全沒必要，直接通過Module調用就好
目前只實現了隨機梯度下降SGD
構造函數的參數是自己定義的Module。在已經計算過梯度之后，調用optimizer.step()改變Module內各個層的參數值
內部機制：
目前由于只有SGD一種算法，所以暫時也只是一個拙劣模仿
就是調用了一下Module.step()，再讓Module調用Sequential.step()，最后由Sequential調用內部各個層的Layer.step()實現更新
梯度值在loss.backward的時候計算、保存在各個層中了
有許多不同的層
共性
前向傳播：
接受一個輸入進行前向傳播計算，輸出一個輸出
會將輸入保存起來，在反向傳播中要用
反向傳播：
接受前向傳播的輸出的梯度值，計算自身參數（如Linear中的w和b）的梯度值并保存起來
輸出值為前向傳播的輸入的梯度值，用來讓上一層（可能沒有）繼續進行反向傳播計算
這樣不同的層之間就可以進行任意的拼裝而不妨礙前向傳播、反向傳播的進行了
.step方法
更新自身的參數值（也可能沒有，如激活層、池化層）
這個類也是繼承自Layer，可以當作一層來使用
它把多個層按照順序拼裝到一起，在前向、反向傳播時按照順序進行計算
結合它的forward、backward方法來理解：
def forward(self, x):
out = x
for layer in self.layers:
out = layer(out)
return out
def backward(self, output_gradiant):
layer_num = len(self.layers)
delta = output_gradiant
for i in range(layer_num - 1, -1, -1):
# 反向遍歷各個層, 將期望改變量反向傳播
delta = self.layers[i].backward(delta)
def step(self, lr):
for layer in self.layers:
layer.step(lr)
繼承自Layer，由于內容比較復雜故單獨說明一下
RNN內部由一個全連接層Linear和一個激活層組成
前向傳播
def forward(self, inputs):
"""
:param inputs: input = (h0, x) h0.shape == (batch, out_dim) x.shape == (seq, batch, in_dim)
:return: outputs: outputs.shape == (seq, batch, out_dim)
"""
h = inputs[0] # 輸入的inputs由兩部分組成
X = inputs[1]
if X.shape[2] != self.in_dim or h.shape[1] != self.out_dim:
# 檢查輸入的形狀是否有問題
raise ShapeNotMatchException(self, "forward: wrong shape: h0 = {}, X = {}".format(h.shape, X.shape))
self.seq_len = X.shape[0] # 時間序列的長度
self.inputs = X # 保存輸入，之后的反向傳播還要用
output_list = [] # 保存每個時間點的輸出
for x in X:
# 按時間序列遍歷input
# x.shape == (batch, in_dim), h.shape == (batch, out_dim)
h = self.activation(self.linear(np.c_[h, x]))
output_list.append(h)
self.outputs = np.stack(output_list, axis=0) # 將列表轉換成一個矩陣保存起來
return self.outputs
反向傳播
def backward(self, output_gradiant):
"""
:param output_gradiant: shape == (seq, batch, out_dim)
:return: input_gradiant
"""
if output_gradiant.shape != self.outputs.shape:
# 期望得到(seq, batch, out_dim)形狀
raise ShapeNotMatchException(self, "__backward: expected {}, but we got "
"{}".format(self.outputs.shape, output_gradiant.shape))
input_gradients = []
# 每個time_step上的虛擬weight_gradient, 最后求平均值就是總的weight_gradient
weight_gradients = np.zeros(self.linear.weights_shape())
bias_gradients = np.zeros(self.linear.bias_shape())
batch_size = output_gradiant.shape[1]
# total_gradient: 前向傳播的時候是將x, h合成為一個矩陣，所以反向傳播也先計算這個大矩陣的梯度再拆分為x_grad, h_grad
total_gradient = np.zeros((batch_size, self.out_dim + self.in_dim))
h_gradient = None
# 反向遍歷各個時間層，計算該層的梯度值
for i in range(self.seq_len - 1, -1, -1):
# 前向傳播順序: x, h -> z -> h
# 所以反向傳播計算順序：h_grad -> z_grad -> x_grad, h_grad, w_grad, b_grad
# %%%%%%%%%%%%%%計算平均值的版本%%%%%%%%%%%%%%%%%%%%%%%
# h_gradient = (output_gradiant[i] + total_gradient[:, 0:self.out_dim]) / 2
# %%%%%%%%%%%%%%不計算平均值的版本%%%%%%%%%%%%%%%%%%%%%%%
# 計算h_grad: 這一時間點的h_grad包括輸出的grad和之前的時間點計算所得grad兩部分
h_gradient = output_gradiant[i] + total_gradient[:, 0:self.out_dim]
# w_grad和b_grad是在linear.backward()內計算的，不用手動再計算了
z_gradient = self.activation.backward(h_gradient) # 計算z_grad
total_gradient = self.linear.backward(z_gradient) # 計算x_grad和h_grad合成的大矩陣的梯度
# total_gradient 同時包含了h和x的gradient, shape == (batch, out_dim + in_dim)
x_gradient = total_gradient[:, self.out_dim:]
input_gradients.append(x_gradient)
weight_gradients += self.linear.gradients["w"]
bias_gradients += self.linear.gradients["b"]
# %%%%%%%%%%%%%%%%%%計算平均值的版本%%%%%%%%%%%%%%%%%%%%%%%
# self.linear.set_gradients(w=weight_gradients / self.seq_len, b=bias_gradients / self.seq_len)
# %%%%%%%%%%%%%%%%%%不計算平均值的版本%%%%%%%%%%%%%%%%%%%%%%%
self.linear.set_gradients(w=weight_gradients, b=bias_gradients) # 設置梯度值
list.reverse(input_gradients) # input_gradients是逆序的，最后輸出時需要reverse一下
print("sum(weight_gradients) = {}".format(np.sum(weight_gradients)))
# np.stack的作用是將列表轉變成一個矩陣
return np.stack(input_gradients), h_gradient
以上就是numpy創建神經網絡框架的詳細內容，更多關于numpy神經網絡的資料請關注腳本之家其它相關文章！
您可能感興趣的文章:- 教你使用Python建立任意層數的深度神經網絡
- python神經網絡編程之手寫數字識別
- python機器學習之神經網絡
- pytorch動態神經網絡(擬合)實現
- Python如何使用神經網絡進行簡單文本分類
- pytorch之深度神經網絡概念全面整理
