[[(i,j) for j in range(1,5)] for i in range(1,5)]

[[(1, 1), (1, 2), (1, 3), (1, 4)],
 [(2, 1), (2, 2), (2, 3), (2, 4)],
 [(3, 1), (3, 2), (3, 3), (3, 4)],
 [(4, 1), (4, 2), (4, 3), (4, 4)]]

嵌套列表理解

嵌套列表推导在 Python 中被大量使用，所以如果您以前没有见过它们，请花几分钟时间确保您了解这里发生的事情，并尝试编写您自己的嵌套列表推导。

这是将我们的内核应用于坐标网格的结果：

rng = range(1,27)
top_edge3 = tensor([[apply_kernel(i,j,top_edge) for j in rng] for i in rng])

show_image(top_edge3);

看起来不错！我们的顶部边缘是黑色的，底部边缘是白色的（因为它们与顶部边缘相反）。现在我们的图像也包含负数，matplotlib已经自动改变了我们的颜色，白色是图像中最小的数字，黑色是最大的数字，零显示为灰色。

我们可以对左边缘尝试同样的事情：

left_edge = tensor([[-1,1,0],
                    [-1,1,0],
                    [-1,1,0]]).float()

left_edge3 = tensor([[apply_kernel(i,j,left_edge) for j in rng] for i in rng])

show_image(left_edge3);

图 13-3。将 3×3 内核应用于 4×4 图像的结果（由 Vincent Dumoulin 和 Francesco Visin 提供）

 查看结果的形状。如果原始图像的高度为 h，宽度为w，我们可以找到多少个 3×3 的窗口？从例子中可以看出，有h-2by w-2windows，所以我们得到的结果图片的高度为h-2，宽度为w-2。

input

形状的输入张量(minibatch, in_channels, iH, iW)

weight

形状过滤器(out_channels, in_channels, kH, kW)

这iH,iW是图像的高度和宽度（即28,28）， kH,kW是我们内核的高度和宽度（3,3）。但显然 PyTorch 期望这两个参数都是 4 阶张量，而目前我们只有 2 阶张量（即矩阵或具有两个轴的数组）。

这些额外轴的原因是 PyTorch 有一些小技巧。第一个技巧是 PyTorch 可以同时对多个图像应用卷积。这意味着我们可以一次对一批中的每个项目调用它！

第二个技巧是 PyTorch 可以同时应用多个内核。因此，让我们也创建对角边缘内核，然后将所有四个边缘内核堆叠到一个张量中：

diag1_edge = tensor([[ 0,-1, 1],
                     [-1, 1, 0],
                     [ 1, 0, 0]]).float()
diag2_edge = tensor([[ 1,-1, 0],
                     [ 0, 1,-1],
                     [ 0, 0, 1]]).float()

edge_kernels = torch.stack([left_edge, top_edge, diag1_edge, diag2_edge])
edge_kernels.shape

torch.Size([4, 3, 3])

为了测试这一点，我们需要DataLoader 一个样本小批量。让我们使用数据块 API：

mnist = DataBlock((ImageBlock(cls=PILImageBW), CategoryBlock),
                  get_items=get_image_files,
                  splitter=GrandparentSplitter(),
                  get_y=parent_label)

dls = mnist.dataloaders(path)
xb,yb = first(dls.valid)
xb.shape

torch.Size([64, 1, 28, 28])

默认情况下，fastai 在使用数据块时将数据放在 GPU 上。在我们的示例中，让我们将其移至 CPU：

xb,yb = to_cpu(xb),to_cpu(yb)

一批包含 64 张图像，每张图像 1 个通道，像素为 28×28。 F.conv2d也可以处理多通道（彩色）图像。通道是图像中的单一基本颜色——对于常规的全彩色图像，有红色、绿色和蓝色三个通道。PyTorch 将图像表示为 rank-3 张量，具有以下维度：

[channels, rows, columns]

我们将在本章后面看到如何处理多个通道。传递给F.conv2d需要为 4 阶张量的内核：

[ features_out , channels_in , rows , columns ]

edge_kernels目前缺少其中一个：我们需要告诉 PyTorch 内核中输入通道的数量是一个，我们可以通过在第一个位置插入一个大小为 1 的轴（这被称为单位轴）来做到这一点，其中PyTorch 文档显示in_channels是预期的。要将单位轴插入张量，我们使用以下unsqueeze 方法：

