如何从NumPy直接创建RNN?

作者:神秘网友 发布时间:2020-10-19 07:27:58

如何从NumPy直接创建RNN?

如何从NumPy直接创建RNN?
木易 发自 凹非寺 
量子位 报道 | 公众号 QbitAI

使用成熟的Tensorflow、PyTorch框架去实现递归神经网络(RNN),已经极大降低了技术的使用门槛。

但是,对于初学者,这还是远远不够的。知其然,更需知其所以然。

如何从NumPy直接创建RNN?

要避免低级错误,打好理论基础,然后使用RNN去解决更多实际的问题的话。

那么,有一个有趣的问题可以思考一下:

不使用Tensorflow等框架,只有Numpy的话,你该如何构建RNN?

没有头绪也不用担心。这里便有一项教程:使用Numpy从头构建用于NLP领域的RNN。

可以带你行进一遍RNN的构建流程。

与传统的神经网络不同,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的黑箱计算

现在有了权重参数,也知道输入和输出,于是可以开始前向传播的计算。

训练神经网络需要以下计算:

如何从NumPy直接创建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

计算损失函数

之后损失函数使用的是交叉熵损失函数,由下式给出:

如何从NumPy直接创建RNN?

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是整个模型(包括所有时间戳)的损失。

反向传播的链式法则:

如何从NumPy直接创建RNN?

如上图所示:

Cost代表误差,它表示的是y^hat到y的差值。

由于Cost是的函数输出,因此激活a所反映的变化由dCost/da表示。

实际上,这意味着从激活节点的角度来看这个变化(误差)值。

类似地,a相对于z的变化表示为da/dz,z相对于w的变化表示为dw/dz。

最终,我们关心的是权重的变化(误差)有多大。

如何从NumPy直接创建RNN?

而由于权重与Cost之间没有直接关系,因此期间各个相对的变化值可以直接相乘(如上式所示)。

RNN的反向传播

由于RNN中存在三个权重,因此我们需要三个梯度。input_weights(dLoss / dU),internal_state_weights(dLoss / dW)和output_weights(dLoss / dV)的梯度。

这三个梯度的链可以表示如下:

如何从NumPy直接创建RNN?

所述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用于包含两个向量相加的方程。

如何从NumPy直接创建RNN?

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)

恭喜你!你现在已经实现从头建立递归神经网络了!

那么,是时候了,继续向LSTM和GRU等的高级架构前进吧。

原文链接:

https://medium.com/@rndholakia/implementing-recurrent-neural-network-using-numpy-c359a0a68a67

本文系网易新闻?网易号特色内容激励计划签约账号【量子位】原创内容,未经账号授权,禁止随意转载。

「百度AI开发」系列课 免费报名

百度EasyDL不仅让企业「定制AI模型」像家用电器一般简单,并且还能像高级AI工程师一样专业。

10.21日起,3期公开课带你0门槛轻松上手EasyDL、实现AI模型训练与部署!扫码添加好友、加入课程直播群吧~ 

如何从NumPy直接创建RNN?

如何从NumPy直接创建RNN?

量子位 QbitAI · 头条号签约作者

?'?' ? 追踪AI技术和产品新动态

喜欢就点「在看」吧 !

如何从NumPy直接创建RNN?相关教程

  1. 如何下载微信直播视频(方法篇HLS视频流)

    如何下载微信直播视频(方法篇,HLS视频流) HLS视频流,直播视频下载,会议视频下载 一般视频下载 针对HLS视频流 1 安装chrome的浏览器插件 Video Downloader Pro 2 将视频播放地址在新标签页打开,然后点击插件会自动弹出。 因为部分直播中使用的是HLS视频

  2. 如何评估DeFi项目的风险看Gauntlet与DeFiPulse的风险评分工具

    如何评估DeFi项目的风险?看Gauntlet与DeFiPulse的风险评分工具 DeFi参与者很大可能也难以评估项目的风险,这对社区以外的参与者来说就更难了。然而DeFi想要扩大受众面,让受众对风险有充分认识是必不可少的。10月14日,DeFi实时数据分析平台DeFi Pulse宣布

  3. 漫画科普:芯片是如何设计出来的

    漫画科普:芯片是如何设计出来的 点击上方“ 大鱼机器人 ”,选择“ 置顶/星标公众号 ” 福利干货,第一时间送达! 看看芯片到底是如何设计的拿好小本本,芯片的设计之旅开始喽 -END- | 整理文章为传播相关技术,版权归原作者所有 | |如有侵权,请联系删除 |

  4. 原创丨如何大幅提高 Django 网站加载速度

    原创丨如何大幅提高 Django 网站加载速度 “ 阅读本文大概需要 1 分钟。 ” 之前做了个爬虫案例平台,https://scrape.center/,具体文章在原创丨发布一个爬虫案例平台,帮助爬虫初学者进行练手。 平台内我设计了非常多的网站,有服务端渲染、客户端渲染等,其

  5. ubuntu下,eclipse如何打开当前文件所在文件夹的方法

    ubuntu下,eclipse如何打开当前文件所在文件夹的方法 为什么80%的码农都做不了架构师? Eclipse里打开相关资源文件所在的文件夹,是经常的事。MyEclipse带了这个功能。可是我不用Myeclipse多年,eclipse官方的j2ee版本已经非常好了,懒得去破解。那怎么办呢?

  6. 如何通过电影截图找到电影

    如何通过电影截图找到电影 苏生不惑第182 篇原创文章,将本公众号设为 星标 ,第一时间看最新文章。 这是公众号的第一篇付费文章(其实很早就开通了付费功能,一直没用),收费1块,保证让你看完觉得值。 之前分享过如何找电影资源 2020 最全百度网盘搜索,

  7. 如何优雅地操作张量维度:einops README

    如何优雅地操作张量维度:einops README einops 通过灵活而强大的张量操作符为你提供易读并可靠的代码。 支持 numpy、pytorch、tensorflow 以及其他框架 In case you need convincing arguments for setting aside time to learn about einsum and einops… T

  8. 算法图解:如何判断括号是否有效?

    算法图解:如何判断括号是否有效? 作者 | 王磊 来源 | Java中文社群(ID:javacn666) 转载请联系授权(微信ID:GG_Stone) 今天要讲的这道题是 bilibili 今年的笔试真题,也是一道关于栈的经典面试题。 经过前面文章的学习,我想很多朋友已经看出来了, 我