RNN网络实现二进制加法（Python无框架代码）

RNN网络实现二进制加法（Python无框架代码）

ＲＮＮ网络在我学习的时候，发现网上的手动代码都是关于二进制加法的程序，当时这个程序注释比较少，不是很好理解，容易让人放弃。下面把我写的一个注释版放出来，方便深度学习和python初学者理解（我也是小白，哈哈哈，希望大佬见谅）

'利用RNN网络特性(能够记忆之前的事物)，使RNN网络学会二进制加法，即能正确完成加法和进位两种操作'
"激活函数为sigmoid"

import copy, numpy as np
np.random.seed(0)

 #定义sigmoid函数
def sigmoid(x):
    output = 1 / (1 + np.exp(-x))
    return output
 #计算sigmoid函数的导数
def sigmoid_output_to_derivative(output):
    return output * (1 - output)

# 生成要计算的二进制数据
int2binary = {}  # 用于将输入的整数转为计算机可运行的二进制数用
binary_dim = 8  # 定义了二进制数的长度=8

largest_number = pow(2, binary_dim)  # 二进制数最大能取的数就=256喽
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.1  # 反向传播时参数w更新的速度
input_dim = 2  # 输入数据的维度，程序是实现两个数相加的
hidden_dim = 16  # 隐藏层神经元个数=16
output_dim = 1  # 输出结果值是1维的

  # 初始化神经网络的权重参数
synapse_0 = 2 * np.random.random((input_dim, hidden_dim)) - 1  # 输入层权值，维度为2X16，取值约束在[-1,1]间
synapse_1 = 2 * np.random.random((hidden_dim, output_dim)) - 1  # 隐层权值,维度为16X1，取值约束在[-1,1]间
synapse_h = 2 * np.random.random((hidden_dim, hidden_dim)) - 1  # 循环层,维度为16X16，取值约束在[-1,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)

# training logic
for j in range(10000):  # 模型迭代次数，可自行更改

    # 随机生成相加的数，并将其转换为二进制数
    # a_int 为十进制 且小于128， a为二进制
    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 为实际值
    c_int = a_int + b_int  # 真实和
    c = int2binary[c_int]
    # d 为预测值
    d = np.zeros_like(c)

    overallError = 0  # 打印显示误差

    layer_2_deltas = list()  # 反向求导用
    layer_1_values = list()
    # 先对隐藏层前一时刻状态初始化为 [0,0,0,,,,*16]
    layer_1_values.append(np.zeros(hidden_dim))

    # 前向传播；二进制求和，低位在右，高位在左 以此方向为正向
    for position in range(binary_dim):
        # 从最右边的数开始求和，所以索引要倒着写(从第七个开始求和)
        X = np.array([[a[binary_dim - position - 1], b[binary_dim - position - 1]]])
        # 输入的a与b（二进制形式） 1*2
        y = np.array([[c[binary_dim - position - 1]]]).T  # 真实label值  二进制

        # 隐层输出 1*2 * 2*16 + 1*16 * 16*16 = 1*16
        layer_1 = sigmoid(np.dot(X, synapse_0) + np.dot(layer_1_values[-1], synapse_h))  # X*w0+RNN前一时刻状态值*wh
        # 输出层 1*16 * 16*1 = 1*1
        layer_2 = sigmoid(np.dot(layer_1, synapse_1))
        # 求误差
        layer_2_error = y - layer_2
        # 将layer_2_deltas 算出来 并存入列表( y - y_p )*f'(z) 其结果是一个数
        layer_2_deltas.append((layer_2_error) * sigmoid_output_to_derivative(layer_2))

        overallError += np.abs(layer_2_error[0])  # 误差，打印显示用

        # a[7]+b[7]=d[7] 预测的和 循环结束后就会得到完整的二进制加法结果
        d[binary_dim - position - 1] = np.round(layer_2[0][0])

        # 深拷贝，将前向传播隐层输出保存起来
        layer_1_values.append(copy.deepcopy(layer_1))
    #  给记忆细胞赋初值  1*16 个0
    future_layer_1_delta = np.zeros(hidden_dim)


    # 反向传播，计算从左到右，即二进制高位到低位
    for position in range(binary_dim):
        X = np.array([[a[position], b[position]]])  # a[0],b[0]
        # 因为从右往左是正向，所以此时拿前向传播中的隐层中第七位的值
        layer_1 = layer_1_values[-position - 1]
        # 拿到前向传播中的前一个值  layer_1_+1 便于后面对循环层的矩阵进行跟新
        prev_layer_1 = layer_1_values[-position - 2]

        # 拿出第七位的 layer_2_delta ，用于计算 layer_1_delta
        layer_2_delta = layer_2_deltas[-position - 1]

        # 计算 layer_1_delta  ,  future_layer_1_delta初始值为0 与 Whh 相乘
        layer_1_delta = (future_layer_1_delta.dot(synapse_h.T) + layer_2_delta.dot(
            synapse_1.T)) * sigmoid_output_to_derivative(layer_1)

        # 跟新权值增量 (atleast_2d 避免列向量导致无法计算的问题)
        synapse_1_update += np.atleast_2d(layer_1).T.dot(layer_2_delta)  # 对w1进行更新
        synapse_h_update += np.atleast_2d(prev_layer_1).T.dot(layer_1_delta)  # 对wh进行更新
        synapse_0_update += X.T.dot(layer_1_delta)  # 对w0进行更新
        # 跟新记忆细胞中的值
        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):  # 每1000次打印结果
        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("------------")