edge_kernels.shape,edge_kernels.unsqueeze(1).shape

(torch.Size([4, 3, 3]), torch.Size([4, 1, 3, 3]))

现在这是 的正确形状edge_kernels。让我们把这一切传递给conv2d：

edge_kernels = edge_kernels.unsqueeze(1)

batch_features = F.conv2d(xb, edge_kernels)
batch_features.shape

torch.Size([64, 4, 26, 26])

输出形状显示我们在小批量中有 64 张图像、4 个内核和 26×26 的边缘图（我们从 28×28 图像开始，但如前所述，每侧丢失一个像素）。我们可以看到我们得到了与手动执行此操作时相同的结果：

show_image(batch_features[0,0]);

 PyTorch 拥有的最重要的技巧是它可以使用 GPU 并行完成所有这些工作——跨多个通道将多个内核应用于多个图像。并行执行大量工作对于让 GPU 高效工作至关重要；如果我们一次执行这些操作中的每一个，我们的运行速度通常会慢数百倍（如果我们使用上一节中的手动卷积循环，我们会慢数百万倍！）。因此，要成为一名强大的深度学习实践者，一项需要练习的技能就是让你的 GPU 一次有大量的工作要做。

最好不要在每个轴上丢失这两个像素。我们这样做的方法是添加padding，这只是在图像外部添加的附加像素。最常见的是，添加零像素。

步幅和填充

图 13-4。带填充的卷积

 使用 5×5 输入、4×4 内核和 2 个像素填充，我们最终得到一个 6×6 激活图，如图 13-5 所示。

图 13-5。具有 5×5 输入和 2 像素填充的 4×4 内核（由 Vincent Dumoulin 和 Francesco Visin 提供）

 ks如果我们添加一个大小为 by ks（ks奇数）的内核，则每边保持相同形状所需的填充是ks//2. 偶数的ks将需要在顶部/底部和左侧/右侧填充不同数量的填充，但实际上我们几乎从不使用偶数过滤器大小。

图 13-6。具有 5×5 输入、stride-2 卷积和 1 像素填充的 3×3 内核（由 Vincent Dumoulin 和 Francesco Visin 提供）

 在大小为 的图像中h，w使用 1 的填充和 2 的步幅将为我们提供大小为 的(h+1)//2结果(w+1)//2。每个维度的通用公式是

(n + 2*pad - ks) // stride + 1

哪里pad是填充，ks是我们内核的大小，stride是步幅。

现在让我们看一下如何计算卷积结果的像素值。

了解卷积方程

这是我们的 3×3 像素图像，每个像素都标有一个字母：

 这是我们的内核，每个权重都标有希腊字母：

 由于过滤器适合图像四次，因此我们有四个结果：

图 13-7显示了我们如何将内核应用于图像的每个部分以产生每个结果。

图 13-7。应用内核

 方程式视图如图 13-8 所示。

图 13-8。方程式

 请注意，偏差项b对于图像的每个部分都是相同的。您可以将偏差视为过滤器的一部分，就像权重 (α, β, γ, δ) 是过滤器的一部分一样。

simple_net = nn.Sequential(
    nn.Linear(28*28,30),
    nn.ReLU(),
    nn.Linear(30,1)
)

我们可以查看模型的定义：

simple_net

Sequential(
  (0): Linear(in_features=784, out_features=30, bias=True)
  (1): ReLU()
  (2): Linear(in_features=30, out_features=1, bias=True)
)

我们现在想要创建一个与此线性模型类似的架构，但使用卷积层而不是线性模型。nn.Conv2d是 . 的模块等价物F.conv2d。它比 F.conv2d创建架构时更方便，因为它会在我们实例化它时自动为我们创建权重矩阵。

这是一个可能的架构：

