最近在查找RNN的公式详解中，发现大多数的公式都是一通链式求导结束，与网络上广为流传的八位二进制代码的计算过程完全不符，经过研究推导，觉得有必要给后来的同学推导一下代码中的计算过程。（代码附在文后）

先上图，

RNN的结构图都是这样，按时间展开，S是隐藏层和输出层的激活函数，这里用Sigmoid，求导比较特殊，W是权重角标表示走向，O是输出层，I是输入层，H是隐藏层，a是单元的输入，b是单元的输出，上下角标是层和时间序列，x是输入层的输入，这里方便，就不给单元设置阈值了，有的代码里会有一个阈值，一般用b表示，影响不大。

神经网络的目标就是通过调整W和阈值b（不是单元的输出的b啊），来让误差变小，所谓的网络就是误差足够小的那些W和阈值b。

再上公式，简单的前向传播

再定义一个损失函数，就是上面说的优化问题的目标函数，一般为了好求导这样给出

这都比较简单，麻烦的是反向传播，先看简单的隐藏层到输入层的转换矩阵的所谓梯度 

 接下来大的两个权重矩阵的梯度就是麻烦了，很多的文章这里就开始含糊不清，我尽量给读者写清楚，需要注意，两个矩阵的梯度都是会受到未来时刻的影响的。

首先，还是继续t时刻的蓝色线的来自输出层的反向传播

接着要看红色的这条反向传播 ，需要注意，这里的t+1不单单指t+1时刻的，而是t时刻未来的所有时刻，因为t+1时刻会包含t+2时刻的信息，这一点会在之后的误差项定义中完美体现

两条反向传播先不着急合再一起 

来看代码里的前向传播部分，先把注释删掉，文后的代码会有注释

里面的函数在这

 麻烦的地方在第四句，其余都好懂，这个layer_2_deltas是什么鬼，再来看一下它的用处

给出反向传播和权重更新

下面这三行代码就是三个矩阵的更新，后面那三个加上去的就是他们对应的梯度，也就是那三个链式求导，1是隐藏层到输出层的，h是隐藏层到隐藏层的，0是输入层到隐藏层的 

先分析一下这个

 包含两部分，左边的误差乘以后边的函数，前边的误差出现时因为特殊的损失函数求导后出现的，后边的函数是

这一环是链式求导里频繁出现的一环，推理确实很麻烦，直接给出结果吧 

麻烦的地方在于layer_1_delta和 layer_2_delta是什么鬼，先给出结果，这两个是误差项，定义如下，

误差项就是对该层的输入求偏导 ，那么代码里的layer_2_delta就是输出层的误差项，即损失函数对输出层的输入求得偏导

那么隐藏层到输出层矩阵的梯度就可以写成

接着看隐藏层的误差项layer_1_delta，即损失函数对隐藏层的输入求导，直接把两部分梯度结合起来

需要说明的是，这个式子里包含了t+1时刻的隐藏层的误差项，代码里实现就是反向传播的计算方向和前向传播的计算方向是相反的，这样反向传播计算机会先得到下一次循环的”下一时刻“的隐藏层误差项，可以让变量保存下来。

有了 隐藏层的误差项，给最后一个矩阵求梯度就好算了

 算好梯度后，就可以计算权重矩阵的更新

后面的常数是步长，或者学习速率。

代码附上

% implementation of RNN 
clc
clear
close all
%% training dataset generation
binary_dim = 8;

largest_number = 2^binary_dim - 1;
binary = cell(largest_number,1);
int2binary = cell(largest_number,1);
for i = 1:largest_number+1
    binary{i} = dec2bin(i-1, 8);
    int2binary{i} = binary{i};
end

%% input variables
alpha = 0.1;
input_dim = 2;
hidden_dim = 16;
output_dim = 1;

%% initialize neural network weights
synapse_0 = 2*rand(input_dim,hidden_dim) - 1;
synapse_1 = 2*rand(hidden_dim,output_dim) - 1;
synapse_h = 2*rand(hidden_dim,hidden_dim) - 1;%产生[-1,1]之间的随机数

