返回 登录
6

LSTM的反向传播过程推导

阅读6844

【在线直播】《TensorFlow实战》作者、PPmoney大数据算法总监黄文坚老师即将开课:《使用TensorFlow创建可自动玩游戏的DQN模型》,本次课程集中讲解Deep-Q Network及其TensorFlow的实现。点击报名

近些年来,随着深度学习的崛起,RNN模型也变得非常热门。如果把RNN模型按照时间轴展开,它也类似其它的深度神经网络模型结构。因此,我们可以参照已有的方法训练RNN模型。

现在最流行的一种RNN模型是LSTM(长短期记忆)网络模型。这里有一些关于LSTM的背景知识介绍文章,Karpathy的博客Chris Olah的博客

尽管我们可以借助Tensorflow、Torch、Theano等深度学习库轻松地训练模型,而不再需要推导反向传播的过程,但是逐步推导LSTM模型的梯度并用反向传播算法来实现,对我们深刻地理解模型是大有裨益的。

因此,我们首先按照LSTM的公式实现正向传播计算过程,然后推导网络模型的梯度计算过程,最后用numpy来实现模型的求解。

LSTM正向传播

单个LSTM单元的公式如下:

用代码可以表示为:

H = 128 # LSTM 层神经元的数量
D = ... # 输入数据的维度 == 词表的大小
Z = H + D # 因为需要把LSTM的状态与输入数据拼接

model = dict(
    Wf=np.random.randn(Z, H) / np.sqrt(Z / 2.),
    Wi=np.random.randn(Z, H) / np.sqrt(Z / 2.),
    Wc=np.random.randn(Z, H) / np.sqrt(Z / 2.),
    Wo=np.random.randn(Z, H) / np.sqrt(Z / 2.),
    Wy=np.random.randn(H, D) / np.sqrt(D / 2.),
    bf=np.zeros((1, H)),
    bi=np.zeros((1, H)),
    bc=np.zeros((1, H)),
    bo=np.zeros((1, H)),
    by=np.zeros((1, D))
)

在上面,我们定义了LSTM单元的结构。上述公式需要注意的一点是,我们把隐藏层上一步的状态h与当前的输入x相连接,因此LSTM单元的输入是 Z = H + D。另外,我们LSTM单元的输出层有H个神经元,因此每个权重矩阵的维度是 ZxH,偏置向量的维度是 1xH。

Wy 和 by略有不同,这两项是全连接层的参数,它们的下一级是softmax层。最终的输出结果将是词表中每个词语出现的概率分布,维度为 1xD。因此,Wy的维度必须是 HxD,by的维度必须是 1xD。

def lstm_forward(X, state):
    m = model
    Wf, Wi, Wc, Wo, Wy = m['Wf'], m['Wi'], m['Wc'], m['Wo'], m['Wy']
    bf, bi, bc, bo, by = m['bf'], m['bi'], m['bc'], m['bo'], m['by']

    h_old, c_old = state

    # One-hot 编码
    X_one_hot = np.zeros(D)
    X_one_hot[X] = 1.
    X_one_hot = X_one_hot.reshape(1, -1)

    # 上一步状态与当前输入值连接
    X = np.column_stack((h_old, X_one_hot))

    hf = sigmoid(X @ Wf + bf)
    hi = sigmoid(X @ Wi + bi)
    ho = sigmoid(X @ Wo + bo)
    hc = tanh(X @ Wc + bc)

    c = hf * c_old + hi * hc
    h = ho * tanh(c)

    y = h @ Wy + by
    prob = softmax(y)

    cache = ... # 存储所有的中间变量结果

    return prob, cache

上面的代码表示了单个LSTM单元的前向传播过程,与公式表示的基本一致,多了one-hot编码的步骤。

LSTM反向传播

接下来,我们进入到本篇文章的要点:LSTM反向传播计算。我们假设可以调用函数计算sigmoid和tanh函数的导数。

def lstm_backward(prob, y_train, d_next, cache):
    # 取出前向传播步骤中存储的中间状态变量
    ... = cache
    dh_next, dc_next = d_next

    # Softmax loss gradient
    dy = prob.copy()
    dy[1, y_train] -= 1.

    # 隐藏层到输出层的导数
    dWy = h.T @ dy
    dby = dy
    # 注意加上dh_next这一项
    dh = dy @ Wy.T + dh_next

    # h = ho * tanh(c),计算ho的偏导数
    dho = tanh(c) * dh
    dho = dsigmoid(ho) * dho

    # h = ho * tanh(c), 计算c的偏导数
    dc = ho * dh * dtanh(c)
    dc = dc + dc_next

    # c = hf * c_old + hi * hc,计算hf的偏导数
    dhf = c_old * dc
    dhf = dsigmoid(hf) * dhf

    # c = hf * c_old + hi * hc,计算hi的偏导数
    dhi = hc * dc
    dhi = dsigmoid(hi) * dhi

    # c = hf * c_old + hi * hc,计算hc的偏导数
    dhc = hi * dc
    dhc = dtanh(hc) * dhc

    # 各个门的偏导数
    dWf = X.T @ dhf
    dbf = dhf
    dXf = dhf @ Wf.T

    dWi = X.T @ dhi
    dbi = dhi
    dXi = dhi @ Wi.T

    dWo = X.T @ dho
    dbo = dho
    dXo = dho @ Wo.T

    dWc = X.T @ dhc
    dbc = dhc
    dXc = dhc @ Wc.T

    # 由于X参与多个门的计算,因此偏导数需要累加
    dX = dXo + dXc + dXi + dXf
    # 计算h_old的偏导数
    dh_next = dX[:, :H]
    # c = hf * c_old + hi * hc,计算dc_next的偏导数
    dc_next = hf * dc

    grad = dict(Wf=dWf, Wi=dWi, Wc=dWc, Wo=dWo, Wy=dWy, bf=dbf, bi=dbi, bc=dbc, bo=dbo, by=dby)
    state = (dh_next, dc_next)

    return grad, state

