http://blog.csdn.net/zzukun/article/details/49968129 以下Visual Studio Code.
import copy, numpy as np
np.random.seed(0)# compute sigmoid nonlinearity
def sigmoid(x):
output=1/(1+np.exp(-x))
return output
# convert output of sigmoid function to its derivative
def sigmoid_output_to_derivative(output):
return output*(1-output)
# training dataset generation
int2binary = {}
binary_dim = 8
largest_number = pow(2,binary_dim) # 256長度
binary = np.unpackbits(
np.array([range(largest_number)],dtype=np.uint8).T,axis=1)
#int2binary 聲明瞭一個查找表 256 個二進制數，這個表是一個實數與對應二進制表示的映射。
#二進制表示將會是我們網路的輸入與輸出，所以這個查找表將會幫助我們將實數轉化爲其二進制表示。
for i in range(largest_number):
int2binary[i] = binary[i]
#print binary[10]
#print int2binary
# input variables
alpha = 0.1 #這裏設置了學習速率。
input_dim = 2 #我們要把兩個數加起來，所以我們一次要輸入兩位字符。如此以來，我們的網絡就需要兩個輸入。
hidden_dim = 16
'''
這是隱含層的大小，回來存儲“攜帶位”。
需要注意的是，它的大小比原理上所需的要大。
自己嘗試着調整一下這個值，然後看看它如何影響收斂速率。
更高的隱含層維度會使訓練變慢還是變快？更多或是更少的迭代次數？
'''
output_dim = 1
# initialize neural network weights
synapse_0 = 2*np.random.random((input_dim,hidden_dim)) - 1
synapse_1 = 2*np.random.random((hidden_dim,output_dim)) - 1
synapse_h = 2*np.random.random((hidden_dim,hidden_dim)) - 1
synapse_0_update = np.zeros_like(synapse_0)
synapse_1_update = np.zeros_like(synapse_1)
'''
這個權值矩陣連接了前一時刻的隱含層與現在時刻的隱含層。
它同樣連接了當前時刻的隱含層與下一時刻的隱含層。
如此以來，它就有隱含層維度大小（hidden_dim）的行與隱含層維度大小（hidden_dim）的列
（假如你沒有修改參數就是16×16）。
'''
synapse_h_update = np.zeros_like(synapse_h)
print len(synapse_h),len(synapse_h[0])
print len(synapse_0),len(synapse_0[0])
print len(synapse_1),len(synapse_1[0])
# training logic
for j in range(10000):
# generate a simple addition problem (a + b = c)
a_int = np.random.randint(largest_number/2) # int version
a = int2binary[a_int] # binary encoding
b_int = np.random.randint(largest_number/2) # int version
b = int2binary[b_int] # binary encoding
# true answer
c_int = a_int + b_int
c = int2binary[c_int]
# where we'll store our best guess (binary encoded)
'''
初始化一個空的二進制數組，
用來存儲神經網絡的預測值（便於我們最後輸出）。
你也可以不這樣做，但是我覺得這樣使事情變得更符合直覺。
'''
d = np.zeros_like(c)
overallError = 0
layer_2_deltas = list()
layer_1_values = list()
'''
這兩個list會每個時刻不斷的記錄layer 2的導數值與layer 1的值。
'''
layer_1_values.append(np.zeros(hidden_dim))
# moving along the positions in the binary encoding
#這個循環是遍歷二進制數字
for position in range(binary_dim):
# generate input and output
'''
X跟圖片中的“layer_0”是一樣的，
X數組中的每個元素包含兩個二進制數，
其中一個來自a，一個來自b。
它通過position變量從a，b中檢索，
從最右邊往左檢索。所以說，當position等於0時，
就檢索a最右邊的一位和b最右邊的一位。
當position等於1時，就向左移一位。
'''
X = np.array([[a[binary_dim - position - 1],b[binary_dim - position - 1]]])
y = np.array([[c[binary_dim - position - 1]]]).T
# hidden layer (input ~+ prev_hidden)
'''這裏就是奧妙所在！一定一定一定要保證你理解這一行！！！
爲了建立隱含層，我們首先做了兩件事。第一，我們從輸入層傳播到隱含層（np.dot(X,synapse_0)）。
然後，我們從之前的隱含層傳播到現在的隱含層（np.dot(prev_layer_1.synapse_h)）。
在這裏，layer_1_values[-1]就是取了最後一個存進去的隱含層，也就是之前的那個隱含層！
然後我們把兩個向量加起來！！！！然後再通過sigmoid函數。
那麼，我們怎麼結合之前的隱含層信息與現在的輸入呢？當每個都被變量矩陣傳播過以後，
我們把信息加起來。
'''
layer_1 = sigmoid(np.dot(X,synapse_0) + np.dot(layer_1_values[-1],synapse_h))
print len(layer_1),len(layer_1[0])
# output layer (new binary representation)
#隱含層傳播到輸出層，即輸出一個預測值。
layer_2 = sigmoid(np.dot(layer_1,synapse_1))
print len(layer_2),len(layer_2[0])
# did we miss?... if so by how much?
#計算一下預測誤差（預測值與真實值的差）。
layer_2_error = y - layer_2
#這裏我們把導數值存起來，即把每個時刻的導數值都保留着。
layer_2_deltas.append((layer_2_error)*sigmoid_output_to_derivative(layer_2))
#計算誤差的絕對值，並把它們加起來，這樣我們就得到一個誤差的標量（用來衡量傳播）。我們最後會得到所有二進制位的誤差的總和。
overallError += np.abs(layer_2_error[0])
# decode estimate so we can print it out
d[binary_dim - position - 1] = np.round(layer_2[0][0])
# store hidden layer so we can use it in the next timestep
#將layer_1的值拷貝到另外一個數組裏，這樣我們就可以下一個時間使用這個值。
layer_1_values.append(copy.deepcopy(layer_1))
future_layer_1_delta = np.zeros(hidden_dim)
'''
我們已經完成了所有的正向傳播，
並且已經計算了輸出層的導數，並將其存入在一個列表裏了。現在我們需要做的就是反向傳播，從最後一個時間點開始，反向一直到第一個。
'''
for position in range(binary_dim):
X = np.array([[a[position],b[position]]])
layer_1 = layer_1_values[-position-1] #從列表中取出當前的隱含層。
prev_layer_1 = layer_1_values[-position-2] #從列表中取出前一個隱含層。
# error at output layer
layer_2_delta = layer_2_deltas[-position-1] #從列表中取出當前輸出層的誤差
# error at hidden layer
#這一行計算了當前隱含層的誤差。通過當前之後一個時間點的誤差和當前輸出層的誤差計算。
layer_1_delta = (future_layer_1_delta.dot(synapse_h.T) +
layer_2_delta.dot(synapse_1.T)) * sigmoid_output_to_derivative(layer_1)
# let's update all our weights so we can try again
'''
:我們已經有了反向傳播中當前時刻的導數值
，那麼就可以生成權值更新的量了（但是還沒真正的更新權值）。
我們會在完成所有的反向傳播以後再去真正的更新我們的權值矩陣，這是爲什麼呢？
因爲我們要用權值矩陣去做反向傳播。如此以來，在完成所有反向傳播以前，
我們不能改變權值矩陣中的值。
'''
synapse_1_update += np.atleast_2d(layer_1).T.dot(layer_2_delta)
synapse_h_update += np.atleast_2d(prev_layer_1).T.dot(layer_1_delta)
synapse_0_update += X.T.dot(layer_1_delta)
future_layer_1_delta = layer_1_delta
'''
現在我們就已經完成了反向傳播，得到了權值要更新的量，所以就趕快更新權
'''
synapse_0 += synapse_0_update * alpha
synapse_1 += synapse_1_update * alpha
synapse_h += synapse_h_update * alpha
synapse_0_update *= 0
synapse_1_update *= 0
synapse_h_update *= 0
# print out progress
if(j % 1000 == 0):
print "Error:" + str(overallError)
print "Pred:" + str(d)
print "True:" + str(c)
out = 0
for index,x in enumerate(reversed(d)):
out += x*pow(2,index)
print str(a_int) + " + " + str(b_int) + " = " + str(out)
print "------------"