Simple-RNN 前向反向传播 原理及代码详解

RNN是最简单的循环神经网络，称谓Simple-RNN，它是LSTM的基础。下面看结构：

输入层到隐含层的权重用U表示，隐含层到隐含层的权重用W表示，隐含层到输出层的权重用V表示。

1. 前向传播

可以将网络看成是一个三层结构，与普通BP神经网络不同的是，输入层有两个部分，一个是上一时刻的隐层向量（h_t-1)；一个是本次的输入向量（x_t)。隐含层(h_t)也会有两个走向，一个作为本次输出到达输出层；同时h_t也作为下一时刻的输入。
公式如下，在时间步t时:
　　　　　　　　　　　　h_t = f(U．x_t + W．h_t-1)
　　　　　　　　　　　　a_t = g(V．h_t)
其中f是隐含层激活函数，一般是tanh。g是输出层激活函数，一般是softmax。所以：
$$\begin{gathered} h_t=tanh(U{x}_t+W{h}_{t-1}) \\ {a}_t=softmax(V{h}_t) \end{gathered}$$

损失函数，这里我们选择交叉熵:

$$Loss=-\sum _{i=1}^n{y}_t(i)\ln a_t(i)$$
其中$y{}_t(i)$表示真实值(标签）的第$i$个值，$a_t(i)$表示输出值的第$i$个值,$n$表示输出向量的长度。

2. 反向传播

反向传播是将误差通过输出层->隐含层->输入层逐层反传，并通过激活函数的导函数将误差分摊给各层的所有单元，从而获得各层单元的修正信号，并以信号作为依据修正各单元的权重。RNN的反向传播是从最后一个时间将累积的残差传递回来，所以梯度是从最后一个时刻开始计算，然后依次往前更新。

从结构图可以看出,Simple-RNN一共包含三个权重：

隐含层到输出层权重:V

输入层到隐含曾权重:U，W

这里将上面前向传播的式子拆开：
$$\begin{gathered} layer{1}_t=U{x}_t+W{h}_{t-1}{h}_t=tanh(layer{1}_t) \\ layer{2}_t=V{h}_t{a}_t=softmax(layer{2}_t) \end{gathered}$$
对于时刻$t$，先看最简单的权重$V$，它的更新只与输出层的误差有关，说白了就是一个全连接层。关于softmax和交叉熵的求导过程可以参考这篇博客： 简单易懂的softmax交叉熵损失函数求导

在$t$时刻，总的$Loss$对$layer{2}_i$的偏导为（这里下标$i$表示输出向量的第$i$项）：
$$\frac{\alpha Loss}{\alpha layer{2}_i}=\sum _{j=1}^n(\frac{\alpha Los{s}_j}{\alpha a_j}\frac{\alpha a_j}{\alpha layer{2}_i})$$
首先看$Los{s}_j$对$a_j$的偏导，
$$\frac{\alpha Los{s}_j}{\alpha a_j}=-y_j\frac{1}{a_j}$$
然后看$a_j$对$layer{2}_i$的偏导。注意这里是$j$对$i$
$$\frac{\alpha a_j}{\alpha layer{2}_i}=\{\begin{array}{ll}{a}_i(1-a_i),& \text{if i=j}\\ -a_j{a}_i,& \text{else}\end{array}$$
$$\begin{gathered} \nabla layer{2}_i=\frac{\alpha Loss}{\alpha layer{2}_i}=\sum _{j̸=i}^n-y_j\frac{1}{a_j}(-a_j{a}_i)+(-y_i\frac{1}{a_i})(a_i(1-ai)) \\ =\sum _{j̸=i}^n{y}_j{a}_i+y_i{a}_i-y_i \\ =a_i\sum _{j=1}^n{y}_j-yi \end{gathered}$$
针对分类问题，真值y是一个独热码，只有一位为1其余均为0，所以上述梯度为：
$$\nabla layer{2}_i=a_i-y_i$$
总的这一层的梯度为：
$$\nabla layer2=-\frac{\alpha Loss}{\alpha layer2}=-[\nabla layer{2}_1,...,\nabla layer{2}_n]$$
这里加上一个负号，是为了让后面更新权重的时候用加法。如果这里不加负号，后面更新权重就用减法。最后$\nabla layer2$其实是一个向量$\nabla layer2=-[a_1,a_2,...,(a_k-1),...,a_n]$，这里$k$就是标签中独热码为1的那一位，也就是除了这一位其它位的梯度都一样是softmax的值本身。
$$\nabla V=-\frac{\alpha Loss}{\alpha layer2}\frac{\alpha layer2}{\alpha V}=h_t^T\nabla layer2$$
然后，再来看$W和U$，由于它们的梯度依赖于之前的状态，所以需要从后向前依次求解：
首先是$tanh(x)$的梯度：
$$\frac{\alpha tanh(x)}{\alpha x}=1-tanh(x{)}^2$$
然后
$$\nabla layer1=(1-h_t^2)\ast (V^T\nabla layer2+W^T\nabla layer{1}_{next})$$
$$\begin{gathered} \nabla W=h_{t-1}^T\nabla layer1 \\ \nabla U=x_t\nabla layer1 \end{gathered}$$
这里$\nabla layer{1}_{next}$是下一时刻的$\nabla layer1$，最后时刻$\nabla layer{1}_{next}$初始化为0，然后每向前计算一次，$\nabla layer{1}_{next}$就更新为这次的$\nabla layer1$。

对每一个时刻，累积计算增量：
$$\begin{gathered} V_{update}+=\nabla V \\ {W}_{update}+=\nabla W \\ {U}_{update}+=\nabla U \end{gathered}$$
最后，更新权重：
$$\begin{gathered} V+=alpha\ast V_{update} \\ W+=alpha\ast W_{update} \\ U+=alpha\ast U_{update} \end{gathered}$$
其中$alpha$是学习率。好了，至此RNN的反向传播就结束了。下面放出详细代码：（代码中的权重和层的乘积是右乘，上面公式中写的左乘，不过相信这应该不算什么）

import numpy as np


class RNN:

    def __init__(self, in_shape, unit, out_shape):
        '''
        :param in_shape: 输入x向量的长度
        :param unit: 隐层大小
        :param out_shape: 输出y向量的长度
        '''
        self.U = np.random.random(size=(in_shape, unit))
        self.W = np.random.random(size=(unit, unit))
        self.V = np.random.random(size=(unit, out_shape))

        self.in_shape = in_shape
        self.unit = unit
        self.out_shape = out_shape

        self.start_h = np.random.random(size=(self.unit,))  # 初始隐层状态

    @staticmethod
    def tanh(x):
        return (np.exp(x)-np.exp(-x))/(np.exp(x)+np.exp(-x))

    @staticmethod
    def tanh_der(y):
        return 1 - y*y

    @staticmethod
    def softmax(x):
        tmp = np.exp(x)
        return tmp/sum(tmp)

    @staticmethod
    def softmax_der(y, y_):
        j = np.argmax(y_)
        tmp = y[j]
        y = -y[j]*y
        y[j] = tmp*(1-tmp)
        return y

    @staticmethod
    def cross_entropy(y, y_):
        '''
        交叉熵
        :param y:预测值
        :param y_: 真值
        :return:
        '''
        return sum(-np.log(y)*y_)

    @staticmethod
    def cross_entropy_der(y, y_):
        j = np.argmax(y_)
        return -1/y[j]

    def inference(self, x, h_1):
        '''
        前向传播
        :param x: 输入向量
        :param h_1: 上一隐层
        :return:
        '''
        h = self.tanh(np.dot(x, self.U) + np.dot(h_1, self.W))
        y = self.softmax(np.dot(h, self.V))
        return h, y

    def train(self, x_data, y_data, alpha=0.1, steps=100):
        '''
        训练RNN
        :param x_data: 输入样本
        :param y_data: 标签
        :param alpha: 学习率
        :param steps: 迭代伦次
        :return:
        '''
        for step in range(steps):  # 迭代伦次
            print("step:", step+1)
            for xs, ys in zip(x_data,y_data):  # 每个样本
                h_list = []
                h = self.start_h  # 初始化初始隐层状态
                h_list.append(h)
                y_list = []
                losses = []
                for x, y_ in zip(xs, ys):  # 前向传播
                    h, y = self.inference(x, h)
                    loss = self.cross_entropy(y=y, y_=y_)
                    h_list.append(h)
                    y_list.append(y)
                    losses.append(loss)
                print("loss:", np.mean(losses))
                V_update = np.zeros(shape=self.V.shape)
                U_update = np.zeros(shape=self.U.shape)
                W_update = np.zeros(shape=self.W.shape)
                next_layer1_delta = np.zeros(shape=(self.unit,))

                for i in range(len(xs))[::-1]:  # 反向传播
                    layer2_delta = -self.cross_entropy_der(y_list[i], ys[i])*self.softmax_der(y_list[i], ys[i])  # 输出层误差
                    # 当前隐层梯度 = 下一隐层梯度 * 下一隐层权重 + 输出层梯度 * 输出层权重
                    layer1_delta = self.tanh_der(h_list[i+1])*(np.dot(layer2_delta, self.V.T) + np.dot(next_layer1_delta, self.W.T))

                    V_update += np.dot(np.atleast_2d(h_list[i+1]).T, np.atleast_2d(layer2_delta))  # V增量
                    W_update += np.dot(np.atleast_2d(h_list[i]).T,  np.atleast_2d(layer1_delta))  # W增量
                    U_update += np.dot(np.atleast_2d(xs[i]).T,  np.atleast_2d(layer1_delta))  # U增量

                    next_layer1_delta = layer1_delta  # 更新下一隐层的梯度等于当前隐层的梯度
                self.W += W_update * alpha
                self.V += V_update * alpha
                self.U += U_update * alpha
                # print(self.W,self.V,self.U)

    def predict(self, xs, return_sequence=False):
        '''
        RNN预测
        :param xs: 单个样本
        :param return_sequence: 是否返回整个输出序列
        :return:
        '''

        y_list = []
        h_list = []
        h = self.start_h
        for x in xs:
            h, y = self.inference(x,h)
            y_list.append(y)
            h_list.append(h)
        if return_sequence:
            return h_list, y_list
        else:
            return h_list[-1], y_list[-1]

然后做一个简单地测试：

预测26个字母中的下一个字母

这里偷懒只写了前面9个字母"abcdefghi",相对需要的样本比较少。

class RNNTest:

    def __init__(self, hidden_num, all_chars):
        '''
        创建一个rnn
        :param hidden_num: 隐层数目
        :param all_chars: 所有字符集
        '''
        self.all_chars = all_chars
        self.len = len(all_chars)
        self.rnn = RNN(self.len, hidden_num, self.len)

    def str2onehots(self, string):
        '''
        字符串转独热码
        :param string:
        :return:
        '''
        one_hots = []
        for char in string:
            one_hot = np.zeros((self.len,),dtype=np.int)
            one_hot[self.all_chars.index(char)] = 1
            one_hots.append(one_hot)
        return one_hots

    def vector2char(self, vector):
        '''
        预测向量转字符
        :param vector:
        :return:
        '''
        return self.all_chars[int(np.argmax(vector))]

    def run(self, x_data, y_data, alpha=0.1, steps=100):

        x_data_onehot = [self.str2onehots(xs) for xs in x_data]
        y_data_onehot = [self.str2onehots(ys) for ys in y_data]
        self.rnn.train(x_data_onehot, y_data_onehot, alpha=alpha, steps=steps) # 训练
        vector_f = self.rnn.predict(self.str2onehots("f"), False)[1] # 预测f下一个字母
        vector_ab = self.rnn.predict(self.str2onehots("ab"), False)[1] # 预测ab的下一个字母
        print("f.next=",self.vector2char(vector_f))
        print("ab.next=",self.vector2char(vector_ab))


# 测试：下一个字母
x_data = ["abc","bcd","cdef","fgh","a","bc","abcdef"]
y_data = ["bcd","cde","defg","ghi","b","cd","bcdefg"]
all_chars = "abcdefghi"

rnn_test = RNNTest(10, all_chars)
rnn_test.run(x_data,y_data)

测试运行把这两份代码，放在一个文件就好了。如果预测结果不对，就再跑一次，样本有限有时候收敛的不好。放个结果图：

都看到这里了，点个赞呗！