即使在经验丰富的从业者中，我也看到最常见的实践错误之一是未能在分析过程中的适当时间使用适当的数据集。特别是，大多数人倾向于从太大和太复杂的数据集开始。

我们现在可以创建我们之前描述的语言模型模块：

class LMModel1(Module):
    def __init__(self, vocab_sz, n_hidden):
        self.i_h = nn.Embedding(vocab_sz, n_hidden)
        self.h_h = nn.Linear(n_hidden, n_hidden)
        self.h_o = nn.Linear(n_hidden,vocab_sz)

    def forward(self, x):
        h = F.relu(self.h_h(self.i_h(x[:,0])))
        h = h + self.i_h(x[:,1])
        h = F.relu(self.h_h(h))
        h = h + self.i_h(x[:,2])
        h = F.relu(self.h_h(h))
        return self.h_o(h)

如您所见，我们创建了三层：

• 嵌入层（i_h，用于隐藏的输入）

• 为下一个词创建激活的线性层（h_h，隐藏到隐藏）

• 预测第四个词的最终线性层（h_o，隐藏到输出）

这可能更容易以图形形式表示，所以让我们定义基本神经网络的简单图形表示。 图 12-1显示了我们将如何表示具有一个隐藏层的神经网络。

每个形状代表激活：矩形用于输入，圆形用于隐藏（内）层激活，三角形用于输出激活。我们将在本章的所有图表中使用这些形状（在图 12-2中进行了总结）。

图 12-2。我们的图示中使用的形状

箭头表示实际的层计算——即线性层后跟激活函数。使用这种表示法， 图 12-3显示了我们的简单语言模型的样子。

为了简化事情，我们从每个箭头中删除了层计算的细节。我们还对箭头进行了颜色编码，这样所有具有相同颜色的箭头都具有相同的权重矩阵。例如，所有输入层都使用相同的嵌入矩阵，因此它们都具有相同的颜色（绿色）。

让我们尝试训练这个模型，看看效果如何：

learn = Learner(dls, LMModel1(len(vocab), 64), loss_func=F.cross_entropy,
                metrics=accuracy)
learn.fit_one_cycle(4, 1e-3)

要查看这是否有任何好处，让我们检查一个非常简单的模型会给我们带来什么。在这种情况下，我们总是可以预测最 通用标记，所以让我们找出哪个标记最常成为我们验证集中的目标：

n,counts = 0,torch.zeros(len(vocab))
for x,y in dls.valid:
    n += y.shape[0]
    for i in range_of(vocab): counts[i] += (y==i).long().sum()
idx = torch.argmax(counts)
idx, vocab[idx.item()], counts[idx].item()/n

(tensor(29), 'thousand', 0.15165200855716662)

最常见的令牌具有索引 29，对应于令牌 thousand。始终预测这个标记会给我们大约 15% 的准确度，所以我们的表现要好得多！

这是一个很好的第一个基线。让我们看看如何用循环重构它。

我们的第一个循环神经网络

查看我们模块的代码，我们可以通过用for循环替换调用层的重复代码来简化它。除了使我们的代码更简单之外，这还有一个好处，我们将能够 将我们的模块同样适用于不同长度的标记序列——我们不会局限于长度为三的标记列表：

class LMModel2(Module):
    def __init__(self, vocab_sz, n_hidden):
        self.i_h = nn.Embedding(vocab_sz, n_hidden)
        self.h_h = nn.Linear(n_hidden, n_hidden)
        self.h_o = nn.Linear(n_hidden,vocab_sz)

    def forward(self, x):
        h = 0
        for i in range(3):
            h = h + self.i_h(x[:,i])
            h = F.relu(self.h_h(h))
        return self.h_o(h)

让我们检查使用此重构是否得到相同的结果：

learn = Learner(dls, LMModel2(len(vocab), 64), loss_func=F.cross_entropy,
                metrics=accuracy)
learn.fit_one_cycle(4, 1e-3)

我们也可以用完全相同的方式重构我们的图形表示，如图 12-4所示（我们在这里也删除了激活大小的细节，并使用与 图 12-3中相同的箭头颜色）。

你会看到每次循环都会更新一组激活，存储在变量中h——这是 称为隐藏状态。

使用这样的循环定义的神经网络称为 递归神经网络(RNN)。重要的是要 意识到 RNN 不是一个复杂的新架构，而只是使用for循环对多层神经网络的重构。

