如何在Python中使用RNN实现一个二进制加法

本篇文章给大家分享的是有关如何在python中使用RNN实现一个二进制加法，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。

Python是什么意思

Python是一种跨平台的、具有解释性、编译性、互动性和面向对象的脚本语言，其最初的设计是用于编写自动化脚本，随着版本的不断更新和新功能的添加，常用于用于开发独立的项目和大型项目。

具体代码

# 前向传播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值，在训练网络的过程中，我们需要计算w₁,w₂分别对这个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函数，得到预测值。然后通过预测值与准确值之间的差值设为l₂层的loss值。有了这个loss值，我们就可以算出刚刚定义的layer_2_deltas（l₂ 层的权重参数）

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频道。