broken_cnn = sequential(
    nn.Conv2d(1,30, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.Conv2d(30,1, kernel_size=3, padding=1)
)

这里要注意的一件事是我们不需要指定28*28输入大小。这是因为线性层需要在权重矩阵中为每个像素分配一个权重，因此它需要知道有多少个像素，但会自动对每个像素应用卷积。正如我们在上一节中看到的，权重仅取决于输入和输出通道的数量以及内核大小。

想想输出的形状是什么；那么让我们试试看：

broken_cnn(xb).shape

torch.Size([64, 1, 28, 28])

这不是我们可以用来进行分类的东西，因为我们需要每个图像的单个输出激活，而不是 28×28 的激活图。解决这个问题的一种方法是使用足够的 stride-2 卷积，使得最后一层的大小为 1。经过一个 stride-2 卷积后，大小将为 14×14；两次之后，它将是 7×7；然后是 4×4、2×2，最后是尺寸 1。

让我们现在试试看。首先，我们将定义一个函数，其中包含我们将在每个卷积中使用的基本参数：

def conv(ni, nf, ks=3, act=True):
    res = nn.Conv2d(ni, nf, stride=2, kernel_size=ks, padding=ks//2)
    if act: res = nn.Sequential(res, nn.ReLU())
    return res

下面是我们如何构建一个简单的 CNN：

simple_cnn = sequential(
    conv(1 ,4),            #14x14
    conv(4 ,8),            #7x7
    conv(8 ,16),           #4x4
    conv(16,32),           #2x2
    conv(32,2, act=False), #1x1
    Flatten(),
)

现在网络输出两个激活，它们映射到我们标签中的两个可能级别：

simple_cnn(xb).shape

torch.Size([64, 2])

我们现在可以创建我们的Learner：

learn = Learner(dls, simple_cnn, loss_func=F.cross_entropy, metrics=accuracy)

要准确查看模型中发生了什么，我们可以使用summary：

learn.summary()

Sequential (Input shape: ['64 x 1 x 28 x 28'])
================================================================
Layer (type)         Output Shape         Param #    Trainable
================================================================
Conv2d               64 x 4 x 14 x 14     40         True
________________________________________________________________
ReLU                 64 x 4 x 14 x 14     0          False
________________________________________________________________
Conv2d               64 x 8 x 7 x 7       296        True
________________________________________________________________
ReLU                 64 x 8 x 7 x 7       0          False
________________________________________________________________
Conv2d               64 x 16 x 4 x 4      1,168      True
________________________________________________________________
ReLU                 64 x 16 x 4 x 4      0          False
________________________________________________________________
Conv2d               64 x 32 x 2 x 2      4,640      True
________________________________________________________________
ReLU                 64 x 32 x 2 x 2      0          False
________________________________________________________________
Conv2d               64 x 2 x 1 x 1       578        True
________________________________________________________________
Flatten              64 x 2               0          False
________________________________________________________________

Total params: 6,722
Total trainable params: 6,722
Total non-trainable params: 0

Optimizer used: <function Adam at 0x7fbc9c258cb0>
Loss function: <function cross_entropy at 0x7fbca9ba0170>

Callbacks:
  - TrainEvalCallback
  - Recorder
  - ProgressCallback

请注意，最后Conv2d一层的输出是64x2x1x1。我们需要删除那些多余的1x1轴；就是Flatten这样。它与 PyTorch 的squeeze 方法基本相同，但作为一个模块。

learn.fit_one_cycle(2, 0.01)

成功！它越来越接近我们的resnet18结果，虽然还不完全是，而且它需要更多的时间，我们需要使用较低的学习率。我们还有一些技巧需要学习，但我们越来越接近能够从头开始创建现代 CNN。

了解卷积算法

m = learn.model[0]
m

Sequential(
  (0): Conv2d(1, 4, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
  (1): ReLU()
)

所以我们有 1 个输入通道、4 个输出通道和一个 3×3 内核。让我们检查第一个卷积的权重：

m[0].weight.shape

torch.Size([4, 1, 3, 3])

摘要显示我们有40个参数，4*1*3*3是36个。其他四个参数是什么？让我们看看偏差包含什么：

m[0].bias.shape

torch.Size([4])

图 13-10。Conv2层的直接先例

在这里，带有绿色边框的单元格是我们单击的单元格，蓝色突出显示的单元格是它的先例——用于计算它的值的单元格。这些单元格是来自输入层（左侧）的相应 3×3 单元格区域，以及来自过滤器（右侧）的单元格。现在让我们再次单击跟踪先例，以查看使用哪些单元格来计算这些输入。图 13-11显示了发生的情况。

在此示例中，我们只有两个卷积层，每个卷积层的步幅为 2，因此现在可以追溯到输入图像。我们可以看到输入层中 7×7 的单元格区域用于计算 Conv2 层中的单个绿色单元格。这个 7×7 的区域是 Conv2 中绿色激活输入的感受野。我们还可以看到现在需要第二个过滤器内核，因为我们有两层。

正如你从这个例子中看到的，我们在网络中越深（具体来说，我们在一层之前有越多的 stride-2 convs），该层中激活的感受野就越大。大的感受野意味着大量的输入图像用于计算该层中的每个激活。我们现在知道，在网络的更深层，我们具有语义丰富的特征，对应于更大的感受野。因此，我们希望我们的每个特征都需要更多的权重来处理这种日益增加的复杂性。这是我们在上一节中提到的同一件事的另一种说法：当我们在网络中引入 stride-2 conv 时，我们还应该增加通道数。

在编写这一章时，我们有很多问题需要回答，以便能够尽可能地向您解释 CNN。信不信由你，我们在 Twitter 上找到了大部分答案。在我们继续讨论彩色图像之前，我们现在将短暂休息一下与您讨论这个问题。

关于推特的注意事项

你看，推特还有另一部分，远离唐纳德特朗普和卡戴珊家族，深度学习研究人员和从业者每天都在这里讨论。在我们撰写本节时，Jeremy 想要仔细检查我们所说的关于 stride-2 卷积的内容是否准确，因此他在 Twitter 上问道：

几分钟后，弹出了这个答案：

Christian Szegedy 是 Inception的第一作者，2014 年 ImageNet 获胜者，以及现代神经网络中使用的许多关键见解的来源。两个小时后，出现了：

你认得那个名字吗？您在第 2 章中看到过，当时我们正在谈论为今天的深度学习奠定基础的图灵奖获得者！

Jeremy 还在 Twitter 上请求帮助检查我们在第 7 章中对标签平滑的描述是否准确，并再次直接从 Christian Szegedy 那里得到了回应（标签平滑最初在 Inception 论文中介绍）：

当今深度学习领域的许多顶尖人物都是 Twitter 的常客，并且非常乐于与更广泛的社区互动。开始的一个好方法是查看 Jeremy 最近的 Twitter 点赞列表，或 Sylvain 的点赞列表。这样，您就可以看到我们认为有有趣和有用的事情要说的 Twitter 用户列表。

Twitter 是我们了解最新有趣论文、软件发布和其他深度学习新闻的主要方式。为了与深度学习社区建立联系，我们建议同时参与fast.ai 论坛和 Twitter。

也就是说，让我们回到本章的主题。到目前为止，我们只向您展示了黑白图片示例，每个像素一个值。实际上，大多数彩色图像的每个像素都有三个值来定义它们的颜色。接下来我们将研究如何处理彩色图像。

def conv(ni, nf, ks=3, act=True):
    res = nn.Conv2d(ni, nf, stride=2, kernel_size=ks, padding=ks//2)
    if act: res = nn.Sequential(res, nn.ReLU())
    return res

让我们从一个基本的 CNN 开始作为基线。我们将使用与之前相同的一个，但有一个调整：我们将使用更多的激活。由于我们有更多的数字需要区分，我们可能需要学习更多的过滤器。

正如我们所讨论的，我们通常希望每次我们有一个 stride-2 层时将过滤器的数量加倍。增加整个网络中过滤器数量的一种方法是将第一层中的激活数量加倍——然后之后的每一层最终也将是之前版本的两倍。

但这会产生一个微妙的问题。考虑应用于每个像素的内核。默认情况下，我们使用 3×3 像素的内核。因此，在每个位置总共有 3 × 3 = 9 个像素应用内核。以前，我们的第一层有四个输出过滤器。因此，从每个位置的九个像素计算出四个值。想想如果我们将这个输出加倍到八个过滤器会发生什么。然后当我们应用内核时，我们将使用九个像素来计算八个数字。这意味着它并没有真正学到太多东西：输出大小几乎与输入大小相同。神经网络只有在被迫这样做时才会创建有用的特征——也就是说，如果操作的输出数量明显小于输入数量。

为了解决这个问题，我们可以在第一层使用更大的内核。如果我们使用 5×5 像素的内核，则每个内核应用程序将使用 25 个像素。从中创建八个过滤器意味着神经网络必须找到一些有用的特征：

def simple_cnn():
    return sequential(
        conv(1 ,8, ks=5),        #14x14
        conv(8 ,16),             #7x7
        conv(16,32),             #4x4
        conv(32,64),             #2x2
        conv(64,10, act=False),  #1x1
        Flatten(),
    )

正如您稍后会看到的，我们可以在模型训练时查看模型内部，以尝试找到让它们训练得更好的方法。为此，我们使用 ActivationStats回调，它记录每个可训练层的激活的均值、标准差和直方图（正如我们所见，回调用于向训练循环添加行为；我们将探讨它们的工作原理在 第 16 章中）：

from fastai.callback.hook import *

我们想要快速训练，这意味着以高学习率进行训练。让我们看看我们在 0.06 时的表现：

def fit(epochs=1):
    learn = Learner(dls, simple_cnn(), loss_func=F.cross_entropy,
                    metrics=accuracy, cbs=ActivationStats(with_hist=True))
    learn.fit(epochs, 0.06)
    return learn

learn = fit()

这根本没有训练好！让我们找出原因。

learn.activation_stats.plot_layer_stats(0)

通常，我们的模型在训练期间应该具有一致的或至少平滑的层激活均值和标准差。接近零的激活尤其有问题，因为这意味着我们在模型中进行的计算根本不做任何事情（因为乘以零得到零）。当你在一层中有一些零时，它们通常会转移到下一层……然后会产生更多的零。这是我们网络的倒数第二层：

learn.activation_stats.plot_layer_stats(-2)

增加批量大小

dls = get_dls(512)

learn = fit()

让我们看看倒数第二层是什么样的：

learn.activation_stats.plot_layer_stats(-2)

同样，我们的大部分激活都接近于零。让我们看看我们还能做些什么来提高训练的稳定性。

1周期训练

1cycle 训练允许我们使用比其他类型的训练高得多的最大学习率，这有两个好处：

• 通过以更高的学习率进行训练，我们训练得更快——史密斯称这种现象为超收敛。

• 通过以更高的学习率进行训练，我们可以减少过度拟合，因为我们跳过了尖锐的局部最小值，最终得到了更平滑（因此更具泛化性）的损失部分。

第二点很有趣，也很微妙。它基于这样的观察：一个泛化能力很好的模型是一个如果你少量改变输入，它的损失不会改变太多的模型。如果一个模型以较大的学习率训练了很长一段时间，并且在这样做时可以找到一个很好的损失，那么它一定已经找到了一个泛化能力也很好的区域，因为它在批次之间跳来跳去很多（基本上高学习率的定义）。问题是，正如我们已经讨论过的那样，仅仅跳到高学习率更有可能导致不同的损失，而不是看到你的损失有所改善。所以我们不会直接跳到高学习率。相反，我们从低学习率开始，我们的损失不会发散，

然后，一旦我们为参数找到了一个很好的平滑区域，我们就想找到该区域的最佳部分，这意味着我们必须再次降低学习率。这就是为什么 1cycle 训练有渐进的学习率预热和渐进的学习率冷却。许多研究人员发现，在实践中，这种方法会导致更准确的模型和更快的训练。这就是为什么fine_tune在 fastai 中默认使用这种方法的原因。

我们可以通过调用在 fastai 中使用 1cycle 训练fit_one_cycle：

def fit(epochs=1, lr=0.06):
    learn = Learner(dls, simple_cnn(), loss_func=F.cross_entropy,
                    metrics=accuracy, cbs=ActivationStats(with_hist=True))
    learn.fit_one_cycle(epochs, lr)
    return learn

learn = fit()

我们终于取得了一些进展！它现在给了我们一个合理的准确性。

lr_max

将使用的最高学习率（这也可以是每个层组的学习率列表，或 slice包含第一个和最后一个层组学习率的 Python 对象）

div

除以多少lr_max得到起始学习率

div_final

除以多少 lr_max得到最终学习率

pct_start

用于预热的批次百分比

moms

元组，其中是初始动量，是最小动量，是最终动量(mom1,mom2,mom3)mom1mom2mom3

让我们再次看一下图层统计信息：

learn.activation_stats.plot_layer_stats(-2)

 接近零权重的百分比越来越好，尽管它仍然很高。color_dim我们可以通过使用向它传递一个图层索引来了解更多关于我们训练中发生的事情：

learn.activation_stats.color_dim(-2)

图 13-14。彩色维度的直方图（由 Stefano Giomo 提供）

为了创建color_dim，我们采用左侧显示的直方图并将其转换为底部显示的彩色表示。然后我们将它翻转过来，如右图所示。我们发现如果取直方图值的对数，分布会更清晰。然后，Giomo 描述：

每个层的最终图是通过沿水平轴堆叠每个批次的激活直方图来绘制的。因此，可视化中的每个垂直切片代表单个批次的激活直方图。颜色强度对应直方图的高度；换句话说，每个直方图 bin 中的激活数。

图 13-15显示了这一切是如何组合在一起的。

这说明了当f服从正态分布时，为什么 log( f ) 比f更丰富多彩，因为取对数会改变二次方的高斯曲线，二次曲线并不那么窄。

因此，考虑到这一点，让我们再看一下倒数第二层的结果：

learn.activation_stats.color_dim(-2)

这显示了“不良训练”的经典画面。我们从几乎所有激活都为零开始——这就是我们在最左边看到的，所有的都是深蓝色。底部的亮黄色代表接近零的激活。然后，在前几批中，我们看到非零激活的数量呈指数增长。但它走得太远而崩溃了！我们看到深蓝色回归，底部再次变成亮黄色。看起来培训几乎是从头开始的。然后我们看到激活再次增加并再次崩溃。重复几次后，我们最终会看到整个范围内的激活分布。

如果训练能从一开始就顺利进行，那就更好了。指数增长然后崩溃的循环往往会导致大量接近零的激活，从而导致训练缓慢和最终结果不佳。解决这个问题的一种方法是使用批量归一化。

批量归一化

训练深度神经网络很复杂，因为每一层输入的分布在训练过程中都会发生变化，因为前一层的参数会发生变化。这通过要求较低的学习率和仔细的参数初始化来减慢训练速度……我们将这种现象称为内部协变量偏移，并通过规范化层输入来解决这个问题。

他们的解决方案，他们说如下：

使规范化成为模型架构的一部分，并对每个训练小批量执行规范化。Batch Normalization 允许我们使用更高的学习率并且对初始化不那么小心。

这篇论文一发表就引起了极大的轰动，因为它包含了图 13-16中的图表，它清楚地表明批归一化可以训练出比当前最先进的模型（ Inception 架构）更准确的模型大约快 5 倍。

图 13-16。批量归一化的影响（由 Sergey Ioffe 和 Christian Szegedy 提供）

批量归一化（通常称为batchnorm）的工作原理是取一层激活的均值和标准差的平均值，并使用它们对激活进行归一化。然而，这可能会导致问题，因为网络可能希望某些激活非常高，以便做出准确的预测。因此他们还添加了两个可学习的参数（意味着它们将在 SGD 步骤中更新），通常称为gamma和beta。在对激活进行归一化以获得一些新的激活向量y之后，batchnorm 层返回gamma*y + beta。

这就是为什么我们的激活可以有任何均值或方差，独立于前一层结果的均值和标准差。这些统计数据是单独学习的，使我们的模型更容易训练。训练和验证期间的行为是不同的：在训练期间，我们使用批次的均值和标准差来规范化数据，而在验证期间，我们使用训练期间计算的统计数据的运行平均值。

让我们添加一个 batchnorm 层到conv：

def conv(ni, nf, ks=3, act=True):
    layers = [nn.Conv2d(ni, nf, stride=2, kernel_size=ks, padding=ks//2)]
    layers.append(nn.BatchNorm2d(nf))
    if act: layers.append(nn.ReLU())
    return nn.Sequential(*layers)

并适合我们的模型：

learn = fit()

这是一个很好的结果！让我们来看看 color_dim：

learn.activation_stats.color_dim(-4)

 这正是我们希望看到的：激活的顺利发展，没有“崩溃”。Batchnorm 在这里真的兑现了它的承诺！事实上，batchnorm 非常成功，以至于我们在几乎所有现代神经网络中都能看到它（或非常相似的东西）。

关于包含批量归一化层的模型的一个有趣观察是，它们往往比不包含它们的模型具有更好的泛化能力。虽然我们还没有看到对这里发生的事情进行严格的分析，但大多数研究人员认为，原因是批量归一化为训练过程增加了一些额外的随机性。每个 mini-batch 的均值和标准差与其他 mini-batch 有所不同。因此，每次都会用不同的值对激活进行归一化。为了让模型做出准确的预测，它必须学会对这些变化变得稳健。通常，在训练过程中添加额外的随机化通常会有所帮助。

既然一切进展顺利，让我们再训练几个 epoch，看看进展如何。事实上，让我们提高 学习率，因为 batchnorm 论文的摘要声称我们应该能够“以更高的学习率进行训练”：

learn = fit(5, lr=0.1)

learn = fit(5, lr=0.1)