只有一百行左右代碼，應該還是比較好理解的。

首先看一下結果，

The end error is:[0.05344101]

發現還是不錯的。如果不想看講解，就直接跳到文末，有所有的代碼，安裝numpy庫就能夠跑。

這個沒啥好說的，就是逢二進一，不知道的就看看計算機組成原理的相關內容吧。

RNN主要學兩件事，一個是前一位的進位，一個是當前位的加法操作。只告訴當前階段和前一階段的計算結果，讓網絡自己學習加法和進位操作。

既然是神經網絡，肯定就非線性的，首先是sigmoid函數，這個要是不清楚，就看看相關博客了解一下。

反向傳播的時候需要sigmoid函數的導數值，所以把兩個函數就直接貼在下面了。

# 前向傳播def sigmoid(in_x): output = 1 / (1 + np.exp(-in_x)) return output# 反向傳播def sigmoid_output_to_derivative(output): return output * (1 - output)

定義一個字典，因為待會兒要進行十進制和二進制之間的轉換，我們用字典進行存儲他們之間的對應關系。

（在這里我們只選用八位二進制）

int2binary = {}binary_dim = 8largest_number = pow(2, binary_dim)binary = np.unpackbits( np.array([range(largest_number)], dtype=np.uint8).T, axis=1)for i in range(largest_number): int2binary[i] = binary[i]

再接著就是對我們的RNN進行初始化操作。

alpha = 0.1input_dim = 2hidden_dim = 16output_dim = 1

接著是生成神經網絡各層的權重值以及反向傳播時對權值矩陣進行更新的存儲。

# 生成神經網絡各層的權重值（在0，1之間）synapse_0 = 2 * np.random.random((input_dim, hidden_dim)) - 1synapse_1 = 2 * np.random.random((hidden_dim, output_dim)) - 1synapse_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)synapse_h_update = np.zeros_like(synapse_h)RNN

我們進行10萬次的迭代訓練。

我們進行的是加法，所以需要將值找到。最大取八位，所以a, b, c都不能超過，因為a+b=c，所以a, b不能超過最大的一半。其中largest_number表示8位二進制數對應的最大的十進制數值。

# 最大取八位，所以a, b, c都不能超過，因為a+b=c，所以a, b不能超過最大的一半a_int = np.random.randint(largest_number / 2)a = int2binary[a_int]b_int = np.random.randint(largest_number / 2) b = int2binary[b_int] c_int = a_int + b_intc = int2binary[c_int]

我們定義一個d來存儲我們的預測值與實際值c進行比較，判斷網絡的能力。并且定義一個overallError來存儲error值，并將初值設為0。

d = np.zeros_like(c) overallError = 0

最后我們在進行反向傳播的時候，會計算一個loss值，在訓練網絡的過程中，我們需要計算w1,w2分別對這個loss值的影響。

layer_2_deltas = list()layer_1_values = list()# 因為第一次迭代會用到l1的值，所以我們需要將列表用0來填充layer_1_values.append(np.zeros(hidden_dim))future_layer_1_delta = np.zeros(hidden_dim)

我們需要先進行前向傳播，再進行反向傳播。

在進行前向傳播的過程中，我們需要將兩個二進制傳入，從最后一位開始，一層一層地通過sigmoid函數，得到預測值。然后通過預測值與準確值之間的差值設為l2層的loss值。有了這個loss值，我們就可以算出剛剛定義的layer_2_deltas（l2 層的權重參數）

for position in range(binary_dim): X = np.array([[a[binary_dim - position - 1], b[binary_dim - position - 1]]]) y = np.array([[c[binary_dim - position - 1]]]).T layer_1 = sigmoid(np.dot(X, synapse_0) + np.dot(layer_1_values[-1], synapse_h)) layer_2 = sigmoid(np.dot(layer_1, synapse_1)) 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]) d[binary_dim - position - 1] = np.round(layer_2[0][0]) layer_1_values.append(copy.deepcopy(layer_1))

然后進行反向傳播，也就是從最高位往后走。（具體的解釋放在代碼的注釋中了）

