基於ng課程的淺層神經網路向量化python實現。
模型：
其中，output layer與圖中不同，只有乙個output node。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
class smallneuralnetwork(object):
def __init__(self, m, n, x, y, hln, alpha, iterstopthreshold, itermaxcnt = 100000):
''':param m: 訓練樣本數
:param n: 每個訓練樣本包含的特徵數
:param x: 訓練樣本矩陣
:param y: 訓練樣本標籤
:param hln(hidden layer nodes): 隱藏層的神經元個數
:param alpha: 學習率
:param iterstopthreshold: 誤差閾值
:param itermaxcnt：最大迭代次數
'''self.x = x #dims: (n, m)
self.y = y #dims: (1, m)
self.m = m
self.n = n
self.hln =hln #hidden layer nodes
self.alpha = alpha
self.iterstopthreshold = iterstopthreshold
self.itermaxcnt = itermaxcnt
#hidden layer paramters
#dims of w1: (hln, n)
#dims of b1: (hln, 1)
self.w1 = np.random.randn(hln, n) * 0.01
self.b1 = np.zeros((hln, 1))
#output layer paramters
#dims of w2: (hln, n)
#dims of b2: (1, 1)
self.w2 = np.random.randn(1, hln) * 0.01
self.b2 = 0.0
def predict(self, x):
z1 = np.dot(self.w1, x) + self.b1
a1 = 1 / (1 + np.exp(-z1))
z2 = np.dot(self.w2, a1) + self.b2
a2 = 1 / (1 + np.exp(-z2))
if a2 >= 0.5:
return 1
else:
return 0
def train(self):
jold = -1.0 # old cost
itercnt = 0 # iterator count
while true:
#-------update iterator count
itercnt += 1
#---------forward propagation-------------------
# dims of z1: (hln, m) = (hln, n) * (n, m) + (hln, 1)
z1 = np.dot(self.w1, self.x) + self.b1
# dims of a1: (hln, m)
a1 = 1 / (1 + np.exp(-z1))
# dims of z2: (1, m) = (1, hln) * (hln, m) + (1, 1)
z2 = np.dot(self.w2, a1) + self.b2
# dims of a2: (1, m)
a2 = 1 / (1 + np.exp(-z2))
# dims of jnew: (1, 1) = (1, m) * (m, 1) + (1, m) * (m, 1)
jnew = -(np.dot(self.y, np.log(a2).t) + np.dot(1 - self.y, np.log(1 - a2).t))
jnew /= self.m
#--------backward propagation----------------
#update output layer paramters
# dims of dz2: (1, m) = (1, m) - (1, m)
dz2 = a2 - self.y
# dims of dw2: (1, hln) = (1, m) * (m, hln)
dw2 = np.dot(dz2, a1.t) / self.m
# dims of db2: (1, 1)
db2 = np.sum(dz2, axis = 1, keepdims = true) / self.m
self.w2 -= self.alpha * dw2
self.b2 -= self.alpha * db2
#update hidden layer paramters
# dims of dz1: (hln, m) = ((hln, 1) * (1, m)) * ((m, hln) * (hln, m))
# = ((hln, m) * (m, m))
# = (hln, m)
dz1 = np.dot(np.dot(self.w2.t, dz2), np.dot(z1.t, 1 - z1))
# dims of dw1: (hln, n) = (hln, m) * (m, n)
dw1 = np.dot(dz1, self.x.t) / self.m
# dims of db1: (hln, 1)
db1 = np.sum(dz1, axis = 1, keepdims = true)
self.w1 -= self.alpha * dw1
self.b1 -= self.alpha * db1
#-----judge to stop iteration-----
print("第" + str(itercnt) + "次迭代的代價j：" + str(jnew))
if np.abs(jnew - jold) < self.iterstopthreshold and jold > 0.0:
print "jnew - jold(%s) < %s, stop iteration." % (abs(jnew - jold), self.iterstopthreshold)
break
elif itercnt > self.itermaxcnt:
print "itercnt(%s) > itermaxcnt(%s), stop iteration." % (itercnt, self.itermaxcnt)
break
#-----update cost-----
jold = jnew
return self.w1, self.b1, self.w2, self.b2
if __name__ == '__main__':
m = 100 # 訓練樣本個數
n = 2 # 每個樣本包含的特徵數
x = np.random.rand(m, n) # 生成隨機訓練樣本
x = x.reshape(n, m) # 基於ng課程，x轉換為n*m
y = np.random.randint(0, 2, (1, m)) # 1*m
hidden_layer_nodes = 10
alpha = 0.1 # 學習率
iterstopthreshold = 0.001 # 設定迭代停止誤差閾值
itermaxcnt = 10000 # 最大迭代次數，超過該迭代次數則停止迭代
lr = smallneuralnetwork(m, n, x, y, hidden_layer_nodes, alpha, iterstopthreshold, itermaxcnt)
lr.train()
#測試分類結果
print(lr.predict(np.array([np.random.rand(1), np.random.rand(1)])))
寶寶攻略 2 神經網路向量化
考慮乙個三層網路 乙個輸入層 乙個隱含層 以及乙個輸出層 並且假定x是包含乙個單一訓練樣本x i r n 的列向量。則向量化的正向傳播步驟如下 z 2 a 2 z 3 w 1 x b 1 f z 2 w 2 a 2 b 2 這對於單一訓練樣本而言是非常有效的一種實現，但是當我們需要處理m個訓練樣本時...
小白帶你神經網路向量化
我們知道了神經網路的基本結構預期神經元節點輸入輸出的計算方法。我們可以將現在的神經網路看出乙個巨大的有向無環圖。1.python的numpy處理資料，所有的資料python總都會盡量被表示為乙個多維陣列或者矩陣。我們來看一下，這裡w表示第一層和第二層的所有連線引數。w就是第1層和第1個節點和第2層第...
寶寶攻略 2 神經網路向量化
考慮乙個三層網路 乙個輸入層 乙個隱含層 以及乙個輸出層 並且假定x是包含乙個單一訓練樣本x i rn的列向量。則向量化的正向傳播步驟如下 z 2 a 2 z 3 w 1 x b 1 f z 2 w 2 a 2 b 2 這對於單一訓練樣本而言是非常有效的一種實現，但是當我們需要處理m個訓練樣本時，則...