初始化参数
与传统的神经网络不同，RNN具有3个权重参数，即：
输入权重（input weights），内部状态权重（internal state weights）和输出权重（output weights）
首先用随机数值初始化上述三个参数。
之后，将词嵌入维度（word_embedding dimension）和输出维度（output dimension）分别初始化为100和80。
输出维度是词汇表中存在的唯一词向量的总数。
hidden_dim = 100 output_dim = 80 # this is the total unique words in the vocabulary input_weights = np.random.uniform(0, 1, (hidden_dim,hidden_dim)) internal_state_weights = np.random.uniform(0,1, (hidden_dim, hidden_dim)) output_weights = np.random.uniform(0,1, (output_dim,hidden_dim))
变量prev_memory指的是internal_state（这些是先前序列的内存）。
其他参数也给予了初始化数值。
input_weight梯度，internal_state_weight梯度和output_weight梯度分别命名为dU，dW和dV。
变量bptt_truncate表示网络在反向传播时必须回溯的时间戳数，这样做是为了克服梯度消失的问题。
prev_memory = np.zeros((hidden_dim,1)) learning_rate = 0.0001 nepoch = 25 T = 4 # length of sequence bptt_truncate = 2 dU = np.zeros(input_weights.shape) dV = np.zeros(output_weights.shape) dW = np.zeros(internal_state_weights.shape)
前向传播
输出和输入向量
例如有一句话为：I like to play.，则假设在词汇表中：
I被映射到索引2，like对应索引45，to对应索引10、**对应索引64而标点符号.** 对应索引1。
为了展示从输入到输出的情况，我们先随机初始化每个单词的词嵌入。
input_string = [2,45,10,65] embeddings = [] # this is the sentence embedding list that contains the embeddings for each word for i in range(0,T): x = np.random.randn(hidden_dim,1) embeddings.append(x)
输入已经完成，接下来需要考虑输出。
在本项目中，RNN单元接受输入后，输出的是下一个最可能出现的单词。
用于训练RNN，在给定第t+1个词作为输出的时候将第t个词作为输入，例如：在RNN单元输出字为“like”的时候给定的输入字为“I”.
现在输入是嵌入向量的形式，而计算损失函数（Loss）所需的输出格式是独热编码（One-Hot）矢量。
这是对输入字符串中除第一个单词以外的每个单词进行的操作，因为该神经网络学习只学习的是一个示例句子，而初始输入是该句子的第一个单词。
RNN的黑箱计算
现在有了权重参数，也知道输入和输出，于是可以开始前向传播的计算。
训练神经网络需要以下计算：
其中：
U代表输入权重、W代表内部状态权重，V代表输出权重。
输入权重乘以input(x)，内部状态权重乘以前一层的激活（prev_memory）。
层与层之间使用的激活函数用的是tanh。
def tanh_activation(Z): return (np.exp(Z)-np.exp(-Z))/(np.exp(Z)-np.exp(-Z)) # this is the tanh function can also be written as np.tanh(Z) def softmax_activation(Z): e_x = np.exp(Z - np.max(Z)) # this is the code for softmax function return e_x / e_x.sum(axis=0)
def Rnn_forward(input_embedding, input_weights, internal_state_weights, prev_memory,output_weights): forward_params = [] W_frd = np.dot(internal_state_weights,prev_memory) U_frd = np.dot(input_weights,input_embedding) sum_s = W_frd + U_frd ht_activated = tanh_activation(sum_s) yt_unactivated = np.asarray(np.dot(output_weights, tanh_activation(sum_s))) yt_activated = softmax_activation(yt_unactivated) forward_params.append([W_frd,U_frd,sum_s,yt_unactivated]) return ht_activated,yt_activated,forward_params
计算损失函数
之后损失函数使用的是交叉熵损失函数，由下式给出：
def calculate_loss(output_mapper,predicted_output): total_loss = 0 layer_loss = [] for y,y_ in zip(output_mapper.values(),predicted_output): # this for loop calculation is for the first equation, where loss for each time-stamp is calculated loss = -sum(y[i]*np.log2(y_[i]) for i in range(len(y))) loss = loss/ float(len(y)) layer_loss.append(loss) for i in range(len(layer_loss)): #this the total loss calculated for all the time-stamps considered together. total_loss = total_loss + layer_loss[i] return total_loss/float(len(predicted_output))
最重要的是，我们需要在上面的代码中看到第5行。
正如所知，ground_truth output(y)的形式是[0，0，….，1，…0]和predicted_output(y^hat)是[0.34，0.03，……，0.45]的形式，我们需要损失是单个值来从它推断总损失。
为此，使用sum函数来获得特定时间戳下y和y^hat向量中每个值的误差之和。
total_loss是整个模型（包括所有时间戳）的损失。
反向传播
反向传播的链式法则：
如上图所示：
Cost代表误差，它表示的是y^hat到y的差值。
由于Cost是的函数输出，因此激活a所反映的变化由dCost/da表示。
实际上，这意味着从激活节点的角度来看这个变化（误差）值。
类似地，a相对于z的变化表示为da/dz，z相对于w的变化表示为dw/dz。
最终，我们关心的是权重的变化（误差）有多大。
而由于权重与Cost之间没有直接关系，因此期间各个相对的变化值可以直接相乘（如上式所示）。
RNN的反向传播
由于RNN中存在三个权重，因此我们需要三个梯度。input_weights(dLoss / dU)，internal_state_weights(dLoss / dW)和output_weights(dLoss / dV)的梯度。
这三个梯度的链可以表示如下：
所述dLoss/dy_unactivated代码如下：
def delta_cross_entropy(predicted_output,original_t_output): li = [] grad = predicted_output for i,l in enumerate(original_t_output): #check if the value in the index is 1 or not, if yes then take the same index value from the predicted_ouput list and subtract 1 from it. if l == 1: #grad = np.asarray(np.concatenate( grad, axis=0 )) grad[i] -= 1 return grad
计算两个梯度函数，一个是multiplication_backward，另一个是additional_backward。
在multiplication_backward的情况下，返回2个参数，一个是相对于权重的梯度（dLoss / dV），另一个是链梯度（chain gradient），该链梯度将成为计算另一个权重梯度的链的一部分。
在addition_backward的情况下，在计算导数时，加法函数（ht_unactivated）中各个组件的导数为1。例如：dh_unactivated / dU_frd=1（h_unactivated = U_frd + W_frd），且dU_frd / dU_frd的导数为1。
所以，计算梯度只需要这两个函数。multiplication_backward函数用于包含向量点积的方程，addition_backward用于包含两个向量相加的方程。
def multiplication_backward(weights,x,dz): gradient_weight = np.array(np.dot(np.asmatrix(dz),np.transpose(np.asmatrix(x)))) chain_gradient = np.dot(np.transpose(weights),dz) return gradient_weight,chain_gradient def add_backward(x1,x2,dz): # this function is for calculating the derivative of ht_unactivated function dx1 = dz * np.ones_like(x1) dx2 = dz * np.ones_like(x2) return dx1,dx2 def tanh_activation_backward(x,top_diff): output = np.tanh(x) return (1.0 - np.square(output)) * top_diff
至此，已经分析并理解了RNN的反向传播，目前它是在单个时间戳上实现它的功能，之后可以将其用于计算所有时间戳上的梯度。
如下面的代码所示，forward_params_t是一个列表，其中包含特定时间步长的网络的前向参数。
变量ds是至关重要的部分，因为此行代码考虑了先前时间戳的隐藏状态，这将有助于提取在反向传播时所需的信息。
def single_backprop(X,input_weights,internal_state_weights,output_weights,ht_activated,dLo,forward_params_t,diff_s,prev_s):# inlide all the param values for all the data thats there W_frd = forward_params_t[0][0] U_frd = forward_params_t[0][1] ht_unactivated = forward_params_t[0][2] yt_unactivated = forward_params_t[0][3] dV,dsv = multiplication_backward(output_weights,ht_activated,dLo) ds = np.add(dsv,diff_s) # used for truncation of memory dadd = tanh_activation_backward(ht_unactivated, ds) dmulw,dmulu = add_backward(U_frd,W_frd,dadd) dW, dprev_s = multiplication_backward(internal_state_weights, prev_s ,dmulw) dU, dx = multiplication_backward(input_weights, X, dmulu) #input weights return (dprev_s, dU, dW, dV)
对于RNN，由于存在梯度消失的问题，所以采用的是截断的反向传播，而不是使用原始的。
在此技术中，当前单元将只查看k个时间戳，而不是只看一次时间戳，其中k表示要回溯的先前单元的数量。
def rnn_backprop(embeddings,memory,output_t,dU,dV,dW,bptt_truncate,input_weights,output_weights,internal_state_weights): T = 4 # we start the backprop from the first timestamp. for t in range(4): prev_s_t = np.zeros((hidden_dim,1)) #required as the first timestamp does not have a previous memory, diff_s = np.zeros((hidden_dim,1)) # this is used for the truncating purpose of restoring a previous information from the before level predictions = memory["yt" + str(t)] ht_activated = memory["ht" + str(t)] forward_params_t = memory["params"+ str(t)] dLo = delta_cross_entropy(predictions,output_t[t]) #the loss derivative for that particular timestamp dprev_s, dU_t, dW_t, dV_t = single_backprop(embeddings[t],input_weights,internal_state_weights,output_weights,ht_activated,dLo,forward_params_t,diff_s,prev_s_t) prev_s_t = ht_activated prev = t-1 dLo = np.zeros((output_dim,1)) #here the loss deriative is turned to 0 as we do not require it for the turncated information. # the following code is for the trunated bptt and its for each time-stamp. for i in range(t-1,max(-1,t-bptt_truncate),-1): forward_params_t = memory["params" + str(i)] ht_activated = memory["ht" + str(i)] prev_s_i = np.zeros((hidden_dim,1)) if i == 0 else memory["ht" + str(prev)] dprev_s, dU_i, dW_i, dV_i = single_backprop(embeddings[t] ,input_weights,internal_state_weights,output_weights,ht_activated,dLo,forward_params_t,dprev_s,prev_s_i) dU_t += dU_i #adding the previous gradients on lookback to the current time sequence dW_t += dW_i dV += dV_t dU += dU_t dW += dW_t return (dU, dW, dV)
权重更新
一旦使用反向传播计算了梯度，则更新权重势在必行，而这些是通过批量梯度下降法
def gd_step(learning_rate, dU,dW,dV, input_weights, internal_state_weights,output_weights ): input_weights -= learning_rate* dU internal_state_weights -= learning_rate * dW output_weights -=learning_rate * dV return input_weights,internal_state_weights,output_weights
训练序列
完成了上述所有步骤，就可以开始训练神经网络了。
用于训练的学习率是静态的，还可以使用逐步衰减等更改学习率的动态方法。
def train(T, embeddings,output_t,output_mapper,input_weights,internal_state_weights,output_weights,dU,dW,dV,prev_memory,learning_rate=0.001, nepoch=100, evaluate_loss_after=2): losses = [] for epoch in range(nepoch): if(epoch % evaluate_loss_after == 0): output_string,memory = full_forward_prop(T, embeddings ,input_weights,internal_state_weights,prev_memory,output_weights) loss = calculate_loss(output_mapper, output_string) losses.append(loss) time = datetime.now().strftime('%Y-%m-%d %H:%M:%S') print("%s: Loss after epoch=%d: %f" % (time,epoch, loss)) sys.stdout.flush() dU,dW,dV = rnn_backprop(embeddings,memory,output_t,dU,dV,dW,bptt_truncate,input_weights,output_weights,internal_state_weights) input_weights,internal_state_weights,output_weights= sgd_step(learning_rate,dU,dW,dV,input_weights,internal_state_weights,output_weights) return losses losses = train(T, embeddings,output_t,output_mapper,input_weights,internal_state_weights,output_weights,dU,dW,dV,prev_memory,learning_rate=0.0001, nepoch=10, evaluate_loss_after=2)