for position in range(binary_dim): X = np.array([[a[position], b[position]]]) # 從參數列表中反向依次取值 layer_1 = layer_1_values[-position - 1] # 因為要進行反向傳播，所以還需要取到l1層的前一位的value prev_layer_1 = layer_1_values[-position - 2] # l2也是如此，delta列表中反向依次取值 layer_2_delta = layer_2_deltas[-position - 1] # 通過公式進行計算l1的delta值 layer_1_delta = (future_layer_1_delta.dot(synapse_h.T) + layer_2_delta.dot(synapse_1.T)) * sigmoid_output_to_derivative(layer_1) # 然后分別對w0, w1和wh進行更新 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

然后再前向傳播和反向傳播結束之后，引入α alphaα值進行參數的更新，并將updata重新置為0，以方便下一次循環使用。

synapse_0 += synapse_0_update * alphasynapse_1 += synapse_1_update * alphasynapse_h += synapse_h_update * alphasynapse_0_update *= 0synapse_1_update *= 0synapse_h_update *= 0

最后就是打印訓練結果了，因為訓練次數過多，所以這邊設計每訓練1萬次打印一次結果。

if j % 10000 == 0: print(str(j) + '/100000 :The error is:' + str(overallError))

運行結果0/100000 :The error is:[3.45638663]10000/100000 :The error is:[0.3231264]20000/100000 :The error is:[0.27153112]30000/100000 :The error is:[0.1603061]40000/100000 :The error is:[0.10004929]50000/100000 :The error is:[0.11245508]60000/100000 :The error is:[0.11951541]70000/100000 :The error is:[0.07859761]80000/100000 :The error is:[0.06742156]90000/100000 :The error is:[0.08218885]The end error is:[0.05344101]

最終代碼

import copyimport numpy as npnp.random.seed(0)def sigmoid(in_x): output = 1 / (1 + np.exp(-in_x)) return outputdef sigmoid_output_to_derivative(output): return output * (1 - output)int2binary = {}binary_dim = 8largest_number = pow(2, binary_dim)binary = np.unpackbits( np.array([range(largest_number)], dtype=np.uint8).T, axis=1)for i in range(largest_number): int2binary[i] = binary[i]alpha = 0.1input_dim = 2hidden_dim = 16output_dim = 1# 生成神經網絡各層的權重值（在0，1之間）synapse_0 = 2 * np.random.random((input_dim, hidden_dim)) - 1synapse_1 = 2 * np.random.random((hidden_dim, output_dim)) - 1synapse_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)synapse_h_update = np.zeros_like(synapse_h)for j in range(100000): # 最大取八位，所以a, b, c都不能超過，因為a+b=c，所以a, b不能超過最大的一半 a_int = np.random.randint(largest_number / 2) a = int2binary[a_int] b_int = np.random.randint(largest_number / 2) b = int2binary[b_int] c_int = a_int + b_int c = int2binary[c_int] d = np.zeros_like(c) overallError = 0 layer_2_deltas = list() layer_1_values = list() # 因為第一次迭代會用到l1的值，所以我們需要將列表用0來填充 layer_1_values.append(np.zeros(hidden_dim)) future_layer_1_delta = np.zeros(hidden_dim) for position in range(binary_dim): X = np.array([[a[binary_dim - position - 1], b[binary_dim - position - 1]]]) y = np.array([[c[binary_dim - position - 1]]]).T layer_1 = sigmoid(np.dot(X, synapse_0) + np.dot(layer_1_values[-1], synapse_h)) layer_2 = sigmoid(np.dot(layer_1, synapse_1)) 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]) d[binary_dim - position - 1] = np.round(layer_2[0][0]) layer_1_values.append(copy.deepcopy(layer_1)) 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] layer_2_delta = layer_2_deltas[-position - 1]layer_1_delta = (future_layer_1_delta.dot(synapse_h.T) + layer_2_delta.dot( synapse_1.T)) * sigmoid_output_to_derivative(layer_1) 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 if j % 10000 == 0: print(str(j) + '/100000 :The error is:' + str(overallError))print('The end error is:' + str(overallError))

到此這篇關于使用Python建立RNN實現二進制加法的示例代碼的文章就介紹到這了,更多相關Python RNN二進制加法內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！