深度学习——结构递归神经网络(Recursive NN)

深度学习——结构递归神经网络(Recursive NN)

1、递归神经网络介绍

目前，递归神经网络一共包含两种，一种是时间递归神经网络(Recurrent NN)，另外一种是结构性递归神经网络(Recursive NN)。

1.1 神经网络处理变长序列

对于常规的神经网络而言，其输入节点的长度往往都是固定的。例如下面的一个普通的前馈神经网络。
(图片来源：https://image.baidu.com/search)

对于上述的前馈网络而言，其每次的输入就只有X1,X2,X3,X4四个。我们知道，在NLP中，句子序列的长度往往都是不固定的。那么如何处理变长的数据呢？

在这里，我们提出了采用递归神经网络的方式来处理不定长度的数据。由于输入单元个数的不确定，所以，必须采用循环，或者递归的方式来对数据进行输入，由此也就有了基于时间的递归神经网络和基于结构的递归神经网络。首先介绍基于时间的递归神经网络对于不定长序列的处理。

图片来源：https://www.sohu.com/a/128784058_487514

当在处理一个变长的句子的时候，将句子看作是不同词汇所构成的序列，每次向递归神经网络中输入一个词汇，知道所有的词汇输入完成，网络产生对应的输出。

下面，我们给出这样的一个序列，“两个计算机学院的学生”，从字面上来看，这句话可以有两种理解方式，第一种，是同一个计算机学院的两个学生，第二种，来自两个不同计算机学院的学生。当我们以基于时间的递归网络进行输入的时候，显然，网络是对无法对这两种语义进行辨析的。

上图是不同语义对应的语法树，根据不同语法树结构，我们自然而然的就可以想到使用树状的神经网络来对序列进行语义理解。这也就是基于结构的递归神经网络的应用。

基于结构的递归神经网络类似于一个自编码器，它将由句子构成的树或者图结构进行自编码，将其整个结构映射的向量空间中。语义相近的句子在向量空间中拥有更近的向量距离。同时，当把词汇，句子、段落映射到相同的向量空间中的时候，可以利用向量组合的方式，由词构成句子，由句子构成段落。不停地向上组合，最后将组合出来的语义树统一的表示成一个有意义的向量。

2、递归神经网络前向传播过程

2.1 前向计算过程

输入：两个或者多个子节点，
输出：两个子节点编码之后产生的父节点

下面两个节点表示子节点向量，上面表示的是父节点的向量，子节点和父节点组成一个全连接到的神经网络，也就是子节点和父节点上的神经单元进行全连接。计算公式为：

$F=f(W(C1||C2)+b)$

其中C1，C2分别表示的是两个子节点的向量，F表示父节点的向量，W表示权重，b表示偏重。f是激活函数。然后，我们将父节点的向量和其他子节点进行拼接，再次产生下一个父节点向量，不停的递归，直到生成最终的根节点向量。如下图所示：

2.2 前向传播的代码展示

#encoding=utf-8
import numpy as np
def sigmoid(x):
    return 1/(1+np.exp(-x))
def IdentityActivator(x):
    return x
#定义递归树的节点信息
class TreeNode(object):
    def __init__(self,data,children=[],children_data=[]):
        self.parent = None
        self.children = children
        self.children_data = children_data
        self.data = data
        for child in children:
            child.parent = self
class RecursiveNetWork(object):
    def __init__(self,node_dim,child_count,lr):
        '''
        node_dim : 每一个节点的维度
        child_count ： 每一个节点的子节点的个数
        lr ： 学习率
        '''
        self.node_dim = node_dim
        self.child_count = child_count
        self.lr = lr
        self.W = np.ones((child_count * node_dim,node_dim))
        self.B = np.ones((node_dim,1))
        #生成最后的根节点
        self.root = None
    def concatenate(self,tree_nodes):
        '''
        定义向量拼接的方法
        '''
        concat = np.zeros((0,1))
        concat = np.concatenate((concat,tree_nodes[0].data))
        concat = np.concatenate((concat,tree_nodes[1].data))
        #for node in tree_nodes:
         #   cocat = np.concatenate((concat,node.data))
        return concat

    def forward(self,*children):
        #首先，将向量进行拼接
        children_data = self.concatenate(children)
        #前向传播，获取父节点的数据
        parent_data = IdentityActivator(np.dot(self.W.T,children_data)+ self.B)
        #生成根节点
        self.root = TreeNode(parent_data,children,children_data)

3 反向传播

3.1 反向传播的过程计算（BPTS算法 ）

3.1.1 少量节点的情况

对于基于结构的递归神经网络，其训练过程和基于时间的递归神经网络不同，基于时间的递归神经网络的反向传播是将当前时刻$t_k$的误差不同的向前一个时刻$t_{k-1}$进行反向传播，直到传播到初始时刻$t_0$。对于基于结构的递归神经网络而言，它的反向传播的方式是从根节点反向传播到所有的子节点，这种反向传播的方式成为BPTS算法。

我们先考虑三个节点的情况，为了便于说明，我们首先说明一个父节点，两个子节点的情况。具体结构如下图所示：

根据上图，我们构造出输入的节点矩阵X和权重W矩阵。输入包括两个子节点$X_1,X_2$，每一个节点包含两个属性：
$$X_1=\begin{array}{c}{X}_{11}\\ X_{12}\end{array}，X_2=\begin{array}{c}{X}_{21}\\ X_{22}\end{array}$$
将两者合并成一个向量之后，表示为X：
$$X=\begin{array}{c}{X}_{11}\\ X_{12}\\ X_{21}\\ X_{22}\end{array}$$
下面构建出对应的W矩阵：
$$W=\begin{array}{cc}{W}_{111}& W_{112}\\ W_{121}& W_{122}\\ W_{211}& W_{212}\\ W_{221}& W_{222}\end{array}$$

根据前向传播的过程，设：
$$ne{t}_Y=W^{T}X，Y=sigmoid(ne{t}_Y)$$
设J表示误差项，设${\delta }_F$是对于父层节点的误差函数,则有：
$${\delta }_{ne{t}_Y}=\frac{\partial J}{ne{t}_Y}=\begin{array}{c}\frac{\partial J}{\partial ne{t}_{Y_1}}=\frac{\partial J}{\partial Y_1}\frac{\partial Y_1}{\partial ne{t}_{Y_1}}=\frac{\partial J}{\partial Y_1}\ast Y_1\ast (1-Y_1)\\ \frac{}{}\\ \frac{\partial J}{\partial ne{t}_{Y_2}}=\frac{\partial J}{\partial Y_2}\frac{\partial Y_2}{\partial ne{t}_{Y_2}}=\frac{\partial J}{\partial Y_2}\ast Y_2\ast (1-Y_2)\end{array}$$
我们假设${\delta }_F$已知，我们下面继续推导$\frac{\partial J}{\partial x_{11}}$
$$\frac{\partial J}{\partial x_{11}}=\sum _{i=1}^2\frac{\partial J}{\partial ne{t}_{Y_i}}\ast \frac{\partial ne{t}_{Y_i}}{\partial X_{11}}=\sum _{i=1}^2\frac{\partial J}{\partial ne{t}_{Y_i}}\ast W_{11i}$$

同理，可以推导出关于$X_{12}，X_{21}，X_{22}$的导数为：
$$\frac{\partial J}{\partial x_{12}}=\sum _{i=1}^2\frac{\partial J}{\partial ne{t}_{Y_i}}\ast \frac{\partial ne{t}_{Y_i}}{\partial X_{12}}=\sum _{i=1}^2\frac{\partial J}{\partial ne{t}_{Y_i}}\ast W_{12i}$$
$$\frac{\partial J}{\partial x_{21}}=\sum _{i=1}^2\frac{\partial J}{\partial ne{t}_{Y_i}}\ast \frac{\partial ne{t}_{Y_i}}{\partial X_{21}}=\sum _{i=1}^2\frac{\partial J}{\partial ne{t}_{Y_i}}\ast W_{21i}$$
$$\frac{\partial J}{\partial x_{22}}=\sum _{i=1}^2\frac{\partial J}{\partial ne{t}_{Y_i}}\ast \frac{\partial ne{t}_{Y_i}}{\partial X_{22}}=\sum _{i=1}^2\frac{\partial J}{\partial ne{t}_{Y_i}}\ast W_{22i}$$

整理成向量的形式：
$${\delta }_X=\frac{\partial J}{\partial X}=W{\delta }_Y=\begin{array}{c}\frac{\partial J}{\partial X_{11}}\\ \frac{}{}\\ \frac{\partial J}{\partial X_{12}}\\ \frac{}{}\\ \frac{\partial J}{\partial X_{21}}\\ \frac{}{}\\ \frac{\partial J}{\partial X_{22}}\end{array}$$
如，X也是采用sigmoid激活的，那么根据激活函数的求导，可以直接定义:
$${\delta }_{ne{t}_X}=\frac{\partial J}{\partial ne{t}_X}={\delta }_X\ast X\ast (1-X)$$
这里可以根据我们选择的激活函数进行实际的求导。，设激活函数为$f(x)$，则最终获取的值为：
$${\delta }_{ne{t}_X}=\frac{\partial J}{\partial ne{t}_X}={\delta }_X\ast f^{\prime }(X)$$
下面就是将${\delta }_{ne{t}_X}$拆解成${\delta }_{ne{t}_{X_1}}和{\delta }_{ne{t}_{X_2}}$两个部分的误差。
$${\delta }_{ne{t}_{X_1}}=\frac{\partial J}{\partial ne{t}_{X_1}}=W{\delta }_{ne{t}_{X_1}}=\begin{array}{c}\frac{\partial J}{\partial ne{t}_{X_{11}}}\\ \frac{}{}\\ \frac{\partial J}{\partial Xne{t}_{12}}\end{array}，{\delta }_{ne{t}_{X_2}}=\frac{\partial J}{\partial ne{t}_{X_2}}=W{\delta }_{ne{t}_{X_2}}=\begin{array}{c}\frac{\partial J}{\partial ne{t}_{X_{21}}}\\ \frac{}{}\\ \frac{\partial J}{\partial ne{t}_{X_{22}}}\end{array}$$

3.1.2 多节点的情况

当构造的递归树的层数较多的时候，我们可以根据上面的少量节点的推导公式，扩展到多层递归树的情况。

在上图中，已经将总的误差标出来了。假设${\delta }_{root}$已知，下面我们来逐层推导一下：
$${\delta }_{ne{t}_X}=W{\delta }_{root}\ast f^{\prime }(X)，{\delta }_{net{X}_1}={\delta }_{ne{t}_X}[0:nodedim,:]，{\delta }_{ne{t}_{X_2}}={\delta }_{ne{t}_X}[nodedim:,:]$$
$${\delta }_{ne{t}_m}=W{\delta }_X\ast f^{\prime }(m)，{\delta }_{net{m}_1}={\delta }_{ne{t}_m}[0:nodedim,:]，{\delta }_{ne{t}_{m_2}}={\delta }_{ne{t}_m}[nodedim:,:]$$
$${\delta }_{ne{t}_k}=W{\delta }_m\ast f^{\prime }(k)，{\delta }_{net{k}_1}={\delta }_{ne{t}_k}[0:nodedim,:]，{\delta }_{ne{t}_{k_2}}={\delta }_{ne{t}_k}[nodedim:,:]$$
其中，W是所有节点共用的。nodedim表示节点数据的维度。

4、权重W，B的更新

我们可以看到，权重W在树的每一层都出现了，我们在更新W的时候，就需要将每一层对于W的更新做一个累加和。下面，根据上面的例子进行逐层计算W，并累加。

4.1 逐层计算关于W的梯度

1. 首先$X_1,X_2,root$层的W，根据计算公式$ne{t}_{root}=W^{T}X+B$有：
   $$\frac{\partial ne{t}_Y}{\partial W_{111}}=\frac{\partial ne{t}_{Y_1}}{\partial W_{111}}=X_{11}$$
   $$\frac{\partial ne{t}_Y}{\partial W_{112}}=\frac{\partial ne{t}_{Y_2}}{\partial W_{112}}=X_{11}$$
   $$\frac{\partial ne{t}_Y}{\partial W_{121}}=\frac{\partial ne{t}_{Y_1}}{\partial W_{121}}=X_{12}$$
   $$\frac{\partial ne{t}_Y}{\partial W_{122}}=\frac{\partial ne{t}_{Y_2}}{\partial W_{122}}=X_{12}$$
   同理，可以计算关于第二个子节点$X_2$的梯度。将上述的计算过程总结成向量的形式可以看到：
   $$\frac{\partial J}{\partial W_X}=X{\delta }_{ne{t}_Y}^T$$
2. 对于上述的过程，扩展到其他层有:
   $$\frac{\partial J}{\partial W_m}=m{\delta }_{ne{t}_X}^T$$
   $$\frac{\partial J}{\partial W_k}=k{\delta }_{ne{t}_m}^T$$

4.2 权重B的更新

B的更新相对于W要简单很多。同样也是将每一层对于B的更新的梯度的求和。

1. 首先$X_1,X_2,root$层的B，根据计算公式$ne{t}_{root}=W^{T}X+B$有：
   $$\frac{\partial ne{t}_Y}{\partial B_1}=\frac{\partial ne{t}_{Y_1}}{\partial B_1}=1$$
   $$\frac{\partial ne{t}_Y}{\partial B_2}=\frac{\partial ne{t}_{Y_2}}{\partial B_2}=1$$
   则$ne{t}_Y$关于B的梯度值为：${\delta }_{ne{t}_Y}$。
   同理可以推导到其他层中：
   ${\delta }_{ne{t}_X}$
   ${\delta }_{ne{t}_m}$

4.2 求和更新

$$\frac{\partial J}{\partial W}=\frac{\partial J}{\partial W_X}+\frac{\partial J}{\partial W_m}+\frac{\partial J}{\partial W_k}=\sum _{i=X,m,k}\frac{\partial J}{\partial W_i}$$
$$\frac{\partial J}{\partial B}={\delta }_{ne{t}_Y}+{\delta }_{ne{t}_X}+{\delta }_{ne{t}_m}$$
$$W_{new}=W-\alpha \frac{\partial J}{\partial W}$$
$$B_{new}=B-\alpha \frac{\partial J}{\partial B}$$

5、反向传播及误差更新的实现

def backward(self,parent_delta):
        self.calc_delta(parent_delta,self.root)
        self.W_grad,self.B_grad = self.calc_gradient(self.root)
    def calc_delta(self,parent_delta,parent):
        '''
        计算δ值
        '''
        parent.delta = parent_delta
        if parent.children:
            children_delta = np.dot(self.W,parent_delta)
            slices = [(i,i*self.node_dim,(i+1)*self.node_dim) for i in range(self.child_count)]
            #针对每一个子节点，计算梯度
            for s in slices:
                self.calc_delta(children_delta[s[1]:s[2]],parent.children[s[0]])
    def calc_gradient(self,parent):
        '''
        计算关于W和B的梯度的累加和
        '''
        W_grad = np.zeros((self.child_count*self.node_dim,self.node_dim))
        B_grad = np.zeros((self.node_dim,1))
        if not parent.children:
            return W_grad,B_grad
        parent.W_grad = np.dot(parent.children_data,parent.delta.T)
        parent.B_grad = parent.delta
        W_grad += parent.W_grad
        B_grad += parent.B_grad
        for child in parent.children:
            W,B = self.calc_gradient(child)
            W_grad += W
            B_grad += B
        return W_grad,B_grad
    def update(self):
        self.W -= self.lr * self.W_grad
        self.B -= self.lr * self.B_grad

注意：在代码中，为了计算方便，选择了y=x的激活方式

6、参考文章

零基础入门深度学习(六)：递归神经网络