Chainer项目教程：深入理解循环神经网络及其计算图

郝赢泉

于 2025-06-07 09:05:59 发布

阅读量330

点赞数 3

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/gitblog_00355/article/details/148488553

Chainer项目教程：深入理解循环神经网络及其计算图

chainer A flexible framework of neural networks for deep learning 项目地址: https://gitcode.com/gh_mirrors/ch/chainer

循环神经网络基础概念

循环神经网络(RNN)是带有循环结构的神经网络，特别适合处理序列输入/输出数据。在Chainer框架中，我们可以方便地实现各种RNN结构。

RNN工作原理

给定输入序列x₁, x₂, ..., xₜ和初始状态h₀，RNN通过hₜ = f(xₜ, hₜ₋₁)迭代更新其状态，并在某些或每个时间点t输出yₜ = g(hₜ)。如果沿时间轴展开这个过程，它看起来就像一个常规的前馈网络，只是网络内部重复使用相同的参数。

实现简单的RNN语言模型

我们将实现一个单层RNN语言模型，任务是根据给定的有限单词序列预测每个位置的下一个单词。

使用LSTM层

Chainer提供了L.LSTM链接，实现了全连接的有状态LSTM层。使用方式如下：

l = L.LSTM(100, 50)  # 输入维度100，输出维度50
l.reset_state()  # 重置内部状态
x = Variable(np.random.randn(10, 100).astype(np.float32))
y = l(x)  # 执行一步LSTM计算

构建完整RNN模型

基于LSTM链接，我们可以构建完整的RNN网络：

class RNN(Chain):
    def __init__(self):
        super(RNN, self).__init__()
        with self.init_scope():
            self.embed = L.EmbedID(1000, 100)  # 词嵌入层
            self.mid = L.LSTM(100, 50)  # LSTM层
            self.out = L.Linear(50, 1000)  # 输出层

    def reset_state(self):
        self.mid.reset_state()

    def forward(self, cur_word):
        x = self.embed(cur_word)
        h = self.mid(x)
        y = self.out(h)
        return y

处理序列数据

虽然RNN链实现了单步前向计算，但我们可以通过循环处理整个序列：

def compute_loss(x_list):
    loss = 0
    for cur_word, next_word in zip(x_list, x_list[1:]):
        loss += model(cur_word, next_word)
    return loss

计算梯度并更新参数：

rnn.reset_state()
model.cleargrads()
loss = compute_loss(x_list)
loss.backward()
optimizer.update()

截断反向传播(Truncated Backprop)

处理长序列时，内存可能不足。这时可以使用截断反向传播技术，通过unchain_backward()方法实现：

loss = 0
count = 0
seqlen = len(x_list[1:])

rnn.reset_state()
for cur_word, next_word in zip(x_list, x_list[1:]):
    loss += model(cur_word, next_word)
    count += 1
    if count % 30 == 0 or count == seqlen:
        model.cleargrads()
        loss.backward()
        loss.unchain_backward()  # 关键步骤：截断计算图
        optimizer.update()

无反向传播模式评估

评估时通常不需要存储计算历史，可以使用no_backprop_mode：

with chainer.no_backprop_mode():
    x_list = [Variable(...) for _ in range(100)]
    loss = compute_loss(x_list)

这种模式也适用于减少前馈网络的内存占用。

使用Trainer进行训练

对于实际训练，推荐使用Trainer。需要自定义迭代器和更新函数：

自定义迭代器

class ParallelSequentialIterator(chainer.dataset.Iterator):
    def __init__(self, dataset, batch_size, repeat=True):
        self.dataset = dataset
        self.batch_size = batch_size
        self.offsets = [i * len(dataset) // batch_size for i in range(batch_size)]
        # 其他初始化代码...

BPTT更新器

class BPTTUpdater(training.updaters.StandardUpdater):
    def __init__(self, train_iter, optimizer, bprop_len):
        super(BPTTUpdater, self).__init__(train_iter, optimizer)
        self.bprop_len = bprop_len

    def update_core(self):
        loss = 0
        for i in range(self.bprop_len):
            batch = train_iter.__next__()
            x, t = self.converter(batch)
            loss += optimizer.target(Variable(x), Variable(t))
        
        optimizer.target.cleargrads()
        loss.backward()
        loss.unchain_backward()  # 截断计算图
        optimizer.update()