synapse_0_update = zeros(size(synapse_0));
synapse_1_update = zeros(size(synapse_1));
synapse_h_update = zeros(size(synapse_h));

%% train logic
for j = 0:19999 
    % generate a simple addition problem (a + b = c)
    a_int = randi(round(largest_number/2)); % int version 产生一个小于128的随机数
    a = int2binary{a_int+1}; % binary encoding
    
    b_int = randi(floor(largest_number/2)); % int version 产生一个小于127的随机数
    b = int2binary{b_int+1}; % binary encoding
    
    % true answer
    c_int = a_int + b_int;
    c = int2binary{c_int+1};
    
    % where we'll store our best guess (binary encoded)
    d = zeros(size(c));%c的维数是1*8
    
    if length(d)<8
        pause;
    end
    
    overallError = 0;
    
    layer_2_deltas = [];
    layer_1_values = [];
    layer_1_values = [layer_1_values; zeros(1, hidden_dim)];
    
    % 开始对一个序列进行处理，搞清楚一个东西，一个LSTM单元的输出其实就是隐含层
    for position = 0:binary_dim-1
        X = [a(binary_dim - position)-'0' b(binary_dim - position)-'0'];   % X 是 input
        y = [c(binary_dim - position)-'0']';                               % Y 是label，用来计算最后误差
        
        % 这里是RNN，因此隐含层比较简单
        % X ------------------------> input
        % sunapse_0 ----------------> U_i
        % layer_1_values(end, :) ---> previous hidden layer （S(t-1)）
        % synapse_h ----------------> W_i
        % layer_1 ------------------> new hidden layer (S(t))

        layer_1 = sigmoid(X*synapse_0 + layer_1_values(end, :)*synapse_h);
        
        % layer_1 ------------------> hidden layer (S(t))
        % layer_2 ------------------> 最终的输出结果，其维度应该与 label (Y) 的维度是一致的
        % 这里的 sigmoid 其实就是一个变换，将 hidden layer (size: 1 x 16) 变换为 1 x 1
        % 有些时候，如果输入与输出不匹配的话，使可以使用 softmax 进行变化的
        % output layer (new binary representation)
        layer_2 = sigmoid(layer_1*synapse_1);
        
        % 计算误差，根据误差进行反向传播
        % layer_2_error ------------> 此次（第 position+1 次的误差）
        % l 是真实结果
        % layer_2 是输出结果
        % layer_2_deltas 输出层的变化结果，使用了反向传播，见那个求导（输出层的输入是 layer_2，那就对输入求导即可，然后乘以误差就可以得到输出的diff）
        % did we miss?... if so, by how much?
        layer_2_error = y - layer_2;
        layer_2_deltas = [layer_2_deltas; layer_2_error*sigmoid_output_to_derivative(layer_2)];
        
        % 总体的误差（误差有正有负，用绝对值）
        overallError = overallError + abs(layer_2_error(1));
        
        % decode estimate so we can print it out
        % 就是记录此位置的输出，用于显示结果
        d(binary_dim - position) = round(layer_2(1));
        
        % 记录下此次的隐含层 (S(t))
        % store hidden layer so we can use it in the next timestep
        layer_1_values = [layer_1_values; layer_1];
    end
    
    % 计算隐含层的diff，用于求参数的变化，并用来更新参数，还是每一个timestep来进行计算
    future_layer_1_delta = zeros(1, hidden_dim);
    
    % 开始进行反向传播，计算 hidden_layer 的diff，以及参数的 diff
    for position = 0:binary_dim-1
        % 因为是通过输入得到隐含层，因此这里还是需要用到输入的
        % a -> (operation) -> y, x_diff = derivative(x) * y_diff
        % 注意这里从最后开始往前推
        X = [a(position+1)-'0' b(position+1)-'0'];
        % layer_1 -----------------> 表示隐含层 hidden_layer (S(t))
        % prev_layer_1 ------------> (S(t-1))
        layer_1 = layer_1_values(end-position, :);
        prev_layer_1 = layer_1_values(end-position-1, :);
        
        % layer_2_delta -----------> 就是隐含层的diff
        % hidden_layer_diff,根据这个可以推算输入的diff以及上一个隐含层的diff
        % error at output layer 输出层的误差项
        layer_2_delta = layer_2_deltas(end-position, :);
        % 这个地方的 hidden_layer 来自两个方面，因为 hidden_layer -> next timestep, hidden_layer -> output，
        % 因此其反向传播也是两方面
        % error at hidden layer 隐藏层的误差项
        layer_1_delta = (future_layer_1_delta*(synapse_h') + layer_2_delta*(synapse_1')).* sigmoid_output_to_derivative(layer_1);
        
        % let's update all our weights so we can try again
        synapse_1_update = synapse_1_update + (layer_1')*(layer_2_delta);
        synapse_h_update = synapse_h_update + (prev_layer_1')*(layer_1_delta);
        synapse_0_update = synapse_0_update + (X')*(layer_1_delta);
        
        future_layer_1_delta = layer_1_delta;
    end
    
    synapse_0 = synapse_0 + synapse_0_update * alpha;
    synapse_1 = synapse_1 + synapse_1_update * alpha;
    synapse_h = synapse_h + synapse_h_update * alpha;
    
    synapse_0_update = synapse_0_update * 0;
    synapse_1_update = synapse_1_update * 0;
    synapse_h_update = synapse_h_update * 0;
    
    if(mod(j,1000) == 0)%余数
        err = sprintf('Error:%s\n', num2str(overallError)); fprintf(err);
        d = bin2dec(num2str(d));
        pred = sprintf('Pred:%s\n',dec2bin(d,8)); fprintf(pred);
        Tru = sprintf('True:%s\n', num2str(c)); fprintf(Tru);
        out = 0;
        size(c)
        sep = sprintf('-------------\n'); fprintf(sep);
    end
    
end
function y = sigmoid(x)
    n = length(x);
    for i = 1:n
        y(i) = 1/(1+exp(-x(i)));
    end
end
function y = sigmoid_output_to_derivative(x)
    n = length(x);
    for i = 1:n
        y(i) = x(i)*(1-x(i));
    end
end

 兄弟也是第一次写，如果你看到结尾了，就给点一个赞支持一下吧，会接着这种公式加代码的讲述风格继续努力的。

深度学习——循环神经网络RNN公式推导

1、循环神经网络引入

1.1 从传统网络到循环网络

对于传统的神经网络，在我们之前介绍的传统的神经网络中，主要包含输入层、隐藏层、输出层三个部分。其基本的图示如下：

X表示输入层的向量，H表示隐藏层的向量，O表示输出层的向量。W表示从输入层到隐藏层的权重矩阵，V表示从隐藏层到输出层的权重矩阵。其中，每一层可以有多个神经元。每一层神经元的个数代表的是每一层的维度。

我们将该网络展开成神经元的形式如下：

我们可以看到的是，对于每一个隐藏层的神经元，其结果是由输入层的向量和权重W来决定的。似乎是有这样的一种可能，每一个隐藏层的神经元是和其排列在前面的神经元之间是有关系的，也就是排列在前面隐藏层的神经元也作为当前隐藏层神经元的一个输入。这就引出来了循环神经网络。

我们先给出循环神经网络的基本结构：

在上面的结构中，我们能够发现，对于隐藏层的神经元，其中有一个自我传递信息的过程，下面是具体的展开图：

可以理解为，网络的输入通过时间进行向后传播，每次输入一个X，产生一个St和一个O，然后下一个时刻的X和前一个时刻的H作为当前时刻的输入，其中X通过W来控制权重，H通过U来控制权重。我们将上述的神经网络结构成为：单向循环神经网络。

在对于该神经网络进行进一步的展开(这里，我们只展开一个时刻的神经单元)

2 BPTT算法以及前向和后向传播算法

2.1 前向传播过程

1. 从输入层神经元到隐藏层神经元。
2. 从隐藏层神经元到隐藏层神经元。
3. 隐藏层神经元整合两个部分的输入。
4. 从隐藏层神经元到输出层神经元。

2.1.1 从输入层神经元到隐藏层神经元

这个部分的前向传播主要是输入神经元信息和对应的权重矩阵W来决定的。具体的计算公式为：
$$W^T{X}_t$$
注意，这个部分中，X是一个向量，W是一个权重矩阵，通过W来将X转换成另外的向量。

2.1.2 从隐藏层神经元到隐藏层神经元

这个部分主要是前一个时刻的隐藏层神经元向当前时刻的神经元的信息传递，其值有$S_{t-1}$和对应的权重矩阵U来决定。公式如下：
$$U^T{S}_{t-1}$$
注意，这个部分中，$S_{t-1}$是一个向量，U是一个权重矩阵，通过U来将$S_{t-1}$转换成另外的向量。

2.1.3 隐藏层神经元整合两个部分的输入

这一部分，主要是当前时刻的神经元$h_t$，将两个部分的输入整合，激活生成当前时刻隐藏层神经元的输出。
整合的过程就是向量相加，对应的公式为：
$$W^T{X}_t+U^T{S}_{t-1}$$
在假设激活函数为f，则激活后生成当前时刻神经元的值：
$$S_t=f(W^T{X}_t+U^T{S}_{t-1})$$

2.1.4 从隐藏层神经元到输出层神经元

这一部分的信息传递主要是将当前时刻隐藏层神经元的值传递到当前时刻的输出神经元中去。计算公式为：
$$O_t=g(V^T{S}_t)$$
其中g表示的也是激活函数。

2.2 前向过程总结

前向过程相对来说比较简单，用两个公式就可以总结其基本的传播过程：
$$S_t=f(W^T{X}_t+U^T{S}_{t-1})$$
$$O_t=g(V^T{S}_t)=g(V^{T}f(W^T{X}_t+U^T{S}_{t-1}))$$

2.3 参数权重说明：

在整个神经网络中，一共包含的三中权重矩阵，第一个矩阵是W，给矩阵的维度为(N,K)，N表示隐藏层神经元值的向量维度，K表示输入神经单元的向量的维度。第二个权重矩阵是V，该矩阵的维度为(L,N)，其中P表示输出层的神经元的向量维度。第三个是权重矩阵U，该矩阵的维度是(N,N)。

2.4 反向传播过程

2.4.1 误差函数

关于误差函数的选择，可以根据具体的任务进行，我们这里选择MSE作为误差计算函数：
$$J=\frac{1}{2}\sum _{t=1}^T||R_t-O_t|{|}^2$$
注意，我们这里在算误差的时候，$R_t和O_t$对应的是t时刻真实标签向量是预测输出的向量，所有采用的了取模计算的|| ||。

将上面的式子展开后得到
$$J=\frac{1}{2}\sum _{t=1}^T\sum _{j=1}^L(R_t(j)-O_t(j){)}^2$$
L表示输入向量的属性值的个数。

2.4.2 反向传播过程

对于最后一个时刻的节点$X_T,H_T,O_T$，我们首先计算这一个时刻的相关误差。我们在这里设置两个临时函数：
$$net{o}_t=V^{T}f(W^T{X}_t+U^T{S}_{t-1})$$
$$net{h}_t=W^T{X}_t+U^T{S}_{t-1}$$

其中$ne{t}_o(t)$表示t时刻没有激活的输出层的向量值，$ne{t}_h(t)$表示t时刻没有激活的隐藏层的向量值。

为了清晰，我们再之前单个神经元中的结构拿过来：

根据公式和图示，我们能够知道$neth(t)$，表示的是t时刻$[h_1,h_2,h_3]$组成的没有激活时的向量，$neto(t)$表示的是没有激活的$[o_1,o_2]$构成的向量。

1. 对于最后时刻T，我们计算出来的误差是J，首先我们计算：
   $$\frac{\partial J}{\partial net{o}_1(T)}=\frac{\partial J}{\partial O_T(1)}\frac{\partial O_T(1)}{\partial net{o}_T(1)}=(R_T(1)-O_T(1))g^{\prime }(net{o}_T(1))$$
   整理一下有：
   $${\delta }_T^O(j)=\frac{\partial J}{\partial net{o}_T(j)}=\frac{\partial J}{\partial O_T(j)}\frac{\partial O_T(j)}{\partial net{o}_T(j)}=(R_T(j)-O_T(j))g^{\prime }(net{o}_T(j))其中j\in [1,L]$$

进一步，转换成矩阵的形式：
$${\delta }_T^O=\frac{\partial J}{\partial net{o}_T}=\frac{\partial J}{\partial O_T}\frac{\partial O_T}{\partial net{o}_T}=(R_T-O_T)\ast g^{\prime }(net{o}_T)公式1$$

2. 然后我们计算
   $$\frac{\partial J}{\partial net{h}_T(1)}=\frac{\partial J}{\partial O_T(1)}\frac{\partial O_T(1)}{\partial net{o}_T(1)}\frac{\partial net{o}_T(1)}{\partial h_T(1)}\frac{\partial h_T(1)}{\partial net{h}_T(1)}+\frac{\partial J}{\partial O_T(2)}\frac{\partial O_T(2)}{\partial net{o}_T(2)}\frac{\partial net{o}_T(2)}{\partial h_T(1)}\frac{\partial h_T(2)}{\partial net{h}_T(1)}$$

整理一下就是：
$$\frac{\partial J}{\partial net{h}_T(1)}=\sum _{i=1}^2\frac{\partial J}{\partial O_T(i)}\frac{\partial O_T(i)}{\partial net{o}_T(i)}\frac{\partial net{o}_T(i)}{\partial h_T(1)}\frac{\partial h_T(1)}{\partial net{h}_T(1)}$$

进一步可以推广为：
$$\frac{\partial J}{\partial net{h}_T(i)}=\sum _{i=1}^L\frac{\partial J}{\partial O_T(i)}\frac{\partial O_T(i)}{\partial net{o}_T(i)}\frac{\partial net{o}_T(i)}{\partial h_T(j)}\frac{\partial h_T(j)}{\partial net{h}_T(j)}$$

计算出来的结果为：
$${\delta }_T^h(j)=\frac{\partial J}{\partial net{h}_j(T)}=\sum _{i=1}^L{\delta }_T^O(i)V_{ji}{f}^{\prime }(net{h}_j(T))$$

在整理成矩阵的形式：
$${\delta }_T^h=V^T{\delta }_T^O\ast f^{\prime }(neth(T))公式2$$

对于其他时刻t的关于${\delta }_t^O$梯度计算，也最后一个时刻T的计算方式类似：

$${\delta }_t^O=\frac{\partial J}{\partial net{o}_t}=\frac{\partial J}{\partial O_t}\frac{\partial O_t}{\partial net{o}_t}=(R_t-O_t)\ast g^{\prime }(net{o}_t)$$

注意：最重要的计算部分在于其他时刻关于${\delta }_T^h(j)$的计算，下面进行具体的介绍

对于不是最后一个时刻T的${\delta }_t^h(j)$，其主要包含的两个部分，一个部分是从输出层传递回来的误差，另外一个部分是从t+1时刻传递回来的误差。(因为$h_t$计算的结果是$h_{t+1}$的一个输入)

形式化描述为：
$${\delta }_t^h(j)=[输出层误差+t+1时刻的误差]f^{\prime }(net{h}_t(j))$$
在之前的计算中，我们已经知道了t时刻从输出层传递回来的误差为：
$$V^t{\delta }_t^O\ast f^{\prime }(neth(t))$$
则有，原式为：
$${\delta }_t^h(j)=[V^t{\delta }_t^O+t+1时刻的误差]f^{\prime }(net{h}_t(j))$$

下面，我们具体来计算T到T-1时刻的误差传递，根据正向传播的方式有：
$$S_T=f(W^T{X}_T+U^T{S}_{T-1})$$
$$S_{T-1}=f(W^{T-1}{X}_{T-1}+U^T{S}_{T-2})$$
根据上面的两个公式我们可以看出，在求${\delta }_{T-1}^h(j)$的时候，需要的另外一部分是$\frac{{\delta }_T^h}{{\delta }_{T-1}^h(j)}$,也就是
$$\sum _{i=1}^N{\delta }_T^h(i)U_{ji}$$，则总结上面的公式有
$${\delta }_{T-1}^h(j)=[\sum _{i=1}^L{V}_{ji}{\delta }_t^O(i)+\sum _{i=1}^N{\delta }_T^h(i)U_{ji}]f^{\prime }(net{h}_{T-1}(j))$$
$${\delta }_{T-1}^h=[V^T{\delta }_T^O+U^T{\delta }_T^h]\ast f^{\prime }(net{h}_{T-1})$$

进而可以推广到其他时刻
$${\delta }_{t-1}^h=[V^T{\delta }_t^O+U^T{\delta }_t^h]\ast f^{\prime }(net{h}_{t-1})$$

2.5 权重更新

2.5.1 隐藏层到输出层V更新

$$V_{ji}(new)=V_{ji}(old)-\alpha \sum _{t=1}^T\frac{\partial J}{\partial net{o}_t(i)}\frac{\partial net{o}_t(i)}{\partial V_{ji}}=V_{ji}-\alpha \sum _{t=1}^T{\delta }_o^t(i)h_t(j)$$
整理成矩阵的形式：
$$V(new)=V(old)+\alpha \sum _{t=1}^T{\delta }_o^t{h}_t^T$$
注意：$h_t^T$中的T表示转置。

2.5.2 输入层到隐藏层的W更新

$$W_{ji}(new)=W_{ji}(old)-\alpha \sum _{t-1}^T\frac{\partial J}{\partial net{h}_t(i)}\frac{\partial net{h}_t(i)}{\partial W_{ji}}=W_{ji}(old)-\alpha \sum _{t-1}^T{\delta }_h^t(i)X_t(j)$$
整理成矩阵的形式
$$W(new)=W(old)+\alpha \sum _{t=1}^T{\delta }_h^t{X}_t^T$$
注意：$X_t^T$中的T表示转置。添加链接描述

2.5.3 隐藏层到隐藏层的U的更新

$$U_{ji}(new)=U_{ji}(old)-\alpha \sum _{t-1}^T\frac{\partial J}{\partial net{h}_t(i)}\frac{\partial net{h}_t(i)}{\partial U_{ji}}=U_{ji}(old)-\alpha \sum _{t-1}^T{\delta }_h^t(i)h_{t-1}(j)$$
整理成矩阵的形式：
$$U(new)=U(old)+\alpha \sum _{t=1}^T{\delta }_o^t{h}_{t-1}^T$$
注意：$h_{t-1}^T$中的T表示转置。

3、参考资料

1. 知乎——RNN前向传播与后向传播公式推导

循环神经网络

神经网络是由一层一层的神经元首尾相连构成，通常情况下网络分为输入层、隐层和输出层三种。而这里要讲的循环神经网络，是下面这样一种结构： 

为了便于直观理解推导，我们先按时间维度展开RNN的网络结构，并对各个部分给出相应的符号标注，如下图所示： 

首先，我们写出RNN的前向传播公式。前向传播指的是从前往后传递信息，传递的是输入x。前向传播公式如下： 

模型训练过程大致是这样：样本信息通过输入层传递到输出层，得到实际输出值，然后与真实值通过损失函数（均方差或者交叉熵公式等）计算出误差L，再反向传播分别修正三个W权重矩阵，直到误差收敛至某一阈值。反向传播指的是从后往前传递信息，传递的是误差信号L，求导之后称之为残差δ。

和普通DNN一样，根据前向传播公式，采用链式法则，我们可以很容易的给出Whk与Wih这两个权重矩阵的梯度计算过程以及权重更新方式，如下图所示： 

RNN中比较难理解的是对Wh’h的梯度计算，因为Wh’h的残差不仅来自于当前t时刻的输出层，也来自于下一个t+1时刻隐层。其中来自当前输出层的残差比较容易给出，如下图所示： 

对本文推导有任何问题或疑问，欢迎留言交流。

转载自：http://m.blog.csdn.net/cherrylvlei/article/details/75269614