维护 RNN 的状态

因为我们为每个新样本将模型的隐藏状态初始化为零，所以我们丢弃了所有关于 到目前为止我们看到的句子，这意味着我们的模型实际上并不知道我们在整个计数序列中的位置。这很容易修复；我们可以简单地将隐藏状态的初始化移动到__init__。

但是这个修复会产生它自己的微妙但重要的问题。它有效地使我们的神经网络与文档中的标记总数一样深。例如，如果我们的数据集中有 10,000 个标记，我们将创建一个 10,000 层的神经网络。

要了解为什么会这样，请考虑图 12-3for中循环神经网络的原始图形表示，然后再使用循环对其进行重构。您可以看到每一层对应一个令牌输入。当我们在用循环重构之前谈论循环神经网络的表示时for，我们称之为展开表示。在尝试理解 RNN 时考虑展开表示通常很有帮助。

10,000 层神经网络的问题在于，如果当你到达数据集的第 10,000 个单词时，你仍然需要计算导数一直回到第一层。这确实会很慢，而且会占用大量内存。您不太可能能够在 GPU 上存储一个小批量。

这个问题的解决方案是告诉 PyTorch 我们不想通过整个隐式神经网络反向传播导数。相反，我们将只保留最后三层渐变。要删除 PyTorch 中的所有梯度历史记录，我们使用该detach方法。

这是我们 RNN 的新版本。它现在是有状态的，因为它会记住它在对 的不同调用之间的激活forward，这代表它对批处理中不同样本的使用：

class LMModel3(Module):
    def __init__(self, vocab_sz, n_hidden):
        self.i_h = nn.Embedding(vocab_sz, n_hidden)
        self.h_h = nn.Linear(n_hidden, n_hidden)
        self.h_o = nn.Linear(n_hidden,vocab_sz)
        self.h = 0

    def forward(self, x):
        for i in range(3):
            self.h = self.h + self.i_h(x[:,i])
            self.h = F.relu(self.h_h(self.h))
        out = self.h_o(self.h)
        self.h = self.h.detach()
        return out

    def reset(self): self.h = 0

无论我们选择什么序列长度，这个模型都会有相同的激活，因为隐藏状态会记住上一批次的最后一次激活。唯一不同的是在每一步计算的梯度：它们将只根据过去的序列长度标记计算，而不是整个流。这种方法称为时间反向传播(BPTT)。

时间反向传播

将每个时间步有效一层的神经网络（通常使用循环重构）视为一个大模型，并以通常的方式计算其梯度。 每隔几个时间步声明一次。

要使用LMModel3，我们需要确保样本将按特定顺序显示。正如我们在第 10 章中看到的，如果第一批的第一行是我们的dset[0]，那么第二批的第一行应该是我们的dset[1]，以便模型看到文本流动。

LMDataLoader在第 10 章中为我们做了这个。这次我们要 自己动手。

为此，我们将重新排列我们的数据集。首先，我们将样本分成 m = len(dset) // bs几组（这相当于将整个连接的数据集分成，例如，64 个大小相同的部分，因为我们在bs=64这里使用）。m是每个片段的长度。例如，如果我们正在使用我们的整个数据集（虽然我们实际上会将其分成训练集和有效集），我们有这个：

m = len(seqs)//bs
m,bs,len(seqs)

(328, 64, 21031)

第一批将由样品组成

(0, m, 2*m, ..., (bs-1)*m)

第二批样品

(1, m+1, 2*m+1, ..., (bs-1)*m+1)

等等。这样，在每个时期，模型将3*m在批处理的每一行上看到一大块大小为 3 的连续文本（因为每个文本的大小为 3）。

以下函数执行重新索引：

def group_chunks(ds, bs):
    m = len(ds) // bs
    new_ds = L()
    for i in range(m): new_ds += L(ds[i + m*j] for j in range(bs))
    return new_ds

然后我们drop_last=True在构建我们的时候就通过DataLoaders删除最后一批没有形状的bs。我们还传递 shuffle=False以确保按顺序阅读文本：

cut = int(len(seqs) * 0.8)
dls = DataLoaders.from_dsets(
    group_chunks(seqs[:cut], bs),
    group_chunks(seqs[cut:], bs),
    bs=bs, drop_last=True, shuffle=False)

