首先介绍一下RNN，RNN全程为循环神经网络，主要用来解决一些序列化具有顺序的输入的问题。普通的前馈神经网络的输入单一决定输出，输出只由输入决定，比如一个单调函数的拟合，一个x决定一个y，前馈神经网络可以直接拟合出一条曲线并得到不错的拟合效果。再举一个例子，给出sin(x)的值，假设x属于[0, 2π)，让你输出x的值是多少，前馈神经网络还能直接做到吗？显然是不可以的，因为一个sin(x)在一个周期内对应着多个值，单一的信息是不能直接确定x的值的，因此无法简单地通过前馈神经网络做到很好的拟合。那么这个时候要推测x的值，就不仅需要sin(x)的值，还需要sin(x)的值在前几个时刻的值来共同确定，放在连续函数中来说就是不仅需要函数在这个点的值，还需要函数在这个点的导数才行。而RNN正是一个可以解决这样问题的神经网络，它不仅考虑当前的输入，还同时考虑之前多个时刻的输入，并由多个时刻的状态共同决定输出。
首先看看这个模型的结构图：
假设模型的原始输入是一段文本，这段文本显然是由一个一个单词挨个连接而成的，是有序的，比如一句话"I love you"和另一句话"You love me"，意思就是不同的，尽管组成这两句话的单词是完全一样的。而RNN网络的输入就是这样一个有序的序列输入。同时每一个状态的输出不仅由当前节点的输入决定，同时还受上一时刻的状态所影响，这个理念和理解一句话中的某个单词很相似，当前单词的意思不仅由这个单词本身决定，还要受到之前的词，也就是当前单词所处的语境的影响。回到之前的例子，
首先，前文一直提到当前状态的输出不仅和当前的输入有关，还和上一个状态有关，体现在公式上就是：
模型的反向传播部分的话我就不多加阐述了，我参考的仍然是刘建平老师的博客，原博客讲得很好。其实自己也完完全全推导了一遍RNN的反向传播求导的公式，求出了最后每个元素求导的公式，奈何数学功底不够，没能强行变换成一个整体的公式，因为这个diag(1-h(t)^2)之前完全没想到可以这么整，可能你现在已经听不懂我在说啥了，但是如果你先自己推导一遍，然后卡住了之后再去看那个博客，你就会懂的（斜眼笑）
目前代码还存在一些问题（也可能是很多问题），后续会修改
首先我们来看初始化部分：
window_size：表示输入单词的个数，也可以理解成 t
hidden_size：就是每个节点隐藏层的维数
embed_size：就是每个单词embedding的维数
n_class：就是分类的类数，比如单词预测中问题中，n_class就是词典的大小
# model.py
class RNN:
def __init__(self, window_size, hidden_size, embed_size, n_class):
self.hidden_size = hidden_size
self.window_size = window_size
self.n_classs = n_class
self.embed_size = embed_size
self.w = np.random.random((hidden_size, hidden_size))
self.u = np.random.random((hidden_size, embed_size))
self.v = np.random.random((n_class, hidden_size))
self.b = np.random.random((hidden_size, 1))
self.c = np.random.random((n_class, 1))
self.x = []
self.hidden_node_list = []
# window_size means how many words in each input batch
# for example, if i input "I love apple" into the network, then the window_size is 3
for i in range(window_size):
# initialize all the nodes in the hidden layer
# then the net will calculate some related value in the forward part
new_node = np.random.random((hidden_size, 1))
self.hidden_node_list.append(new_node)
然后看一下前向传播：
# model.py
def forward(self, x):
self.x = x
# default h0 = 0
h0 = np.zeros((self.hidden_size, 1))
# before calculate, we need to clear the node list of the net
self.hidden_node_list.clear()
# calculate some intermediate variables
for i in range(self.window_size):
new_node = Node()
if i == 0:
new_node.h = np.tanh(np.dot(self.u, x[0]) + np.dot(self.w, h0) + self.b)
else:
new_node.h = np.tanh(np.dot(self.u, x[i]) + np.dot(self.w, self.hidden_node_list[i - 1].h))
new_node.d_tanh = 1 - new_node.h ** 2
new_node.o = np.dot(self.v, new_node.h) + self.c
self.hidden_node_list.append(new_node)
明白了RNN前向传播的公式的话，forward这部分应该很好懂。
接着看RNN的反向传播，建议数学推导搞明白后再看代码，那样会很明了：
# model.py
def backward(self, target_output, lr):
h0 = np.zeros((self.hidden_size, 1))
# then calculate the gradient in each hidden layer
predict = softmax(self.hidden_node_list[-1].o)
for i in range(self.window_size):
j = self.window_size - i - 1
if i == 0:
self.hidden_node_list[j].e = np.dot(self.v.T, predict - target_output)
else:
temp = np.dot(self.w.T, diag(self.hidden_node_list[j + 1].d_tanh))
self.hidden_node_list[j].e = np.dot(temp, self.hidden_node_list[j + 1].e)
dloss_w = np.zeros((self.hidden_size, self.hidden_size))
dloss_u = np.zeros((self.hidden_size, self.embed_size))
dloss_b = np.zeros((self.hidden_size, 1))
dloss_c = predict - target_output
dloss_v = np.dot(predict-target_output, self.hidden_node_list[-1].h.T)
for i in range(self.window_size):
temp = np.dot(diag(self.hidden_node_list[i].d_tanh), self.hidden_node_list[i].e)
if i == 0:
# seem unnecessary~
dloss_w += 0
else:
dloss_w += np.dot(temp, self.hidden_node_list[i - 1].h.T)
dloss_b += temp
dloss_u += np.dot(temp, self.x[i].T)
self.w -= lr * dloss_w
self.u -= lr * dloss_u
self.v -= lr * dloss_v
self.b -= lr * dloss_b
self.c -= lr * dloss_c
最后附上本博客的github代码