devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

RNN原理

作者：小丑西瓜9 | 2024-03-30 22:25:25

赞

踩

rnn原理

1.什么是RNN

RNN（Recurrent Neural Network）循环神经网络，是用来专门处理序列数据的神经网络。百度百科关于时间序列数据的定义是这样的：时间序列数据是指在不同时间点上收集到的数据，这类数据反映了某一事物、现象等随时间的变化状态或程度。这是时间序列数据的定义，当然这里也可以不是时间，比如文字序列，但总归序列数据有一个特点——后面的数据跟前面的数据有关系。

RNN的出现是为了解决全连接神经网络不能联系上下文去训练模型的缺点。有一个NLP很常见的问题命名实体识别，举个例子，有下面两句话：

第一句：I like eating apple!

第二句：The Apple is a great company!

现在我们要给apple打标签，假设现在有很多已经标记好的数据供我们训练模型。假如我们使用全连接神经网络，把apple对应的特征向量输入到网络中，那么输出结果中我们想让正确的标签概率值最大，来训练模型，我们的训练集中有的apple的标签是苹果有的是公司，这将导致训练的准确度取决于训练集中哪个标签的个数比较多，这显然是我们不愿看到的。

但如果让我们去判断，那么一定是不能只看apple这个词的，是要联系上下文的。但全连接神经网络是不能做到这一点的，于是就有了循环神经网络。

2.RNN为什么能处理序列数据

这是RNN的结构决定的。

 这是网上很经典的一张RNN的结构图，他每层不只有一个神经元，不看矩阵w,把他展开可以是这样的：

这就是一个全连接神经网络。u就是一个3×4的矩阵，s的维度是4，v是4×3的矩阵。

如果按照第一张图的w展开他也可以变成这样：

 这是不同时刻输入x对应输出的图，这体现了RNN的很重要的一个思想：权重共享。即不同时刻输入的x每次使用的权重矩阵是一样的，每一部分都是如此。

有了这个图我们就可以解释RNN是如何处理序列数据的了，其关键之处在于循环核，也就是图中的Ws矩阵，他能记住上次隐藏层输出的特征，并将他传递给下一次输入。

我们来看RNN的前向传播的公式：

 隐藏层的输出不仅与本次输入有关还和上一时刻隐藏层的输出有关，这样网络便能记住不同时刻的特征，于是他便能处理序列数据。

3.RNN的反向传播

RNN对于每个时刻输入的x都会产生一个损失函数值，总的损失函数是每个时刻的叠加，我们只以某个时刻为例来推导他的反向传播公式，实际是用各个时刻的损失函数的和来求梯度的。

以第三幅图为例，在t时刻（使用平方损失函数），假设t=3。

损失函数为：

 y为真实的输出，各个参数的梯度为：

 以Wx的梯度为例，因为S3不仅和本层输入有关，还和S2有关而S2又和S1有关，所以Wx的梯度会有三部分，Ws也是一样。

于是我们便可以推出任意时刻Wx的梯度为：

 Ws与之类似，只不过把Ws替换一下，这样便可以用梯度下降法进行更新参数了。

4.RNN存在的问题

梯度消失和梯度爆炸是RNN存在的两个问题，他们是如何产生的哪？

我们看上面推出的任意时刻Wx的梯度就会发现中间的连乘的部分每次Sj对Sj-1求导都会产生一个Ws和一项损失函数的导数(因为先要对损失函数整体求导)，如果连乘的项过多那么就会有Ws的n次方的项产生如果Ws大于或小于1就会让这个梯度本身很大或很小，也就是产生梯度爆炸或梯度消失。

当然这里说的消失并不是整个梯度都没有了，而是当t较大时(就是后面输入的x)的梯度没有了，这也限制了RNN的学习能力，就是他不能学习远距离的依赖关系。

我们也不能忽略了求导过程中损失函数的导数这一项，他的大小同样会加重梯度消失或爆炸。

如何解决梯度消失或梯度爆炸？