我们添加的最后一件事是通过 Callback. 我们将更多地讨论回调 第16章；这个将reset在每个纪元开始和每个验证阶段之前调用我们模型的方法。由于我们实现了该方法以将模型的隐藏状态设置为零，这将确保我们在读取那些连续的文本块之前从一个干净的状态开始。我们还可以开始更长时间的训练：

learn = Learner(dls, LMModel3(len(vocab), 64), loss_func=F.cross_entropy,
                metrics=accuracy, cbs=ModelResetter)
learn.fit_one_cycle(10, 3e-3)

我们当前方法的另一个问题是，对于每三个输入词，我们只预测一个输出词。结果，数量 我们正在反馈以更新权重的信号并不像它应该的那么大。如果我们在每个单词之后而不是每三个单词之后预测下一个单词会更好， 如图 12-5所示。

图 12-5。RNN 在每个标记后进行预测

 这很容易添加。我们需要首先更改我们的数据，以便因变量在我们的三个输入词中的每一个之后都有接下来的三个词中的每一个。取而代之的是3，我们使用一个属性sl（用于序列长度），并使其更大一些：

sl = 16
seqs = L((tensor(nums[i:i+sl]), tensor(nums[i+1:i+sl+1]))
         for i in range(0,len(nums)-sl-1,sl))
cut = int(len(seqs) * 0.8)
dls = DataLoaders.from_dsets(group_chunks(seqs[:cut], bs),
                             group_chunks(seqs[cut:], bs),
                             bs=bs, drop_last=True, shuffle=False)

查看 的第一个元素seqs，我们可以看到它包含两个相同大小的列表。第二个列表与第一个列表相同，但偏移了一个元素：

[L(vocab[o] for o in s) for s in seqs[0]]

[(#16) ['one','.','two','.','three','.','four','.','five','.'...],
 (#16) ['.','two','.','three','.','four','.','five','.','six'...]]

现在我们需要修改我们的模型，让它在每个单词之后输出一个预测，而不是仅仅在三个单词序列的末尾：

class LMModel4(Module):
    def __init__(self, vocab_sz, n_hidden):
        self.i_h = nn.Embedding(vocab_sz, n_hidden)
        self.h_h = nn.Linear(n_hidden, n_hidden)
        self.h_o = nn.Linear(n_hidden,vocab_sz)
        self.h = 0

    def forward(self, x):
        outs = []
        for i in range(sl):
            self.h = self.h + self.i_h(x[:,i])
            self.h = F.relu(self.h_h(self.h))
            outs.append(self.h_o(self.h))
        self.h = self.h.detach()
        return torch.stack(outs, dim=1)

    def reset(self): self.h = 0

该模型将返回形状的输出bs x sl x vocab_sz（因为我们堆叠在 上dim=1）。我们的目标是形状的bs x sl，所以我们需要在使用它们之前将它们展平F.cross_entropy：

def loss_func(inp, targ):
    return F.cross_entropy(inp.view(-1, len(vocab)), targ.view(-1))

我们现在可以使用这个损失函数来训练模型：

learn = Learner(dls, LMModel4(len(vocab), 64), loss_func=loss_func,
                metrics=accuracy, cbs=ModelResetter)
learn.fit_one_cycle(15, 3e-3)

epoch	train_loss	vaild_loss	accuracy	time
0	3.103298	2.874341	0.212565	00:01
1	2.231964	1.971280	0.462158	00:01
2	1.711358	1.813547	0.461182	00:01
3	1.448516	1.828176	0.483236	00:01
4	1.288630	1.659564	0.520671	00:01
5	1.161470	1.714023	0.554932	00:01
6	1.055568	1.660916	0.575033	00:01
7	0.960765	1.719624	0.591064	00:01
8	0.870153	1.839560	0.614665	00:01
9	0.808545	1.770278	0.624349	00:01
10	0.758084	1.842931	0.610758	00:01
11	0.719320	1.799527	0.646566	00:01
12	0.683439	1.917928	0.649821	00:01
13	0.660283	1.874712	0.628581	00:01
14	0.646154	1.877519	0.640055	00:01

我们需要训练更长时间，因为现在任务发生了一些变化并且更加复杂。但我们最终得到了一个好结果……至少，有时是这样。如果你运行它几次，你会发现在不同的运行中你会得到完全不同的结果。那是因为实际上我们这里有一个非常深的网络，这会导致非常大或非常小的梯度。我们将在本章的下一部分看到如何处理这个问题。

现在，获得更好模型的明显方法是更深入：我们在基本 RNN 中的隐藏状态和输出激活之间只有一个线性层，所以也许我们会得到更好的结果。

对于 RNN，经常使用两种类型的层来避免激活爆炸：门控循环单元(GRU) 和 长短期记忆(LSTM) 层。这两个都在 PyTorch 中可用，并且是 RNN 层的直接替代品。我们将在本书中仅介绍 LSTM；许多优秀的在线教程解释了 GRU，它是 LSTM 设计的一个小变体。

从头开始构建 LSTM

为了构建 LSTM，我们首先必须了解其架构。 其内部结构如图 12-9所示。

图 12-9。LSTM 的架构

 在这张图片中，我们的输入Xt与先前的隐藏状态一起进入左侧（Ht-1) 和细胞状态 (Ct-1). 四个橙色框代表四个层（我们的神经网络），激活是 sigmoid（p) 或 tanh。tanh 只是一个重新缩放到 –1 到 1 范围内的 sigmoid 函数。它的数学表达式可以这样写：

在哪里p是 sigmoid 函数。图中的绿色圆圈是elementwise操作。右边出来的是新的隐藏状态（Ht) 和新的细胞状态 (Ct), 准备好我们的下一个输入。新的隐藏状态也用作输出，这就是箭头向上分裂的原因。