代码似乎有点长。但只要你掌握了计算函数偏导数的方法,外加一些小技巧,就能很容易地推导LSTM的导数计算。关于这些知识,我强烈推荐学习CS231n课程

在推导的过程中,不太容易理解地方的有如下几点:

  1. 计算dh时需要加上dh_next,因为在前向过程中,h不仅出现在y = h @ Wy + by,还与下一步计算有关。因此,这里不要忘记加上它。
  2. 计算dc时加上dc_next,理由同上。
  3. 计算dX时,需要累加dXo + dXc + dXi + dXf,理由与上面类似,因为X在多个计算步骤中都有用到。
  4. 因为X = [h_old, x],所以从dx可以得到dh_next。

既然正向和反向传播计算都已经实现,我们就可以合并两者来训练模型。

LSTM训练步骤

训练的过程分为三步:正向计算,计算损失值,反向计算。

python
def train_step(X_train, y_train, state):
    probs = []
    caches = []
    loss = 0.
    h, c = state

    # 正向计算

    for x, y_true in zip(X_train, y_train):
        prob, state, cache = lstm_forward(x, state, train=True)
        loss += cross_entropy(prob, y_true)

        # 保存正向计算的结果
        probs.append(prob)
        caches.append(cache)

    # 损失值采用交叉熵
    loss /= X_train.shape[0]

    # 反向过程

    # 在最后一步, dh_next 和 dc_next 的值等于0。
    d_next = (np.zeros_like(h), np.zeros_like(c))
    grads = {k: np.zeros_like(v) for k, v in model.items()}

    # 按照从后到前的时间顺序
    for prob, y_true, cache in reversed(list(zip(probs, y_train, caches))):
        grad, d_next = lstm_backward(prob, y_true, d_next, cache)

        # 累加各个步骤的梯度值
        for k in grads.keys():
            grads[k] += grad[k]

    return grads, loss, state

在一个完整的训练步骤中,我们首先进行前向计算,保存softmax层的概率分布结果以及每一步的中间结果,因为在反向过程中还会用到。

接着,我们在每一步都能计算交叉熵损失值(因为采用softmax方法)。然后,累加每一步的损失值,并求平均值。

最后,基于前向传播的结果进行反向传播运算,需要注意的是数据遍历的方向与之前相反。

另外,在反向传播的第一步,dh_next和dc_next的值等于0.为什么呢?这是因为在正向计算的最后一步,h和c不会参与下一步的计算,因为不存在下一步!因此,在最后一步h和c的偏导数可以直接推导,不需要考虑dh_next和dc_next。

一旦实现了这个函数,我们稍加修改就可以把它嵌入到任何优化算法中,比如RMSProp、Adam等等。

一切搞定!我们可以尝试训练一个LSTM模型。

测试结果

使用Adam优化算法,我从维基百科上复制了一段关于日本的文字。每一个字符表示一个数据。训练目标是预测文章的下一个字符。每隔100轮迭代,我们会检查一下模型的效果。下面是截取到的训练结果:

=========================================================================
Iter-100 loss: 4.2125
=========================================================================
best c ehpnpgteHihcpf,M tt" ao tpo Teoe ep S4 Tt5.8"i neai   neyoserpiila o  rha aapkhMpl rlp pclf5i
=========================================================================

...

=========================================================================
Iter-52800 loss: 0.1233
=========================================================================
tary shoguns who ruled in the name of the Uprea wal motrko, the copulation of Japan is a sour the wa
=========================================================================

模型果然学到了一些知识!

小结

在本文中,我们介绍了LSTM的通用公式,并基于此实现了前向计算过程。然后,我们推导了反向计算的过程,尽管加入了一些小技巧,但是整个过程还是非常直截了当。接着,我们将两者结合构建了完整的训练步骤,并用真实的数据训练和测试模型。

参考链接

原文: Deriving LSTM Gradient for Backpropagation
作者: Agustinus Kristiadi
译者: KK4SBB
责编:何永灿,欢迎人工智能领域技术投稿、约稿、给文章纠错,请发送邮件至heyc@csdn.net



评论