梯度消失：可以使用不同的损失函数比如ReLU,他求导后的值总为1(对于大于0的值)，还有leakrelu、elu函数等，或者改变RNN本身的结构，这就是接下来我们要学习的LSTM(Long Short Term Memory, 长短期记忆网络 )和GRU(Gated Recurrent Unit networks,门控循环单元网络）。

梯度爆炸：梯度裁剪，权值正则化。

参考文章：

史上最详细循环神经网络讲解（RNN/LSTM/GRU） - 知乎

通俗易懂的RNN_长竹Danko的博客-CSDN博客_rnn

5.代码实例

本代码是参考博客：RNN及其简单Python代码示例_夏轻的博客-CSDN博客_python rnn实例，只是自己对代码进行了重新理解，并整理。

本代码的任务是用RNN来实现一个八位二进制数的加法运算。

  1. import copy, numpy as np
  2. np.random.seed(0)
  3.  
  4. # compute sigmoid nonlinearity
  5. def sigmoid(x):
  6.     output = 1/(1+np.exp(-x))
  7.     return output
  8.  
  9. # convert output of sigmoid function to its derivative
  10. def sigmoid_output_to_derivative(output):
  11.     return output*(1-output)

首先是导入需要的库，并定义sigmoid函数及其导数，这在梯度下降时会用到。

  1. # training dataset generation
  2. int2binary = {}
  3. binary_dim = 8
  4.  
  5. largest_number = pow(2,binary_dim)
  6. binary = np.unpackbits(
  7.     np.array([range(largest_number)],dtype=np.uint8).T,axis=1)          #将uint8数组的元素解压缩为二进制值输出数组。
  8. for i in range(largest_number):
  9.     int2binary[i] = binary[i]
  10.  
  11.  
  12. # input variables
  13. alpha = 0.1
  14. input_dim = 2
  15. hidden_dim = 16
  16. output_dim = 1

然后是定义本次任务的参数，binary_dim二进制的位数为八位，最大的十进制数为2的8次方，并存储所有的八位二进制数。

  1. # initialize neural network weights
  2. synapse_0 = 2*np.random.random((input_dim,hidden_dim)) - 1  #生成input_dim,hidden_dim大小的矩阵，值为0-1
  3. synapse_1 = 2*np.random.random((hidden_dim,output_dim)) - 1
  4. synapse_h = 2*np.random.random((hidden_dim,hidden_dim)) - 1
  5.  
  6. synapse_0_update = np.zeros_like(synapse_0)                  #构造全零的矩阵，大小和参数的一样
  7. synapse_1_update = np.zeros_like(synapse_1)
  8. synapse_h_update = np.zeros_like(synapse_h)

初始化权重矩阵，和梯度矩阵。

  1.  # generate a simple addition problem (a + b = c)
  2.     a_int = np.random.randint(largest_number/2) # int version
  3.     a = int2binary[a_int] # binary encoding
  4.  
  5.     b_int = np.random.randint(largest_number/2) # int version
  6.     b = int2binary[b_int] # binary encoding
  7.  
  8.     # true answer
  9.     c_int = a_int + b_int
  10.     c = int2binary[c_int]
  11.     
  12.     # where we'll store our best guess (binary encoded)
  13.     d = np.zeros_like(c)
  14.  
  15.     overallError = 0
  16.     
  17.     layer_2_deltas = list()
  18.     layer_1_values = list()
  19.     layer_1_values.append(np.zeros(hidden_dim))

随机初始化要运算的数，和他的真实输出。d是一个存储预测输出的数组。layer_1_values存储隐藏层的输出，layer_2_deltas表示输出层对于参数求导时的整体梯度，也即上面式子中L对O的梯度。

  1. # moving along the positions in the binary encoding
  2.     for position in range(binary_dim):
  3.         #每次取八位二进制数的一位进行运算
  4.         # generate input and output
  5.         X = np.array([[a[binary_dim - position - 1],b[binary_dim - position - 1]]])
  6.         y = np.array([[c[binary_dim - position - 1]]]).T
  7.         '''print("!!!!!!")
  8.         print(X)
  9.         print(y)'''
  10.         # hidden layer (input ~+ prev_hidden)
  11.         layer_1 = sigmoid(np.dot(X,synapse_0) + np.dot(layer_1_values[-1],synapse_h))
  12.  
  13.         # output layer (new binary representation)
  14.         layer_2 = sigmoid(np.dot(layer_1,synapse_1))
  15.  
  16.         # did we miss?... if so, by how much?
  17.         layer_2_error = y - layer_2
  18.         layer_2_deltas.append((layer_2_error)*sigmoid_output_to_derivative(layer_2))
  19.         overallError += np.abs(layer_2_error[0])
  20.     
  21.         # decode estimate so we can print it out
  22.         d[binary_dim - position - 1] = np.round(layer_2[0][0])
  23.         
  24.         # store hidden layer so we can use it in the next timestep
  25.         layer_1_values.append(copy.deepcopy(layer_1))               #保存隐藏层的输出
  26.         '''print("?????")
  27.         print(layer_1_values)'''
  28.     future_layer_1_delta = np.zeros(hidden_dim)

每次循环只取二进制数的一位进行运算，X表示二进制加数和被加数的两位，y表示真实和的一位。layer_1和layer_2表示隐藏层和输出层的输出值,layer_2_error表示误差。然后将误差的整体导数添加到layer_2_deltas中，统计一下整体误差，循环结束后初始化隐藏层的梯度。

  1. for position in range(binary_dim):
  2.         
  3.         X = np.array([[a[position],b[position]]])
  4.         layer_1 = layer_1_values[-position-1]
  5.         prev_layer_1 = layer_1_values[-position-2]        #取一项的原因是因为这一项的值已经包含之前的了
  6.         '''print("!!!!!!")
  7.         print(prev_layer_1)'''
  8.         # error at output layer
  9.         layer_2_delta = layer_2_deltas[-position-1]
  10.         # error at hidden layer
  11.         layer_1_delta = (future_layer_1_delta.dot(synapse_h.T) + layer_2_delta.dot(synapse_1.T)) * sigmoid_output_to_derivative(layer_1)
  12.  
  13.         # let's update all our weights so we can try again
  14.         synapse_1_update += np.atleast_2d(layer_1).T.dot(layer_2_delta)
  15.         synapse_h_update += np.atleast_2d(prev_layer_1).T.dot(layer_1_delta)
  16.         synapse_0_update += X.T.dot(layer_1_delta)
  17.         
  18.         future_layer_1_delta = layer_1_delta
  19.     
  20.  
  21.     synapse_0 += synapse_0_update * alpha
  22.     synapse_1 += synapse_1_update * alpha
  23.     synapse_h += synapse_h_update * alpha    
  24.  
  25.     synapse_0_update *= 0
  26.     synapse_1_update *= 0
  27.     synapse_h_update *= 0

开始梯度下降更新参数，需要更新三个矩阵synapse_0,synapes_1,synapes_h。在计算梯度时较为复杂的就是synapes_h的梯度，他需要在计算时向前传播梯度，也即上边总结的最终梯度的连乘的那一部分。其实代码中就变得简单了，他只是一个数，我们用prev_layer_1来表示，但你可能会说，为什么他只有隐藏层的一项如果是最后一个输入的不应该有前面n个隐藏层的输出吗？其实每一个prev_layer_1的数值就已经包含前面的隐藏层的输出了，因为在计算layer_1时就已经包含了。

其余梯度的计算和上边推导的公式是一致的，只是他计算的是这一层的整体的梯度，我们公式里只是一个参数的梯度。其实每一个参数的求导在代码里都不会向前去寻找n个梯度，因为当前的值已经包括之前的梯度了。

  1. # print out progress
  2.     if(j % 1000 == 0):
  3.         print ("Error:" + str(overallError))
  4.         print ("Pred:" + str(d))
  5.         print ("True:" + str(c))
  6.         out = 0
  7.         for index,x in enumerate(reversed(d)):
  8.             out += x*pow(2,index)
  9.         print (str(a_int) + " + " + str(b_int) + " = " + str(out))
  10.         print ("------------")

 

最后就是输出：误差，预测的二进制的结果，真实的二进制的结果，十进制的初始化的两个数和他们相加的预测结果的表达式。

最后再给出总的代码：

  1. #为啥会有一个损失值骤降的过程?
  2. import copy, numpy as np
  3. np.random.seed(0)
  4.  
  5. # compute sigmoid nonlinearity
  6. def sigmoid(x):
  7.     output = 1/(1+np.exp(-x))
  8.     return output
  9.  
  10. # convert output of sigmoid function to its derivative
  11. def sigmoid_output_to_derivative(output):
  12.     return output*(1-output)
  13.  
  14.  
  15. # training dataset generation
  16. int2binary = {}
  17. binary_dim = 8
  18.  
  19. largest_number = pow(2,binary_dim)
  20. binary = np.unpackbits(
  21.     np.array([range(largest_number)],dtype=np.uint8).T,axis=1)          #将uint8数组的元素解压缩为二进制值输出数组。
  22. for i in range(largest_number):
  23.     int2binary[i] = binary[i]
  24.     #print(binary[i])
  25.  
  26. # input variables
  27. alpha = 0.1
  28. input_dim = 2
  29. hidden_dim = 16
  30. output_dim = 1
  31.  
  32.  
  33. # initialize neural network weights
  34. synapse_0 = 2*np.random.random((input_dim,hidden_dim)) - 1  #生成input_dim,hidden_dim大小的矩阵，值为0-1
  35. synapse_1 = 2*np.random.random((hidden_dim,output_dim)) - 1
  36. synapse_h = 2*np.random.random((hidden_dim,hidden_dim)) - 1
  37.  
  38. synapse_0_update = np.zeros_like(synapse_0)                  #构造全零的矩阵，大小和参数的一样
  39. synapse_1_update = np.zeros_like(synapse_1)
  40. synapse_h_update = np.zeros_like(synapse_h)
  41.  
  42. # training logic
  43. for j in range(10000):
  44.     
  45.     # generate a simple addition problem (a + b = c)
  46.     a_int = np.random.randint(largest_number/2) # int version
  47.     a = int2binary[a_int] # binary encoding
  48.  
  49.     b_int = np.random.randint(largest_number/2) # int version
  50.     b = int2binary[b_int] # binary encoding
  51.  
  52.     # true answer
  53.     c_int = a_int + b_int
  54.     c = int2binary[c_int]
  55.     
  56.     # where we'll store our best guess (binary encoded)
  57.     d = np.zeros_like(c)
  58.     #print(type(d))
  59.     overallError = 0
  60.     
  61.     layer_2_deltas = list()
  62.     layer_1_values = list()
  63.     layer_1_values.append(np.zeros(hidden_dim))
  64.     
  65.     # moving along the positions in the binary encoding
  66.     for position in range(binary_dim):
  67.         #每次取八位二进制数的一位进行运算
  68.         # generate input and output
  69.         X = np.array([[a[binary_dim - position - 1],b[binary_dim - position - 1]]])
  70.         y = np.array([[c[binary_dim - position - 1]]]).T
  71.         '''print("!!!!!!")
  72.         print(X)
  73.         print(y)'''
  74.         # hidden layer (input ~+ prev_hidden)
  75.         layer_1 = sigmoid(np.dot(X,synapse_0) + np.dot(layer_1_values[-1],synapse_h))
  76.  
  77.         # output layer (new binary representation)
  78.         layer_2 = sigmoid(np.dot(layer_1,synapse_1))
  79.  
  80.         # did we miss?... if so, by how much?
  81.         layer_2_error = y - layer_2
  82.         layer_2_deltas.append((layer_2_error)*sigmoid_output_to_derivative(layer_2))
  83.         overallError += np.abs(layer_2_error[0])
  84.     
  85.         # decode estimate so we can print it out
  86.         d[binary_dim - position - 1] = np.round(layer_2[0][0])
  87.         
  88.         # store hidden layer so we can use it in the next timestep
  89.         layer_1_values.append(copy.deepcopy(layer_1))               #保存隐藏层的输出
  90.         '''print("?????")
  91.         print(layer_1_values)'''
  92.     future_layer_1_delta = np.zeros(hidden_dim)
  93.     
  94.     for position in range(binary_dim):
  95.         
  96.         X = np.array([[a[position],b[position]]])
  97.         layer_1 = layer_1_values[-position-1]
  98.         prev_layer_1 = layer_1_values[-position-2]        #取一项的原因是因为这一项的值已经包含之前的了
  99.         '''print("!!!!!!")
  100.         print(prev_layer_1)'''
  101.         # error at output layer
  102.         layer_2_delta = layer_2_deltas[-position-1]
  103.         # error at hidden layer
  104.         layer_1_delta = (future_layer_1_delta.dot(synapse_h.T) + layer_2_delta.dot(synapse_1.T)) * sigmoid_output_to_derivative(layer_1)
  105.  
  106.         # let's update all our weights so we can try again
  107.         synapse_1_update += np.atleast_2d(layer_1).T.dot(layer_2_delta)
  108.         synapse_h_update += np.atleast_2d(prev_layer_1).T.dot(layer_1_delta)
  109.         synapse_0_update += X.T.dot(layer_1_delta)
  110.         
  111.         future_layer_1_delta = layer_1_delta
  112.     
  113.  
  114.     synapse_0 += synapse_0_update * alpha
  115.     synapse_1 += synapse_1_update * alpha
  116.     synapse_h += synapse_h_update * alpha    
  117.  
  118.     synapse_0_update *= 0
  119.     synapse_1_update *= 0
  120.     synapse_h_update *= 0
  121.     
  122.     # print out progress
  123.     if(j % 1000 == 0):
  124.         print ("Error:" + str(overallError))
  125.         print ("Pred:" + str(d))
  126.         print ("True:" + str(c))
  127.         out = 0
  128.         for index,x in enumerate(reversed(d)):
  129.             out += x*pow(2,index)
  130.         print (str(a_int) + " + " + str(b_int) + " = " + str(out))
  131.         print ("------------")

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/341996
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号