让我们一个一个地检查四个神经网络（称为门）并解释图表——但在此之前，请注意细胞状态（顶部）的变化非常小。它甚至不直接通过神经网络！这正是它会保持更长期状态的原因。

首先，输入和旧隐藏状态的箭头连接在一起。在本章前面写的 RNN 中，我们将它们加在一起。在 LSTM 中，我们将它们堆叠在一个大张量中。这意味着我们嵌入的维度（这是维度X吨) 可以不同于我们隐藏状态的维度。如果我们称它们 为n_inand n_hid，底部的箭头大小为n_in + n_hid；因此所有的神经网络（橙色框）都是具有 n_in + n_hid输入和n_hid 输出的线性层。

第一个门（从左往右看）叫做遗忘门。由于它是一个线性层，后面跟着一个 sigmoid，它的输出将由 0 到 1 之间的标量组成。我们将这个结果乘以细胞状态来确定保留哪些信息和丢弃哪些信息：接近 0 的值被丢弃，并且值接近 1 被保留。这使 LSTM 能够忘记其长期状态。例如，当跨越一个句点或一个xxbos标记时，我们会期望它（已经学会）重置它的细胞状态。

第二个门称为输入门。它与第三个门（实际上没有名称，但有时称为单元门）一起工作以更新单元状态。例如，我们可能会看到一个新的性别代词，在这种情况下，我们需要替换遗忘门删除的有关性别的信息。与遗忘门类似，输入门决定要更新单元状态的哪些元素（值接近 1）或不更新（值接近 0）。第三个门确定那些更新的值是什么，在 –1 到 1 的范围内（多亏了 tanh 函数）。结果被添加到细胞状态。

最后一个门是输出门。它确定使用来自细胞状态的哪些信息来生成输出。单元状态在与输出门的 sigmoid 输出组合之前经过 tanh，结果是新的隐藏状态。在代码方面，我们可以这样写相同的步骤：

class LSTMCell(Module):
    def __init__(self, ni, nh):
        self.forget_gate = nn.Linear(ni + nh, nh)
        self.input_gate  = nn.Linear(ni + nh, nh)
        self.cell_gate   = nn.Linear(ni + nh, nh)
        self.output_gate = nn.Linear(ni + nh, nh)

    def forward(self, input, state):
        h,c = state
        h = torch.cat([h, input], dim=1)
        forget = torch.sigmoid(self.forget_gate(h))
        c = c * forget
        inp = torch.sigmoid(self.input_gate(h))
        cell = torch.tanh(self.cell_gate(h))
        c = c + inp * cell
        out = torch.sigmoid(self.output_gate(h))
        h = out * torch.tanh(c)
        return h, (h,c)

在实践中，我们可以重构代码。此外，就性能而言，进行一次大矩阵乘法比进行四次较小的矩阵乘法更好（这是因为我们只在 GPU 上启动了一次特殊的快速内核，它让 GPU 可以并行执行更多工作）。堆叠需要一点时间（因为我们必须在 GPU 上移动其中一个张量以将其全部放在一个连续的数组中），因此我们为输入和隐藏状态使用两个单独的层。优化和重构后的代码如下所示：

