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。所以：
$h_t=tanh(Ux_t+Wh_{t-1}) \\a_t=softmax(Vh_t)$

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

$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

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

在 $t$ 时刻，总的 $Loss$ 对 $layer2_i$ 的偏导为（这里下标 $i$ 表示输出向量的第 $i$ 项）：
$\frac{\alpha Loss}{\alpha layer2_i}=\sum_{j=1}^{n}(\frac{\alpha Loss_j}{\alpha a_j}\frac{\alpha a_j}{\alpha layer2_i})$
首先看 $Loss_j$ 对 $a_j$ 的偏导，
$\frac{\alpha Loss_j}{\alpha a_j} = -y_j\frac{1}{a_j}$
然后看 $a_j$ 对 $layer2_i$ 的偏导。注意这里是 $j$ 对 $i$
$\frac{\alpha a_j}{\alpha layer2_i} = \begin{cases} a_i(1-a_i), & \text{if $i=j$} \\ -a_ja_i, & \text{else} \end{cases}$
$\nabla layer2_i=\frac{\alpha Loss}{\alpha layer2_i}=\sum_{j \neq i}^{n}-y_j\frac{1}{a_j}(-a_ja_i) + (-y_i\frac{1}{a_i})(a_i(1-ai)) \\=\sum_{j \neq i}^{n}y_ja_i+y_ia_i-y_i \\=a_i\sum_{j=1}^{n}y_j-yi$
针对分类问题，真值y是一个独热码，只有一位为1其余均为0，所以上述梯度为：
$\nabla layer2_i=a_i-y_i$
总的这一层的梯度为：
$\nabla layer2=-\frac{\alpha Loss}{\alpha layer2}= -[\nabla layer2_1,...,\nabla layer2_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)*(V^T\nabla layer2+W^T\nabla layer1_{next})$
$\nabla W=h_{t-1}^T \nabla layer1 \\\nabla U=x_t \nabla layer1$
这里 $\nabla layer1_{next}$ 是下一时刻的 $\nabla layer1$ ，最后时刻 $\nabla layer1_{next}$ 初始化为0，然后每向前计算一次， $\nabla layer1_{next}$ 就更新为这次的 $\nabla layer1$ 。

对每一个时刻，累积计算增量：
$V_{update} += \nabla V\\ W_{update}+=\nabla W \\ U_{update}+=\nabla U$
最后，更新权重：
$V+=alpha*V_{update}\\ W+=alpha*W_{update}\\ U+=alpha*U_{update}$
其中 $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)

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

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

1. 前向传播

2. 反向传播

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

隐含层到输出层权重:V

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

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

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

我真的从测试转成了开发......

零基础写框架(2)：故障排查和日志基础

芯片产业管理和营销指北（1）—— 产品线经理主要职能

记一次疑似JVM内存泄漏的排查过程

简单4步，带你用华为云MetaStudio制作数字人短片

Simple-RNN 前向反向傳播原理及代碼詳解

統計學習方法之感知機 python代碼實現

python 發票驗證碼自動生成

windows下virtualenv和virtualenvwrapper的使用方法命令

用python開發微信公衆平臺聊天機器人

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

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

1. 前向传播

2. 反向传播

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

隐含层到输出层权重:V

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

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

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

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