Python 实现通过 RNN实现二进制的乘法

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 "------------"