class LSTMCell(Module):
    def __init__(self, ni, nh):
        self.ih = nn.Linear(ni,4*nh)
        self.hh = nn.Linear(nh,4*nh)

    def forward(self, input, state):
        h,c = state
        # One big multiplication for all the gates is better than 4 smaller ones
        gates = (self.ih(input) + self.hh(h)).chunk(4, 1)
        ingate,forgetgate,outgate = map(torch.sigmoid, gates[:3])
        cellgate = gates[3].tanh()

        c = (forgetgate*c) + (ingate*cellgate)
        h = outgate * c.tanh()
        return h, (h,c)

在这里，我们使用 PyTorchchunk方法将我们的张量分成四个部分。它是这样工作的：

t = torch.arange(0,10); t

tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

t.chunk(2)

(tensor([0, 1, 2, 3, 4]), tensor([5, 6, 7, 8, 9]))

现在让我们使用这个架构来训练语言模型！

使用 LSTM 训练语言模型

这是与 相同的网络LMModel5，使用两层 LSTM。我们可以以更高的学习率、更短的时间训练它，并获得更好的准确性：

class LMModel6(Module):
    def __init__(self, vocab_sz, n_hidden, n_layers):
        self.i_h = nn.Embedding(vocab_sz, n_hidden)
        self.rnn = nn.LSTM(n_hidden, n_hidden, n_layers, batch_first=True)
        self.h_o = nn.Linear(n_hidden, vocab_sz)
        self.h = [torch.zeros(n_layers, bs, n_hidden) for _ in range(2)]

    def forward(self, x):
        res,h = self.rnn(self.i_h(x), self.h)
        self.h = [h_.detach() for h_ in h]
        return self.h_o(res)

    def reset(self):
        for h in self.h: h.zero_()

learn = Learner(dls, LMModel6(len(vocab), 64, 2),
                loss_func=CrossEntropyLossFlat(),
                metrics=accuracy, cbs=ModelResetter)
learn.fit_one_cycle(15, 1e-2)

现在这比多层 RNN 更好！然而，我们仍然可以看到有一点过度拟合，这表明一些正则化可能会有所帮助。

Dropout是一种正则化技术，由 Geoffrey Hinton 等人引入。在“通过防止特征检测器的共同适应来改善神经网络”中。基础的 想法是在训练时随机将一些激活更改为零。这确保所有神经元都积极地为输出工作， 如图 12-10 所示（来自Nitish Srivastava 等人的“Dropout：一种防止神经网络过度拟合的简单方法”）。

图 12-10。在神经网络中应用 dropout（由 Nitish Srivastava 等人提供）

Hinton 在一次采访中解释 dropout 的灵感时使用了一个很好的比喻：

我去了我的银行。出纳员一直在换，我问其中一个为什么。他说他不知道，但他们经常搬家。我想这一定是因为它需要员工之间的合作才能成功骗取银行。这让我意识到，在每个示例中随机移除不同的神经元子集可以防止阴谋论，从而减少过度拟合。

在同一次采访中，他还解释说神经科学提供了额外的 灵感：

我们真的不知道为什么神经元会发出尖峰信号。一种理论是他们想要噪音以便进行正则化，因为我们拥有的参数比我们拥有的数据点多得多。dropout 的想法是，如果你有嘈杂的激活，你可以负担得起使用更大的模型。

这解释了为什么 dropout 有助于泛化背后的想法：首先它帮助神经元更好地合作；然后它使激活更加嘈杂，从而使模型更加健壮。

然而，我们可以看到，如果我们只是将这些激活归零而不做任何其他事情，我们的模型在训练时就会出现问题：如果我们从五个激活的总和（因为我们应用了 ReLU，它们都是正数）到第二，这不会有相同的规模。因此，如果我们以概率 应用 dropout p，我们通过将它们除以1-p（平均p将归零，所以它离开 1-p）来重新缩放所有激活，如图 12-11所示。

图 12-11。为什么我们在应用 dropout 时缩放激活（由 Nitish Srivastava 等人提供）

这是 PyTorch 中 dropout 层的完整实现（尽管 PyTorch 的原生层实际上是用 C 而不是 Python 编写的）：

class Dropout(Module):
    def __init__(self, p): self.p = p
    def forward(self, x):
        if not self.training: return x
        mask = x.new(*x.shape).bernoulli_(1-p)
        return x * mask.div_(1-p)

该bernoulli_方法创建一个由随机零（概率为 ）和随机零（概率为p）组成的张量，1-p然后在除以 之前将其与我们的输入相乘1-p。请注意training 属性的使用，它在任何 PyTorch 中都可用nn.Module，并告诉我们是在进行训练还是推理。

我们会在bernoulli_这里添加一个代码示例，这样您就可以确切地看到它是如何工作的。但既然您已经足够了解自己做这件事，我们将为您做的例子会越来越少，而是希望您自己做实验来了解事情是如何运作的。在这种情况下，您会在本章末尾的调查问卷中看到我们要求您进行实验bernoulli_——但不要等到我们要求您通过实验来加深对我们正在研究的代码的理解；继续做吧！

在将 LSTM 的输出传递到最后一层之前使用 dropout 将有助于减少过度拟合。Dropout 也用于许多其他模型，包括 中使用的默认 CNN 头fastai.vision，并且可以fastai.tabular通过传递ps参数（其中每个“p”传递给每个添加的Dropout层）来使用，正如我们将在第 15 章中看到的那样。

trainingDropout在训练和验证模式下有不同的行为，我们使用Dropout. train在 a上调​​用方法Module设置training为True（对于您调用该方法的模块和它递归包含的每个模块），并将eval其设置为False. 这是在调用 的方法时自动完成的Learner，但如果您没有使用该类，请记住根据需要从一个类切换到另一个类。

激活正则化(AR) 和时间激活正则化(TAR) 是两种与权重衰减非常相似的正则化方法，将在第 8 章中讨论。当应用权重衰减时，我们对损失添加一个小的惩罚 旨在使权重尽可能小。对于激活正则化，我们将尝试使 LSTM 产生的最终激活尽可能小，而不是权重。

loss += alpha * activations.pow(2).mean()

loss += beta * (activations[:,1:] - activations[:,:-1]).pow(2).mean()

我们可以将 dropout（在我们进入输出层之前应用）与 AR 和 TAR 结合起来训练我们之前的 LSTM。我们只需要 返回三样东西而不是一件：LSTM 的正常输出、丢弃的激活和 LSTM 的激活。最后两个将由回调拾取，因为 RNNRegularization它必须对损失做出贡献。

我们可以从AWD-LSTM 论文中添加的另一个有用技巧是权重绑定。在语言模型中，输入嵌入表示一个映射 从英语单词到激活，输出隐藏层表示从激活到英语单词的映射。我们可能会直觉地期望这些映射可能是相同的。我们可以通过为这些层中的每一层分配相同的权重矩阵来在 PyTorch 中表示这一点：

self.h_o.weight = self.i_h.weight

在LMModel7中，我们包括这些最终调整：

class LMModel7(Module):
    def __init__(self, vocab_sz, n_hidden, n_layers, p):
        self.i_h = nn.Embedding(vocab_sz, n_hidden)
        self.rnn = nn.LSTM(n_hidden, n_hidden, n_layers, batch_first=True)
        self.drop = nn.Dropout(p)
        self.h_o = nn.Linear(n_hidden, vocab_sz)
        self.h_o.weight = self.i_h.weight
        self.h = [torch.zeros(n_layers, bs, n_hidden) for _ in range(2)]

    def forward(self, x):
        raw,h = self.rnn(self.i_h(x), self.h)
        out = self.drop(raw)
        self.h = [h_.detach() for h_ in h]
        return self.h_o(out),raw,out

    def reset(self):
        for h in self.h: h.zero_()

Learner我们可以使用RNNRegularizer 回调创建正则化：

learn = Learner(dls, LMModel7(len(vocab), 64, 2, 0.5),
                loss_func=CrossEntropyLossFlat(), metrics=accuracy,
                cbs=[ModelResetter, RNNRegularizer(alpha=2, beta=1)])

ATextLearner自动为我们添加这两个回调（使用默认值alpha和beta默认值），因此我们可以简化前面的行：

learn = TextLearner(dls, LMModel7(len(vocab), 64, 2, 0.4),
                    loss_func=CrossEntropyLossFlat(), metrics=accuracy)

然后我们可以训练模型，并通过将权重衰减增加到 来添加额外的正则化0.1：

learn.fit_one_cycle(15, 1e-2, wd=0.1)

现在这比我们以前的模型要好得多！