让我们谈谈 CIFAR10，原因是今天我们将看一些更基础的 PyTorch 内容，以构建这些生成对抗模型。目前没有关于 GAN 的 fastai 支持 - 很快就会有，但目前还没有，所以我们将从头开始构建许多模型。我们已经有一段时间没有进行严肃的模型构建了。在课程的第一部分中，我们看了 CIFAR10，并构建了一个准确率约为 85%的模型，训练时间约为几个小时。有趣的是，现在正在进行一项竞赛，看看谁能最快地训练 CIFAR10（DAWN），目标是将准确率提高到 94%。看看我们是否能构建一个能够达到 94%准确率的架构，因为这比我们之前的尝试要好得多。希望通过这样做，我们将学到一些关于创建良好架构的东西，这对于今天研究 GANs 将会很有用。此外，这也很有用，因为 Jeremy 在过去几年深入研究了关于不同类型 CNN 架构的论文，并意识到这些论文中的许多见解并没有被广泛利用，显然也没有被广泛理解。因此，他想向您展示如果我们能利用其中一些理解会发生什么。

这个笔记本被称为darknet，因为我们将要查看的特定架构与 darknet 架构非常接近。但在这个过程中，您会发现 darknet 架构并不是整个 YOLO v3 端到端的东西，而只是他们在 ImageNet 上预训练用于分类的部分。这几乎就像您可以想到的最通用的简单架构，因此它是实验的一个很好的起点。因此，我们将其称为“darknet”，但它并不完全是那样，您可以对其进行调整以创建绝对不是 darknet 的东西。它实际上只是几乎任何现代基于 ResNet 的架构的基础。

CIFAR10 是一个相当小的数据集[8:06]。图像大小仅为 32x32，这是一个很好的数据集，因为：

• 与 ImageNet 不同，您可以相对快速地对其进行训练

• 相对较少的数据

• 实际上很难识别这些图像，因为 32x32 太小了，很难看清楚发生了什么。

这是一个被低估的数据集，因为它很老。谁愿意使用小而古老的数据集，当他们可以利用整个服务器房间来处理更大的数据时。但这是一个非常好的数据集，值得关注。

继续导入我们通常使用的东西，我们将尝试从头开始构建一个网络来训练这个[8:58]。

%matplotlib inline
%reload_ext autoreload
%autoreload 2
from fastai.conv_learner import *
PATH = Path("data/cifar10/")
os.makedirs(PATH,exist_ok=True)

对于那些对广播和 PyTorch 基本技能不是 100%自信的人来说，一个非常好的练习是弄清楚 Jeremy 是如何得出这些stats数字的。这些数字是 CIFAR10 中每个通道的平均值和标准差。尝试确保您可以重新创建这些数字，并查看是否可以在不超过几行代码的情况下完成（不使用循环！）。

由于这些数据相当小，我们可以使用比通常更大的批量大小，并且这些图像的大小为 32[9:46]。

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'
)
stats = (np.array([ 0.4914 ,  0.48216,  0.44653]), np.array([ 0.24703,  0.24349,  0.26159])
)num_workers = num_cpus()//2
bs=256
sz=32

变换[9:57]，通常我们有这一套标准的 side_on 变换，用于普通物体的照片。我们不会在这里使用这个，因为这些图像太小了，尝试将一个 32x32 的图像稍微旋转会引入很多块状失真。人们倾向于使用的标准变换是随机水平翻转，然后我们在每一侧添加 4 个像素（尺寸除以 8）的填充。一个非常有效的方法是，默认情况下 fastai 不会添加黑色填充，而许多其他库会这样做。Fastai 会取现有照片的最后 4 个像素，翻转并反射它，我们发现使用反射填充会得到更好的结果。现在我们有了 40x40 的图像，在训练中，这组变换将随机选择 32x32 的裁剪，所以我们会有一点变化但不会太多。因此我们可以使用正常的from_paths来获取我们的数据。

tfms = tfms_from_stats(stats, sz, aug_tfms=[RandomFlip()], pad=sz//8
)
data = ImageClassifierData.from_paths(PATH, val_name='test', tfms=tfms, bs=bs
)

现在我们需要一个架构，我们将创建一个适合在一个屏幕上显示的架构[11:07]。这是从头开始的。我们正在使用预定义的Conv2d，BatchNorm2d，LeakyReLU模块，但我们没有使用任何块或其他东西。整个东西都在一个屏幕上，所以如果你曾经想知道我是否能理解一个现代的高质量架构，绝对可以！让我们来学习这个。

def conv_layer(ni, nf, ks=3, stride=1):return nn.Sequential(nn.Conv2d(ni, nf, kernel_size=ks, bias=False, stride=stride,padding=ks//2),nn.BatchNorm2d(nf, momentum=0.01),nn.LeakyReLU(negative_slope=0.1, inplace=True))
class ResLayer(nn.Module):def __init__(self, ni):super().__init__()self.conv1=conv_layer(ni, ni//2, ks=1)self.conv2=conv_layer(ni//2, ni, ks=3)def forward(self, x): return x.add_(self.conv2(self.conv1(x)))
class Darknet(nn.Module):def make_group_layer(self, ch_in, num_blocks, stride=1):return [conv_layer(ch_in, ch_in*2,stride=stride)] + \[(ResLayer(ch_in*2)) for i in range(num_blocks)]def __init__(self, num_blocks, num_classes, nf=32):super().__init__()layers = [conv_layer(3, nf, ks=3, stride=1)]for i,nb in enumerate(num_blocks):layers += self.make_group_layer(nf, nb, stride=2-(i==1))nf *= 2layers += [nn.AdaptiveAvgPool2d(1), Flatten(), nn.Linear(nf, num_classes)]self.layers = nn.Sequential(*layers)def forward(self, x): return self.layers(x)

架构的基本起点是说它是一堆堆叠的层，一般来说会有一种层次结构[11:51]。在最底层，有像卷积层和批量归一化层这样的东西，但任何时候你有一个卷积，你可能会有一些标准的顺序。通常会是：

1. 卷积

2. 批量归一化

3. 一个非线性激活（例如 ReLU）

我们将从确定我们的基本单元是什么开始，并在一个函数（conv_layer）中定义它，这样我们就不必担心保持一致性，这将使一切变得更简单。

Leaky Relu [12:43]：

Leaky ReLU 的梯度（其中x < 0）会有所变化，但通常是 0.1 或 0.01 左右。其背后的想法是，当你处于负区域时，你不会得到一个零梯度，这会使更新变得非常困难。实践中，人们发现 Leaky ReLU 在较小的数据集上更有用，在大数据集上不太有用。但有趣的是，在YOLO v3论文中，他们使用了 Leaky ReLU，并从中获得了很好的性能。它很少会使事情变得更糟，通常会使事情变得更好。所以如果你需要创建自己的架构，Leaky ReLU 可能不错作为默认选择。

你会注意到我们在conv_layer中没有定义 PyTorch 模块，我们只是使用nn.Sequential[14:07]。如果你阅读其他人的 PyTorch 代码，你会发现这是一个被低估的东西。人们倾向于将一切都写成 PyTorch 模块，带有__init__和forward，但如果你想要的只是一系列按顺序排列的东西，将其作为Sequential会更简洁易懂。

残差块 [14:40]：如前所述，大多数现代网络中通常有多个层次的单元，我们现在知道 ResNet 中这个单元层次结构的下一个级别是 ResBlock 或残差块（参见ResLayer）。回顾我们上次做 CIFAR10 时，我们过于简化了（有点作弊）。我们将x输入，经过一个conv，然后将其加回到x中输出。在真正的 ResBlock 中，有两个这样的块。当我们说conv时，我们将其作为conv_layer的快捷方式（卷积，批量归一化，ReLU）。

这里有一个有趣的观点是这些卷积中的通道数量。我们有一些 ni 进来（一些输入通道/滤波器的数量）。Darknet 团队设置的方式是，他们让每一个这些 Res 层输出与进来的相同数量的通道，Jeremy 喜欢这样做，这就是为什么他在ResLayer中使用它，因为这样会让生活更简单。第一个卷积将通道数量减半，然后第二个卷积再将其加倍。所以你有一个漏斗效应，64 个通道进来，通过第一个卷积压缩到 32 个通道，然后再次提升到 64 个通道输出。

问题：为什么LeakyReLU中要使用inplace=True？谢谢你的提问！很多人忘记了这一点或者不知道这一点，但这是一个非常重要的内存技巧。如果你想一下，这个conv_layer，它是最底层的东西，所以基本上我们的 ResNet 一旦全部组装起来，就会有很多conv_layer。如果你没有inplace=True，它会为 ReLU 的输出创建一个完全独立的内存块，这样就会分配一大堆完全不必要的内存。另一个例子是ResLayer中的原始forward看起来像这样：

def forward(self, x): return x + self.conv2(self.conv1(x))

希望你们中的一些人记得在 PyTorch 中几乎每个函数都有一个下划线后缀版本，告诉它在原地执行。+等同于add，add的原地版本是add_，这样可以减少内存使用量：

def forward(self, x): return x.add_(self.conv2(self.conv1(x)))

这些都是非常方便的小技巧。Jeremy 一开始忘记了inplace=True，但他不得不将批量大小降低到非常低的数量，这让他发疯了——然后他意识到那个部分缺失了。如果你使用了 dropout，你也可以这样做。以下是需要注意的事项：

• Dropout

• 所有激活函数

• 任何算术操作

问题：在 ResNet 中，为什么conv_layer中的偏置通常设置为 False？在Conv之后，紧接着是BatchNorm。记住，BatchNorm对于每个激活有 2 个可学习参数——你要乘以的东西和你要添加的东西。如果我们在Conv中有偏置，然后在BatchNorm中再添加另一件事，那就是在添加两件事，这完全没有意义——这是两个权重，一个就够了。所以如果在Conv之后有一个BatchNorm，你可以告诉BatchNorm不要包括添加部分，或者更简单的方法是告诉Conv不要包括偏置。这没有特别的危害，但是会占用更多内存，因为它需要跟踪更多的梯度，所以最好避免。

另一个小技巧是，大多数人的conv_layer都有填充作为参数。但一般来说，你应该能够很容易地计算填充。如果卷积核大小为 3，那么显然每边会有一个单位的重叠，所以我们需要填充 1。或者，如果卷积核大小为 1，那么我们就不需要任何填充。所以一般来说，卷积核大小“整数除以 2”就是你需要的填充。有时会有一些调整，但在这种情况下，这个方法非常有效。再次尝试简化我的代码，让计算机为我计算东西，而不是我自己去做。

另一个关于这两个conv_layer的事情：我们有这个瓶颈的想法（减少通道然后再增加），还有要使用的卷积核大小。第一个有 1 乘 1 的Conv。1 乘 1 卷积实际上发生了什么？如果我们有一个 4 乘 4 的网格，有 32 个滤波器/通道，我们将进行 1 乘 1 卷积，卷积的核看起来像中间的那个。当我们谈论卷积核大小时，我们从来没有提到最后一部分——但假设它是 1 乘 1 乘 32，因为这是输入和输出的滤波器的一部分。卷积核被放在黄色的第一个单元上，我们得到这 32 个深度位的点积，这给了我们第一个输出。然后我们将其移动到第二个单元并得到第二个输出。所以对于网格中的每个点，都会有一堆点积。这使我们能够以任何我们想要的方式改变通道维度。我们创建了ni//2个滤波器，我们将有ni//2个点积，基本上是输入通道的不同加权平均值。通过非常少的计算，它让我们添加了这个额外的计算和非线性步骤。这是一个很酷的技巧，利用这些 1 乘 1 卷积，创建这个瓶颈，然后再用 3 乘 3 卷积拉出来——这将充分利用输入的 2D 特性。否则，1 乘 1 卷积根本不利用这一点。

这两行代码，里面没有太多内容，但这是一个对你对正在发生的事情的理解和直觉的很好的测试——为什么它有效？为什么张量秩是对齐的？为什么维度都很好地对齐？为什么这是一个好主意？它到底在做什么？这是一个很好的东西来调整。也许在 Jupyter Notebook 中创建一些小的实例，自己运行一下，看看输入和输出是什么。真正感受一下。一旦你这样做了，你就可以尝试不同的东西。

这篇真正被低估的论文是这篇Wide Residual Networks。这篇论文非常简单，但他们做的是围绕这两行代码进行调整：

• 如果我们用ni*2代替ni//2会怎样？

• 如果我们添加conv3呢？

他们提出了一种简单的符号表示来定义这两行代码可能的样子，并展示了许多实验。他们展示的是，在 ResNet 中普遍采用的减少通道数量的瓶颈方法可能不是一个好主意。实际上，根据实验结果，绝对不是一个好主意。因为这样可以创建非常深的网络。创建 ResNet 的人因为创建了 1001 层网络而变得特别有名。但是 1001 层的问题在于，你无法在完成第 1 层之前计算第 2 层。你无法在完成计算第 2 层之前计算第 3 层。所以是顺序的。GPU 不喜欢顺序。所以他们展示的是，如果层数较少但每层计算量更大——一个简单的方法是去掉//2，没有其他改变：

在家里试试吧。尝试运行 CIFAR 看看会发生什么。甚至乘以 2 或者摆弄一下。这样可以让你的 GPU 做更多的工作，这非常有趣，因为绝大多数关于不同架构性能的论文实际上从来没有计算运行一个批次需要多长时间。他们说“这个需要每批次 X 个浮点运算”，但他们从来没有真正费心像一个合格的实验者那样运行它，找出它是快还是慢。现在很有名的很多架构结果都很慢，占用大量内存，完全没用，因为研究人员从来没有费心看看它们是否快，实际上看看它们是否适合正常批次大小的内存。所以 Wide ResNet 论文之所以不同在于它实际上计算了运行所需的时间，YOLO v3 论文也做了同样的发现。他们可能错过了 Wide ResNet 论文，因为 YOLO v3 论文得出了很多相同的结论，但 Jeremy 不确定他们是否引用了 Wide ResNet 论文，所以他们可能不知道所有这些工作已经完成。看到人们实际上在计时并注意到什么是有意义的是很好的。

问题：你对 SELU（缩放指数线性单元）有什么看法？[29:44] SELU 主要用于全连接层，它允许你摆脱批量归一化，基本思想是，如果你使用这种不同的激活函数，它是自归一化的。自归一化意味着它将始终保持单位标准差和零均值，因此你不需要批量归一化。它实际上并没有取得什么进展，原因是因为它非常挑剔 — 你必须使用非常特定的初始化，否则它就不会以完全正确的标准差和均值开始。很难将其用于诸如嵌入之类的东西，如果你这样做，那么你必须使用一种特定类型的嵌入初始化，这对嵌入来说是没有意义的。你做了所有这些工作，很难搞对，最终如果你搞对了，有什么意义呢？好吧，你成功摆脱了一些并没有真正伤害你的批量归一化层。有趣的是 SELU 论文 — 人们注意到它的主要原因是因为它是由 LSTM 的发明者创建的，而且它有一个巨大的数学附录。所以人们认为“一个名人的大量数学 — 必定很棒！”但实际上，Jeremy 没有看到任何人使用它来获得任何最先进的结果或赢得任何比赛。

Darknet.make_group_layer包含一堆ResLayer[31:28]。group_layer将会有一些通道/滤波器进入。我们将通过使用标准的conv_layer来使进入的通道数量加倍。可选地，我们将通过使用步幅为 2 来减半网格大小。然后我们将做一系列的 ResLayers — 我们可以选择多少个（2、3、8 等），因为记住 ResLayers 不会改变网格大小，也不会改变通道数量，所以你可以添加任意数量而不会造成任何问题。这将使用更多的计算和内存，但除此之外你可以添加任意数量。因此，group_layer最终将使通道数量加倍，因为初始卷积使通道数量加倍，取决于我们传入的stride，如果我们设置stride=2，它也可能减半网格大小。然后我们可以做一系列 Res 块的计算，任意数量。

定义我们的Darknet，我们将传入类似这样的东西[33:13]：

m = Darknet([1, 2, 4, 6, 3], num_classes=10, nf=32)
m = nn.DataParallel(m, [1,2,3])

这意味着创建五个组层：第一个将包含 1 个额外的 ResLayer，第二个将包含 2 个，然后是 4 个，6 个，3 个，我们希望从 32 个滤波器开始。第一个 ResLayers 将包含 32 个滤波器，只会有一个额外的 ResLayer。第二个将会使滤波器数量翻倍，因为每次有一个新的组层时我们都会这样做。所以第二个将有 64 个，然后 128 个，256 个，512 个，就这样。几乎整个网络将由这些层组成，记住，每个组层在开始时也有一个卷积。所以在这之前，我们将在一开始有一个卷积层，在最后我们将执行标准的自适应平均池化，展平，并在最后创建一个线性层来生成最终的类别数量。总结一下，一个端有一个卷积，自适应池化和另一个端有一个线性层，中间是这些组层，每个组层由一个卷积层和n个 ResLayers 组成。

自适应平均池化：Jeremy 多次提到过这个，但他还没有看到任何代码，任何示例，任何地方使用自适应平均池化。他看到的每一个都像nn.AvgPool2d(n)这样写，其中n是一个特定的数字-这意味着它现在与特定的图像大小绑定在一起，这绝对不是您想要的。所以大多数人仍然认为特定的架构与特定的大小绑定在一起。当人们认为这样时，这是一个巨大的问题，因为这会严重限制他们使用更小的尺寸来启动建模或使用更小的尺寸进行实验的能力。

Sequential：创建架构的一个好方法是首先创建一个列表，在这种情况下，这是一个只有一个conv_layer的列表，然后make_group_layer返回另一个列表。然后我们可以用+=将该列表附加到前一个列表中，并对包含AdaptiveAvnPool2d的另一个列表执行相同操作。最后，我们将调用所有这些层的nn.Sequential。现在forward只是self.layers(x)。

这是如何使您的架构尽可能简单的好方法。有很多可以摆弄的地方。您可以将ni的除数参数化，使其成为您传入的数字，以传入不同的数字-也许是乘以 2。您还可以传入一些可以改变内核大小或改变卷积层数量的参数。Jeremy 有一个版本，他将为您运行，其中实现了 Wide ResNet 论文中的所有不同参数，因此他可以摆弄看看哪些效果好。

lr = 1.3
learn = ConvLearner.from_model_data(m, data)
learn.crit = nn.CrossEntropyLoss()
learn.metrics = [accuracy]
wd=1e-4
%time learn.fit(lr, 1, wds=wd, cycle_len=30, use_clr_beta=(20, 20, 0.95, 0.85)
)

一旦我们有了这个，我们可以使用ConvLearner.from_model_data来获取我们的 PyTorch 模块和模型数据对象，并将它们转换为一个学习器。给它一个标准，如果我们喜欢，可以添加一个指标，然后我们可以拟合并开始。

问题：您能解释一下自适应平均池化吗？将其设置为 1 是如何工作的？当我们进行平均池化时，通常情况下，假设我们有 4x4，然后进行avgpool((2, 2))。这将创建一个 2x2 的区域（下方的蓝色），并取这四个的平均值。如果我们传入stride=1，下一个是 2x2（绿色），然后取平均值。这就是正常的 2x2 平均池化。如果我们没有填充，那么输出将是 3x3。如果我们想要 4x4，我们可以添加填充。

如果我们想要 1x1 呢？那么我们可以说avgpool((4,4), stride=1)，这将在黄色中进行 4x4 并对整体进行平均，结果为 1x1。但这只是一种方法。与其说池化滤波器的大小，为什么不说“我不在乎输入网格的大小。我总是想要一个一个”。这就是你说adap_avgpool(1)的地方。在这种情况下，你不说池化滤波器的大小，而是说我们想要的输出大小。我们想要的是一个一个。如果你放一个单独的整数n，它会假设你的意思是n乘以n。在这种情况下，一个 4x4 网格的自适应平均池化与平均池化(4,4)相同。如果是一个 7x7 的网格进来，它将与平均池化(7,7)相同。这是相同的操作，只是以一种方式表达，无论输入是什么，我们都希望得到那个大小的输出。

DAWNBench：让我们看看我们的简单网络与这些最新技术结果相比如何。Jeremy 已经准备好命令了。我们已经将所有这些东西放入一个简单的 Python 脚本中，他修改了一些他提到的参数，创建了一个他称之为wrn_22网络，它并不存在，但根据 Jeremy 的实验，它对我们讨论的参数进行了一些改变。它有一堆很酷的东西，比如：

• 莱斯利·史密斯的一个周期

• 半精度浮点实现

这将在 AWS p3 上运行，它有 8 个 GPU 和 Volta 架构的 GPU，这些 GPU 对半精度浮点有特殊支持。Fastai 是第一个实际将 Volta 优化的半精度浮点集成到库中的库，所以你只需learn.half()就可以自动获得支持。它也是第一个集成一个周期的库。

实际上，这是使用 PyTorch 的多 GPU 支持。由于有八个 GPU，它实际上会启动八个单独的 Python 处理器，每个处理器都会训练一点，然后最后将梯度更新传回主进程，主进程将把它们全部整合在一起。所以你会看到很多进度条一起弹出。

你可以看到这种方式训练三到四秒。而在之前，当 Jeremy 早些时候训练时，他每个时代要花 30 秒。所以用这种方式，我们可以训练东西大约快 10 倍，这很酷。

检查状态：

完成了！我们达到了 94%，用时 3 分 11 秒。之前的最新技术是 1 小时 7 分钟。折腾这些参数，学习这些架构实际上是如何工作的，而不仅仅是使用开箱即用的东西，值得吗？哇哦。我们刚刚使用了一个公开可用的实例（我们使用了一个 spot 实例，所以花费了我们每小时 8 美元——3 分钟 40 美分）来从头开始训练，比以往任何人都要快 20 倍。所以这是最疯狂的最新技术结果之一。我们看到了很多，但这个结果真的让人大吃一惊。这在很大程度上要归功于调整这些架构参数，主要是关于使用莱斯利·史密斯的一个周期。提醒一下它在做什么，对于学习率，它创建了一个向上的路径，与向下的路径一样长，所以它是真正的三角形循环学习率（CLR）。像往常一样，你可以选择 x 和 y 的比例（即起始 LR/峰值 LR）。在

在这种情况下，我们选择了 50 作为比率。所以我们从更小的学习率开始。然后它有一个很酷的想法，你可以说你的 epochs 的百分之几是从三角形底部一直下降到几乎为零 - 这是第二个数字。所以 15%的批次花在从我们的三角形底部进一步下降。

这不是一个周期所做的唯一事情，我们还有动量。动量从 0.95 到 0.85。换句话说，当学习率很低时，我们使用很大的动量，当学习率很高时，我们使用很少的动量，这很有道理，但在 Leslie Smith 在论文中展示之前，Jeremy 从未见过有人这样做。这是一个非常酷的技巧。你现在可以通过在 fastai 中使用use-clr-beta参数来使用它（Sylvain 的论坛帖子），你应该能够复制最先进的结果。你可以在自己的计算机上或者 paper space 上使用它，唯一得不到的是多 GPU 部分，但这样训练会更容易一些。

问题：make_group_layer包含步幅等于 2，这意味着第一层的步幅为 1，其他所有层的步幅为 2。背后的逻辑是什么？通常我见过的步幅是奇数。步幅要么是 1，要么是 2。我认为你在考虑卷积核大小。所以步幅=2 意味着我跨越两个，这意味着你的网格大小减半。所以我认为你可能在步幅和卷积核大小之间混淆了。如果步幅为 1，网格大小不会改变。如果步幅为 2，那么会改变。在这种情况下，因为这是 CIFAR10，32x32 很小，我们不会经常减半网格大小，因为很快我们就会用完单元格。这就是为什么第一层的步幅为 1，这样我们不会立即减小网格大小。这是一种很好的做法，因为这就是为什么我们一开始在大网格上没有太多计算Darknet([1, 2, 4, 6, 3], …)。我们可以从大网格上开始，然后随着网格变小，逐渐增加更多的计算，因为网格越小，计算所需的时间就越少。

• 沃瑟斯坦 GAN

• 使用深度卷积生成对抗网络进行无监督表示学习

我们将讨论生成对抗网络，也称为 GAN，具体来说，我们将专注于沃瑟斯坦 GAN 论文，其中包括后来创建 PyTorch 的 Soumith Chintala。沃瑟斯坦 GAN（WGAN）受到了深度卷积生成对抗网络论文的重大影响，Soumith 也参与其中。这是一篇非常有趣的论文。很多内容看起来像这样：

好消息是你可以跳过那些部分，因为还有一个看起来像这样的部分：

很多论文都有一个理论部分，似乎完全是为了满足审稿人对理论的需求。但 WGAN 论文并非如此。理论部分实际上很有趣 - 你不需要了解它就能使用它，但如果你想了解一些很酷的想法，并看到为什么选择这种特定算法的思考过程，那绝对是迷人的。在这篇论文出来之前，Jeremy 不认识任何研究其基础数学的人，所以每个人都必须学习这些数学知识。这篇论文做了很好的工作，列出了所有的要点（你需要自己阅读一些内容）。所以如果你对深入研究某篇论文背后更深层次的数学感兴趣，想看看学习它是什么感觉，我会选择这篇，因为在那个理论部分结束时，你会说“我现在明白他们为什么要设计这种算法了。”

GAN 的基本思想是它是一个生成模型[51:23]。它将创建句子、创建图像或生成一些东西。它将尝试创建一些很难区分生成的东西和真实的东西的东西。因此，生成模型可以用于换脸视频——目前发生的深度伪造和虚假色情非常有争议。它可以用来伪造某人的声音。它可以用来伪造对医学问题的回答——但在这种情况下，它并不是真正的伪造，它可以是对医学问题的生成回答，实际上是一个好的回答，因此你在生成语言。例如，你可以为图像生成标题。因此，生成模型有许多有趣的应用。但一般来说，它们需要足够好，例如，如果你要用它自动为凯丽·费舍尔在下一部星球大战电影中的新场景而她已经不在了，你想尝试生成一个看起来一样的图像，那么它必须欺骗星球大战的观众，让他们认为“好吧，那看起来不像奇怪的凯丽·费舍尔——那看起来像真正的凯丽·费舍尔。或者如果你试图生成对医学问题的回答，你希望生成的英语读起来流畅清晰，并且听起来有权威和意义。生成对抗网络的思想是我们不仅要创建一个生成模型来创建生成的图像，还要创建一个第二个模型，它将尝试挑选哪些是真实的，哪些是生成的（我们将称之为“假的”）。因此，我们有一个生成器，它将创建我们的虚假内容，还有一个鉴别器，它将努力变得擅长识别哪些是真实的，哪些是假的。因此，将有两个模型，它们将是对抗性的，意味着生成器将努力不断提高欺骗鉴别器认为假的是真实的能力，而鉴别器将努力不断提高区分真实和虚假的能力。因此，它们将正面交锋。这基本上就像 Jeremy 刚刚描述的那样[54:14]：

• 我们将在 PyTorch 中构建两个模型

• 我们将创建一个训练循环，首先说鉴别器的损失函数是“你能分辨真实和虚假吗，然后更新那个的权重。

• 我们将为生成器创建一个损失函数，即“你能生成一些能欺骗鉴别器的东西并从中更新权重。

• 然后我们将循环几次并看看会发生什么。

笔记本

GAN 有很多不同的用途。我们将做一些有点无聊但易于理解的事情，而且甚至可能的是我们将从无中生成一些图片。我们只是让它画一些图片。具体来说，我们将让它画卧室的图片。希望你有机会在这一周内使用自己的数据集玩耍。如果你选择一个非常多样化的数据集，比如 ImageNet，然后让 GAN 尝试创建 ImageNet 的图片，它往往做得不太好，因为你想要的图片不够清晰。所以最好给它，例如，有一个名为CelebA的数据集，其中包含名人的脸部图片，这对 GAN 非常有效。你可以生成真实但实际上不存在的名人脸。卧室数据集也是一个不错的选择——同一种类型的图片。

有一个叫做 LSUN 场景分类数据集的东西。

from fastai.conv_learner import *
from fastai.dataset import *
import gzip

下载 LSUN 场景分类数据集卧室类别，解压缩它，并将其转换为 jpg 文件（脚本文件夹在dl2文件夹中）：

curl 'http://lsun.cs.princeton.edu/htbin/download.cgi?tag=latest&category=bedroom&set=train' -o bedroom.zip
unzip bedroom.zip
pip install lmdb
python lsun-data.py {PATH}/bedroom_train_lmdb --out_dir {PATH}/bedroom

这在 Windows 上没有经过测试 - 如果不起作用，您可以使用 Linux 框来转换文件，然后复制它们。或者，您可以从 Kaggle 数据集中下载这个 20%的样本。

PATH = Path('data/lsun/')
IMG_PATH = PATH/'bedroom'
CSV_PATH = PATH/'files.csv'
TMP_PATH = PATH/'tmp'
TMP_PATH.mkdir(exist_ok=True)

在处理我们的数据时，通过 CSV 路线会更容易。因此，我们生成一个包含我们想要的文件列表和一个虚假标签“0”的 CSV，因为我们实际上根本没有这些标签。一个 CSV 文件包含卧室数据集中的所有内容，另一个包含随机的 10%。这样做很好，因为这样我们在实验时大多数时间可以使用样本，因为即使只是读取列表也需要很长时间，因为有超过一百万个文件。

files = PATH.glob('bedroom/**/*.jpg')with CSV_PATH.open('w') as fo:for f in files: fo.write(f'{f.relative_to(IMG_PATH)},0\n')# Optional - sampling a subset of files
CSV_PATH = PATH/'files_sample.csv'
files = PATH.glob('bedroom/**/*.jpg')with CSV_PATH.open('w') as fo:for f in files:if random.random()<0.1: fo.write(f'{f.relative_to(IMG_PATH)},0\n')

这看起来非常熟悉。这是在 Jeremy 意识到顺序模型更好之前。因此，如果将这与以前的顺序模型的卷积块进行比较，这里有更多的代码行数——但它做的事情是一样的，卷积，ReLU，批量归一化。

class ConvBlock(nn.Module):def __init__(self, ni, no, ks, stride, bn=True, pad=None):super().__init__()if pad is None: pad = ks//2//strideself.conv = nn.Conv2d(ni, no, ks, stride, padding=pad, bias=False)self.bn = nn.BatchNorm2d(no) if bn else Noneself.relu = nn.LeakyReLU(0.2, inplace=True)def forward(self, x):x = self.relu(self.conv(x))return self.bn(x) if self.bn else x

我们要做的第一件事是构建一个鉴别器。鉴别器将接收一幅图像作为输入，并输出一个数字。如果它认为这幅图像是真实的，那么这个数字应该更低。当然，“它为什么输出一个更低的数字”这个问题不会出现在架构中，这将在损失函数中。所以我们所要做的就是创建一个接收图像并输出数字的东西。这些代码的很多部分都是从这篇论文的原始作者那里借来的，所以一些命名方案与我们习惯的不同。但它看起来与我们之前的很相似。我们从卷积（conv，ReLU，批量归一化）开始。然后我们有一堆额外的卷积层——这不会使用残差，所以它看起来与之前非常相似，有一堆额外的层，但这些将是卷积层而不是残差层。最后，我们需要添加足够的步幅为 2 的卷积层，使网格大小减小到不大于 4x4。所以它将继续使用步幅 2，将大小除以 2，并重复直到我们的网格大小不大于 4。这是一个非常好的方法，可以创建网络中所需的任意数量的层，以处理任意大小的图像并将它们转换为固定的已知网格大小。

问题：GAN 是否需要比狗和猫或 NLP 等更多的数据？还是可以相提并论？老实说，我有点尴尬地说我不是 GAN 的专家从业者。我在第一部分教授的东西是我很高兴地说我知道如何做这些事情的最佳方式，所以我可以展示像我们刚刚在 CIFAR10 中所做的那样的最新结果，有一些学生的帮助。我在 GAN 方面一点也不行，所以我不太确定你需要多少。总的来说，似乎需要相当多，但请记住我们在狗和猫方面不需要太多的原因是因为我们有一个预训练模型，我们可以利用预训练的 GAN 模型并微调它们，可能。据我所知，我认为没有人这样做过。这可能是人们考虑和实验的一个非常有趣的事情。也许人们已经这样做了，有一些文献我们还没有接触到。我对 GAN 的主要文献有一些了解，但并不是全部，所以也许我错过了关于 GAN 中迁移学习的一些内容。但这可能是不需要太多数据的诀窍。

问题：是单周期学习率和动量退火加上八个 GPU 并行训练在半精度下的巨大加速？只有消费级 GPU 才能进行半精度计算吗？另一个问题，为什么从单精度到半精度的计算速度提高了 8 倍，而从双精度到单精度只提高了 2 倍？好的，所以 CIFAR10 的结果，从单精度到半精度并不是提高了 8 倍。从单精度到半精度大约快了 2 到 3 倍。NVIDIA 声称张量核心的 flops 性能，在学术上是正确的，但在实践中是没有意义的，因为这真的取决于你需要什么调用来做什么事情——所以半精度大约提高了 2 到 3 倍。所以半精度有所帮助，额外的 GPU 有所帮助，单周期有很大帮助，然后另一个关键部分是我告诉你的参数调整。所以仔细阅读 Wide ResNet 论文，识别他们在那里发现的东西的类型，然后编写一个你刚刚看到的架构的版本，使我们可以轻松地调整参数，整夜不眠地尝试每种可能的不同核大小、核数、层组数、层组大小的组合。记住，我们做了一个瓶颈，但实际上我们更倾向于扩大，所以我们增加了大小，然后减小了，因为这更好地利用了 GPU。所以所有这些结合在一起，我会说单周期也许是最关键的，但每一个都导致了巨大的加速。这就是为什么我们能够在 CIFAR10 的最新技术上取得 30 倍的改进。我们对其他事情有一些想法——在这个 DAWN 基准完成之后，也许我们会尝试更进一步，看看是否可以在某一天打破一分钟。那将很有趣。

class DCGAN_D(nn.Module):def __init__(self, isize, nc, ndf, n_extra_layers=0):super().__init__()assert isize % 16 == 0, "isize has to be a multiple of 16"self.initial = ConvBlock(nc, ndf, 4, 2, bn=False)csize,cndf = isize/2,ndfself.extra = nn.Sequential(*[ConvBlock(cndf, cndf, 3, 1)for t in range(n_extra_layers)])pyr_layers = []while csize > 4:pyr_layers.append(ConvBlock(cndf, cndf*2, 4, 2))cndf *= 2; csize /= 2self.pyramid = nn.Sequential(*pyr_layers)self.final = nn.Conv2d(cndf, 1, 4, padding=0, bias=False)def forward(self, input):x = self.initial(input)x = self.extra(x)x = self.pyramid(x)return self.final(x).mean(0).view(1)

所以这是我们的鉴别器。关于架构需要记住的重要事情是它除了有一些输入张量大小和秩，以及一些输出张量大小和秩之外，什么也不做。正如你所看到的，最后一个卷积层只有一个通道。这与我们通常的做法不同，因为通常我们的最后一层是一个线性块。但我们这里的最后一层是一个卷积块。它只有一个通道，但它的网格大小大约是 4x4（不超过 4x4）。所以我们将输出（假设是 4x4），4x4x1 张量。然后我们计算平均值。所以它从 4x4x1 变成一个标量。这有点像最终的自适应平均池化，因为我们有一个通道，我们取平均值。这有点不同——通常我们首先进行平均池化，然后通过一个全连接层来得到我们的输出。但这里是得到一个通道，然后取平均值。Jeremy 怀疑如果我们按照正常方式做会更好，但他还没有尝试过，他也没有足够好的直觉来知道是否漏掉了什么——但如果有人想要尝试在自适应平均池化层和一个具有单个输出的全连接层之后添加一个，那将是一个有趣的实验。

这就是一个鉴别器。假设我们已经有了一个生成器——有人说“好的，这里有一个生成卧室的生成器。我希望你建立一个模型，可以找出哪些是真实的，哪些是假的”。我们将拿取数据集，并标记一堆来自生成器的假卧室图像，以及 LSUN 数据集中真实卧室的一堆图像，然后在每个图像上贴上 1 或 0。然后我们将尝试让鉴别器区分出差异。所以这将是足够简单的。但我们还没有得到一个生成器。我们需要建立一个。我们还没有讨论损失函数——我们将假设有一个损失函数可以做到这一点。

Paper / Notebook

我们将使用 cycle GAN 将马变成斑马。您也可以使用它将莫奈的印刷品转变为照片，或将优胜美地夏季的照片转变为冬季。

这将非常简单，因为它只是一个神经网络。我们要做的就是创建一个包含大量斑马照片的输入，并将每个照片与等价的马照片配对，然后训练一个从一个到另一个的神经网络。或者您可以对每幅莫奈的画做同样的事情——创建一个包含该地点照片的数据集……哦等等，这不可能，因为莫奈绘制的地方已经不存在了，也没有确切的斑马版本的马……这将如何运作？这似乎违背了我们对神经网络能做什么以及它们如何做的一切认知。

所以某种方式，这些伯克利的人创造了一个模型，可以将马变成斑马，尽管没有任何照片。除非他们出去画马并拍摄前后照片，但我相信他们没有。那么他们是如何做到的呢？这有点天才。

我知道目前正在进行最有趣的 cycle GAN 实践的人是我们的学生 Helena Sarin。她是我所知道的唯一一位 cycle GAN 艺术家。

以下是她更多令人惊叹的作品，我觉得非常有趣。我在这堂课开始时提到，GANs 属于尚未出现的东西，但它们几乎已经到位了。在这种情况下，世界上至少有一个人正在使用 GANs（具体来说是 cycle GANs）创作美丽而非凡的艺术作品。至少我知道有十几个人正在用神经网络进行有趣的创意工作。创意人工智能领域将会大幅扩展。

这是基本的技巧。这是来自 cycle GAN 论文。我们将有两幅图像（假设我们正在处理图像）。关键是它们不是配对的图像，所以我们没有一组马和等价斑马的数据集。我们有一堆马，一堆斑马。拿一匹马X，拿一匹斑马Y。我们将训练一个生成器（他们在这里称之为“映射函数”），将马变成斑马。我们将称之为映射函数G，并创建一个将斑马变成马的映射函数（也称为生成器），我们将称之为F。我们将创建一个鉴别器，就像以前一样，它将尽可能地识别真假马，我们将称之为Dx。另一个鉴别器，它将尽可能地识别真假斑马，我们将称之为Dy。这是我们的起点。

使这个工作的关键[1:51:27] - 所以我们在这里生成一个损失函数(Dx和Dy)。我们将创建一个叫做循环一致性损失的东西，它说当你用生成器将你的马变成斑马后，检查我是否能识别它是真实的。我们将我们的马变成斑马，然后尝试将那只斑马再变回我们开始的同一匹马。然后我们将有另一个函数，它将检查这匹马是否与原始马相似，这匹马是完全由这只斑马Y生成的，不知道x的任何信息。所以想法是，如果你生成的斑马看起来一点也不像原始马，你就没有机会将其变回原始马。因此，将x-hat与x进行比较的损失会非常糟糕，除非你能进入Y再出来，如果你能够创建一个看起来像原始马的斑马，那么你可能能够做到这一点。反之亦然 - 将你的斑马变成一个假马，检查你是否能识别它，然后尝试将其变回原始斑马并检查它是否看起来像原始的。

注意F（斑马到马）和G（马到斑马）正在做两件事。它们都将原始马变成斑马，然后将斑马再变回原始马。所以只有两个生成器。没有一个单独的生成器用于反向映射。你必须使用用于原始映射的相同生成器。这就是循环一致性损失。我认为这是天才。这种事情甚至可能存在的想法。老实说，当这一点出现时，我从未想过我甚至可以尝试解决这个问题。它似乎如此明显地不可能，然后你可以像这样解决它的想法 - 我只是觉得这太聪明了。

看这篇论文中的方程式是很好的，因为它们是很好的例子 - 它们写得相当简单，不像一些瓦瑟斯坦 GAN 论文那样，那些是很多理论证明和其他东西。在这种情况下，它们只是列出了正在发生的事情的方程式。你真的想要达到一个可以阅读并理解它们的程度。

所以我们有一匹马X和一只斑马Y。对于一些映射函数G，这是我们的马到斑马映射函数，然后有一个 GAN 损失，这是我们已经熟悉的一部分，它说我们有一匹马，一只斑马，一个假斑马识别器和一个马斑马生成器。损失就是我们之前看到的 - 我们能够从我们的斑马中画出一只斑马并识别它是真实的还是假的。然后拿一匹马变成一只斑马并识别它是真实的还是假的。然后做一减另一个（在这种情况下，它们里面有一个对数，但对数并不是非常重要）。这就是我们刚刚看到的东西。这就是为什么我们先做了瓦瑟斯坦 GAN。这只是一个标准的数学形式的 GAN 损失。

问题：所有这些听起来很像将一种语言翻译成另一种语言，然后再翻译回原来的语言。GANs 或任何等效物已经尝试过翻译吗？来自论坛的论文。回到我所知道的 — 通常在翻译中，你需要这种配对的输入（即平行文本 — “这是这个英语句子的法语翻译”）。最近有几篇论文显示了在没有配对数据的情况下创建高质量翻译模型的能力。我还没有实施它们，我不理解我没有实施的任何东西，但它们很可能在做同样的基本想法。我们将在本周内研究一下，并回复您。

循环一致性损失：所以我们有一个 GAN 损失，接下来是循环一致性损失。基本思想是我们从我们的马开始，使用我们的斑马生成器创建一匹斑马，然后使用我们的马生成器创建一匹马，并将其与原始马进行比较。这个双线与 1 是 L1 损失 — 差异的绝对值的和。否则，如果这是 2，那么它将是 L2 损失，即平方差的和。

我们现在知道这个波浪线的想法是从我们的马抓取一匹马。这就是我们所说的从分布中取样。有各种各样的分布，但在这些论文中，我们最常用的是经验分布，换句话说，我们有一些数据行，抓取一行。所以这里，它是说从数据中抓取一些东西，我们将称那个东西为x。为了重新概括：

1. 从我们的马图片中，抓取一匹马

2. 将其变成斑马

3. 将其转换回马

4. 将其与原始图像进行比较并求绝对值的和

5. 也对斑马进行同样的操作

6. 然后将两者相加

这就是我们的循环一致性损失。

完整目标

现在我们得到了我们的损失函数，整个损失函数取决于：

• 我们的马生成器

• 一个斑马生成器

• 我们的马识别器

• 我们的斑马识别器（又名鉴别器）

我们将加起来：

• 用于识别马的 GAN 损失

• 用于识别斑马的 GAN 损失

• 我们两个生成器的循环一致性损失

我们这里有一个 lambda，希望我们现在对这个想法有点习惯了，当你有两种不同的损失时，你可以加入一个参数，这样你可以将它们乘以一个相同的比例。我们在定位时也对我们的边界框损失与分类器损失做了类似的事情。

然后对于这个损失函数，我们将尝试最大化鉴别器的辨别能力，同时最小化生成器的辨别能力。因此，生成器和鉴别器将面对面地对抗。当你在论文中看到这个 min max 时，基本上意味着在你的训练循环中，一个东西试图让某事变得更好，另一个东西试图让某事变得更糟，有很多方法可以做到，但最常见的是你会在两者之间交替。你经常会在数学论文中看到这个被简称为 min-max。所以当你看到 min-max 时，你应该立即想到对抗训练。

笔记本

fastai 库的另一个非常酷的贡献是一个新的训练阶段 API。我将做一件我以前从未做过的事情，那就是我将展示别人的笔记本。之前我没有这样做的原因是因为我没有喜欢到足够好的笔记本，认为值得展示，但 Sylvain 在这里做得非常出色，不仅创建了这个新 API，还创建了一个描述它是什么以及如何工作等等的精美笔记本。背景是，正如大家所知，我们一直在努力更快地训练网络，部分原因是作为这个 Dawn bench 竞赛的一部分，还有一个下周您将了解的原因。我上周在论坛上提到，如果我们有一个更容易尝试不同的学习率调度等的方法，那对我们的实验将非常方便，我提出了我心目中的 API，如果有人能写出来那将非常酷，因为我现在要睡觉了，明天我有点需要它。Sylvain 在论坛上回复说，听起来是一个不错的挑战，24 小时后，它就完成了，而且效果非常酷。我想带您了解一下，因为它将使您能够研究以前没有人尝试过的东西。

这被称为 TrainPhase API，最简单的方法是展示它的示例。这是一个迭代学习率图表，你应该很熟悉。我们在学习率为 0.01 的情况下训练一段时间，然后在学习率为 0.001 的情况下训练一段时间。我实际上想创建一个非常类似于学习率图表的东西，因为大多数训练 ImageNet 的人都使用这种分阶段的方法，而这实际上并不是 fastai 内置的，因为我们通常不建议这样做。但为了复制现有的论文，我想以同样的方式做。因此，与其写一系列不同学习率的 fit、fit、fit 调用，不如能够说在这个学习率下训练 n 个周期，然后在那个学习率下训练 m 个周期。

这就是你如何做到的：

phases = [TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-2),   TrainingPhase(epochs=2, opt_fn=optim.SGD, lr = 1e-3)
]

一个阶段是一个具有特定优化器参数的训练期，phases由许多训练阶段对象组成。一个训练阶段对象说明要训练多少个周期，要使用什么优化函数，以及其他我们将看到的东西。在这里，你会看到你刚刚在那张图上看到的两个训练阶段。所以现在，不再调用learn.fit，而是说：

learn.fit_opt_sched(phases)

换句话说，learn.fit与一个具有这些阶段的优化器调度器。大多数传递的参数都可以像往常一样传递给 fit 函数，所以大多数通常的参数都可以正常工作。一般来说，我们只需使用这些训练阶段，你会看到它以一种通常的方式适应。然后当你说plot_lr时，你会看到上面的图表。它不仅绘制学习率，还绘制动量，并且对于每个阶段，它告诉你使用了什么优化器。你可以关闭优化器的打印（show_text=False），你可以关闭动量的打印（show_moms=False），你还可以做其他一些小事情，比如一个训练阶段可以有一个lr_decay参数：

phases = [TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-2), TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = (1e-2,1e-3), lr_decay=DecayType.LINEAR),TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-3)
]

这里有一个固定的学习率，然后是线性衰减的学习率，然后是放弃这个图像的固定学习率：

lr_i = start_lr + (end_lr - start_lr) * i/n

这可能是一个很好的训练方式，因为我们知道在高学习率下，你可以更好地探索，在低学习率下，你可以更好地微调。逐渐在两者之间滑动可能更好。所以我认为这实际上不是一个坏方法。

你可以使用其他衰减类型，比如余弦：

phases = [TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-2),    TrainingPhase(epochs=1, opt_fn=optim.SGD, lr =(1e-2,1e-3),lr_decay=DecayType.COSINE),           TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-3)
]

这可能更有意义，作为一个真正有用的学习率退火形状。

lr_i = end_lr + (start_lr - end_lr)/2 * (1 + np.cos(i * np.pi)/n)

指数，这是一个非常流行的方法：

lr_i = start_lr * (end_lr/start_lr)**(i/n)

多项式并不是非常流行，但实际上在文献中比其他任何方法都要好，但似乎已经被大多数人忽视了。所以多项式是值得注意的。Sylvain 已经为每个曲线给出了公式。因此，使用多项式，你可以选择使用哪个多项式。我相信 p 为 0.9 的多项式是我看到的效果非常好的一个 - FYI。

lr_i = end_lr + (start_lr - end_lr) * (1 - i/n) ** p

如果在 LR 衰减时不提供学习率的元组，那么它将一直衰减到零。如你所见，你可以愉快地从不同的点开始下一个周期。

phases = [TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-2), TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-2, lr_decay=DecayType.COSINE),TrainingPhase(epochs=1, opt_fn=optim.SGD, lr = 1e-3)
]

这是我们谈论最重要的部分，现在我们可以做所有这些事情，我们应该做什么，我们如何考虑？简而言之，我其实不知道。最近，你们中的许多人看到了 spaCy prodigy 公司的创始人在 Explosion AI 做了一个演讲，Matthew 和 Ines，之后我和他们一起吃饭，我们基本上整个晚上都在讨论，辩论，争论我们这样的公司正在构建可以以有害方式使用的工具，这意味着什么。他们是非常深思熟虑的人，我们，我不会说我们没有达成一致意见，我们只是无法得出结论。所以我只是列出一些问题，并指出一些研究，当我说研究时，实际上大部分文献综述和整理工作都是由 Rachel 完成的，所以谢谢 Rachel。

让我先说一下，我们构建的模型通常在某些方面相当糟糕，这些问题并不立即显现[36:52]。除非与你一起构建它们的人是各种各样的人，与你一起使用它们的人也是各种各样的人，否则你不会知道它们有多糟糕。例如，一对出色的研究人员，Timnit Gebru在微软工作，Joy Buolamwini刚从麻省理工学院获得博士学位，他们进行了一项非常有趣的研究，他们查看了一些现成的人脸识别器，其中包括来自 FACE++的一个，这是一家庞大的中国公司，IBM 的，以及微软的，他们寻找了一系列不同类型的人脸。

一般来说，微软的一个特别准确，除非人脸类型恰好是深色皮肤，突然间糟糕了 25 倍。IBM 几乎一半的时间都搞错了。对于这样一个大公司来说，发布一个对世界上大部分人来说都不起作用的产品，不仅仅是技术上的失败。这是对理解需要使用什么样的团队来创建这样的技术以及测试这样的技术，甚至对你的客户是谁的一种深刻失败。你的一些客户有深色皮肤。“我还要补充说，分类器在女性身上的表现都比在男性身上差”（Rachel）。令人震惊。有趣的是，Rachel 前几天在推特上发表了类似的言论，有人说“这是怎么回事？你在说什么？难道你不知道人们很长时间以来一直在制造汽车吗——你是在说你需要女性来制造汽车吗？”Rachel 指出——实际上是的。在汽车安全的大部分历史中，女性在汽车中的死亡风险远远高于男性，因为男性创造了看起来像男性、感觉像男性、尺寸像男性的碰撞测试假人，所以汽车安全实际上没有在女性身材上进行测试。产品管理糟糕，缺乏多样性和理解的失败在我们领域并不新鲜。

“我只是想说，这是在比较男性和女性的影响力”（Rachel）。我不知道为什么每当你在 Twitter 上说这样的话时，Rachel 都要这样说，因为每当你在 Twitter 上说这样的话时，大约有 10 个人会说“哦，你必须比较所有这些其他事情”，好像我们不知道一样。

像微软的人脸识别器或谷歌的语言翻译器这样的我们最好最著名的系统做的其他事情，你把“她是医生。他是护士。”翻译成土耳其语，非常正确——两个代词都变成了 O，因为土耳其语中没有性别代词。反过来，它会变成什么？“他是医生。她是护士。”所以我们在每天使用的工具中内置了这种偏见。而且，人们会说“哦，它只是展示了世界上的东西”，好吧，这个基本断言有很多问题，但正如你所知，机器学习算法喜欢概括。

因为他们喜欢概括，这是你们现在了解技术细节的一个很酷的事情，因为当你看到像 60%的照片中烹饪的人是女性，而他们用来构建这个模型的照片，然后你在另一组照片上运行模型时，84%被选择为烹饪的人是女性，而不是正确的 67%。这对于算法来说是一个非常可以理解的事情，因为它接受了有偏见的输入，并创造了一个更有偏见的输出，因为对于这个特定的损失函数来说，这就是它的结果。这是一种非常常见的模型放大。

这些事情很重要。它的重要性不仅仅体现在尴尬的翻译或黑人照片未被正确分类的方式上。也许也有一些胜利，比如到处可怕的监视，也许对黑人不起作用。“或者会更糟，因为这是可怕的监视，而且是彻头彻尾的种族主义和错误”（Rachel）。但让我们深入一点。尽管我们谈论人类的缺陷，但文明和社会有着长期的历史，创造了层层人类判断，希望避免最可怕的事情发生。有时候，热爱技术的公司会认为“让我们抛弃人类，用技术取代他们”，就像 Facebook 所做的那样。几年前，Facebook 真的摆脱了他们的人类编辑，当时这成为了新闻。他们被算法取代了。现在，当算法将所有内容放在你的新闻源上，而人类编辑却被排除在外时，接下来会发生什么？

接下来发生了很多事情。其中之一是缅甸发生了大规模的可怕种族灭绝。婴儿被从母亲怀里夺走，扔进火里。大规模的强奸、谋杀，整个民族被流放出境。

好吧，我不会说那是因为 Facebook 这样做的，但我要说的是，当这个可怕项目的领导接受采访时，他们经常谈论他们从 Facebook 学到的关于罗辛亚人恶劣动物行为的一切，这些行为需要被扫除。因为算法只是想要给你更多让你点击的东西。如果你被告知这些人不像你，你不认识这些坏人，这里有很多关于坏人的故事，然后你开始点击它们，然后他们会给你更多这些东西。接下来你会发现，你陷入了这个不寻常的循环。人们一直在研究这个问题，比如，我们被告知有几次人们点击我们的 fast.ai 视频，然后推荐给他们的下一个东西是来自 Alex Jones 的阴谋论视频，然后继续下去。因为人类点击那些让我们震惊、惊讶和恐惧的东西。在很多层面上，这个决定产生了不同寻常的后果，我们只是开始理解。再次强调，这并不是说这个特定的后果是因为这一个原因，但说它与此毫无关联显然是在忽视我们所拥有的所有证据和信息。

笔记本

arxiv.org/abs/1508.06576

这非常有趣——艺术风格。我们在这里有点复古，因为这实际上是最初的艺术风格论文，后来有很多更新和很多不同的方法，我实际上认为在很多方面最初的方法是最好的。我们也会看一些更新的方法，但我实际上认为最初的方法是一个很棒的方式，即使在之后的一切发展之后。让我们来看看代码。

%matplotlib inline
%reload_ext autoreload
%autoreload 2from fastai.conv_learner import *
from pathlib import Path
from scipy import ndimage
torch.cuda.set_device(3)torch.backends.cudnn.benchmark=TruePATH = Path('data/imagenet')
PATH_TRN = PATH/'train'm_vgg = to_gpu(vgg16(True)).eval()
set_trainable(m_vgg, False)

这里的想法是我们想要拍摄一只鸟的照片，并且我们想要创作一幅看起来像梵高画了这只鸟的画。顺便说一句，我正在做的很多事情都使用了 ImageNet。你不必为我所做的任何事情下载整个 ImageNet。在files.fast.ai/data中有一个 ImageNet 样本，它有几个 G 的数据，对我们正在做的一切来说应该足够了。如果你想要得到真正出色的结果，你可以获取 ImageNet。你可以从Kaggle下载。定位竞赛实际上包含了所有的分类数据。如果你有空间，最好拥有一份 ImageNet 的副本，因为它随时都会派上用场。

img_fn = PATH_TRN/'n01558993'/'n01558993_9684.JPEG'
img = open_image(img_fn)
plt.imshow(img);

所以我刚从我的 ImageNet 文件夹中拿出了这只鸟，这就是我的鸟：

sz=288trn_tfms,val_tfms = tfms_from_model(vgg16, sz)
img_tfm = val_tfms(img)
img_tfm.shape*(3, 288, 288)*opt_img = np.random.uniform(0, 1, size=img.shape).astype(np.float32)
plt.imshow(opt_img);

我要做的是从这张图片开始：

我将尝试让它越来越像梵高画的鸟的图片。我做的方法实际上非常简单。你们都很熟悉它。我们将创建一个损失函数，我们将称之为f。损失函数将以一张图片作为输入，并输出一个值。如果图像看起来更像梵高画的鸟照片，那么这个值将更低。编写了这个损失函数之后，我们将使用 PyTorch 的梯度和优化器。梯度乘以学习率，我们不会更新任何权重，而是会更新输入图像的像素，使其更像梵高画的鸟的图片。然后我们再次通过损失函数来获取更多的梯度，一遍又一遍地进行。就是这样。所以这与我们解决每个问题的方式是相同的。你们知道我是一个只会一招的人，对吧？这是我的唯一招数。创建一个损失函数，用它来获取一些梯度，乘以学习率来更新某些东西，以前我们总是更新模型中的权重，但今天我们不会这样做。我们将更新输入图像中的像素。但实际上并没有什么不同。我们只是针对输入而不是针对权重来获取梯度。就是这样。我们快要完成了。

让我们做更多的事情。让我们在这里提到，我们的损失函数将有两个额外的输入。一个是鸟的图片。第二个是梵高的一幅艺术作品。通过将它们作为输入，这意味着我们以后可以重新运行这个函数，使其看起来像梵高画的鸟，或者像莫奈画的鸟，或者像梵高画的大型喷气式飞机等。这些将是三个输入。最初，正如我们讨论过的，我们的输入是一些随机噪音。我们从一些随机噪音开始，使用损失函数，获取梯度，使其更像梵高画的鸟，依此类推。

所以我猜我们可以简要讨论的唯一未解决的问题是我们如何计算我们的图像看起来有多像梵高画的这只鸟。让我们将其分为两部分：

内容损失：返回一个值，如果看起来更像这只鸟（不只是任何鸟，而是我们要处理的特定鸟）。

风格损失：如果图像更像 V.G.的风格，则返回一个较低的数字。

有一种非常简单的计算内容损失的方法——我们可以查看输出的像素，将它们与鸟的像素进行比较，计算均方误差，然后相加。所以如果我们这样做，我运行了一段时间。最终我们的图像会变成一只鸟的图像。你应该尝试一下。你应该尝试这个作为练习。尝试使用 PyTorch 中的优化器，从一个随机图像开始，通过使用均方误差像素损失将其转变为另一幅图像。这并不是非常令人兴奋，但这将是第一步。

问题是，即使我们已经有了我们的风格损失函数运行得很好，然后假设我们要做的是将这两者相加，然后其中一个，我们将乘以一些λ来调整风格与内容的比例。假设我们有一个风格损失并选择了一些合理的λ，如果我们使用像素级的内容损失，那么任何使其看起来更像梵高而不是完全像照片、背景、对比度、光照等的东西都会增加内容损失——这不是我们想要的。我们希望它看起来像鸟，但不是以相同的方式。它仍然会有相同位置的两只眼睛，相同的形状等等，但不是相同的表示。所以我们要做的是，这可能会让您震惊，我们要使用一个神经网络！我们将使用 VGG 神经网络，因为那是我去年使用的，我没有时间看其他东西是否有效，所以您可以在这一周自己尝试。

VGG 网络是一个接受输入并将其通过多个层的网络，我将把这些层视为卷积层，显然还有 ReLU，如果是带有批量归一化的 VGG，那么它也有批量归一化。还有一些最大池化等等，但没关系。我们可以做的是，我们可以取其中一个卷积激活，而不是比较这只鸟的像素，我们可以比较这个（由 V.G.绘制的）鸟的 VGG 层 5 激活与我们原始鸟的 VGG 层 5 激活（或第 6 层，第 7 层等）。那么为什么这样更有趣呢？首先，它不会是同一只鸟。它不会完全相同，因为我们不是在检查像素。我们在检查一些后续的激活。那么这些后续的激活包含什么？假设它经过一些最大池化后，它包含一个较小的网格——所以它对事物的位置不那么具体。而不是包含像素颜色值，它们更像是语义的东西，比如这是一种眼球，这是一种毛茸茸的，这是一种明亮的，或者这是一种反射的，或者平放的，或者其他什么。因此，我们希望通过这些层有一定程度的语义特征，如果我们得到一个与这些激活匹配的图片，那么任何匹配这些激活的图片看起来像鸟，但不是相同的鸟的表示。这就是我们要做的。这就是我们的内容损失将是什么。人们通常称之为感知损失，因为在深度学习中，您总是为您做的每件明显的事情创造一个新名称。如果您将两个激活进行比较，您正在进行感知损失。就是这样。我们的内容损失将是感知损失。然后我们将稍后进行风格损失。

让我们从尝试创建一只最初是随机噪音的鸟开始，我们将使用感知损失来创建类似鸟的东西，但不是特定的鸟。我们将从 288x288 开始。因为我们只做一只鸟，所以不会出现 GPU 内存问题。我实际上很失望地意识到我选择了一个相当小的输入图像。尝试使用更大的图像创建一个真正宏伟的作品会很有趣。另一件事要记住的是，如果您要将其投入生产，可以一次处理整个批次。有时人们会抱怨这种方法（Gatys 是主要作者）——Gatys 的风格迁移方法很慢，但我不同意它很慢。只需要几秒钟，您就可以在几秒钟内处理整个批次。

sz=288

所以我们将按照通常的做法将其通过 VGG16 模型的一些转换。记住，转换类有 dunder call 方法（__call__），所以我们可以将其视为一个函数。如果你将一个图像传递给它，那么我们将得到转换后的图像。尽量不要将 fast.ai 和 PyTorch 基础设施视为黑盒，因为它们都设计成非常易于以解耦的方式使用。所以这个转换只是“可调用”的想法（即用括号括起来的东西）来自于 PyTorch，我们完全抄袭了这个想法。所以在 torch.vision 或 fast.ai 中，你的转换只是可调用的。整个转换流水线只是一个可调用的。

trn_tfms,val_tfms = tfms_from_model(vgg16, sz)
img_tfm = val_tfms(img)
img_tfm.shape
'''
(3, 288, 288)
'''

现在我们有了一个 3x288x288 的东西，因为 PyTorch 喜欢通道在前面。正如你所看到的，它已经被转化为一个方形，被归一化为（0,1），所有这些正常的东西。

现在我们正在创建一个随机图像。

opt_img = np.random.uniform(0, 1, size=img.shape).astype(np.float32)
plt.imshow(opt_img);

这是我发现的一件事。试图将这个转化为任何东西的图片实际上非常困难。我发现实际上很难让优化器获得合理的梯度，使其有所作为。就在我以为我要在这门课上耗尽时间并真正让自己尴尬的时候，我意识到关键问题是图片不是这样的。它们更加平滑，所以我稍微模糊了一下，将其转化为以下内容：

opt_img = scipy.ndimage.filters.median_filter(opt_img, [8,8,1])
plt.imshow(opt_img);

我使用了一个中值滤波器——基本上就像一个中值池化。一旦我将其改为这样，它立即开始训练得非常好。你必须做一些微小的调整才能让这些东西工作起来，这有点疯狂，但这里有一个小调整。

所以我们从一个随机图像开始，这个图像至少有一定的平滑度。我发现我的鸟类图像的像素均值大约是这个值的一半，所以我将其除以 2，只是试图让匹配变得更容易一些（我不知道这是否重要）。将其转化为一个变量，因为这个图像，记住，我们将使用优化算法修改这些像素，所以任何涉及损失函数的东西都需要是一个变量。并且，它需要梯度，因为我们实际上是在更新图像。

opt_img = val_tfms(opt_img)/2
opt_img_v = V(opt_img[None], requires_grad=True)
opt_img_v.shape*torch.Size([1, 3, 288, 288])*

所以现在我们有了一个大小为 1 的小批量，3 个通道，288x288 的随机噪声。

m_vgg = nn.Sequential(*children(m_vgg)[:37])

我们将使用，没有特定原因，VGG 的第 37 层。如果你打印出 VGG 网络（你只需输入m_vgg并打印出来），你会看到这是中后期的层。所以我们可以只获取前 37 层并将其转化为一个顺序模型。现在我们有了一个 VGG 的子集，它将输出一些中间层的激活，这就是模型将要做的事情。所以我们可以拿到我们实际的鸟类图像，我们想创建一个大小为一的小批量。记住，如果你在 Numpy 中使用None进行切片，也就是np.newaxis，它会在那个点引入一个新的单位轴。这里，我想创建一个大小为 1 的轴，表示这是一个大小为一的小批量。所以就像我在这里做的一样（opt_img_v = V(opt_img[**None**], requires_grad=**True**)）使用None进行切片，在前面得到一个单位轴。然后我们将其转化为一个变量，这个变量不需要更新，所以我们使用VV来表示你不需要为这个变量计算梯度。这将给我们我们的目标激活。

• 我们已经拿到了我们的鸟类图像。

• 将其转化为一个变量

• 将其通过我们的模型传递，以获取第 37 层的激活，这是我们的目标。我们希望我们的内容损失是这组激活。

• 我们将创建一个优化器（我们稍后会回到这个细节）

• 我们将进行多次迭代

• 梯度清零

• 调用一些损失函数

• 损失反向传播()

这就是高层次的版本。我一会儿会回到细节，但关键是我们传入那个随机生成的图像的损失函数——优化图像的变量。因此，我们将该图像传递给我们的损失函数，它将使用损失函数进行更新，而损失函数是通过将我们当前的优化图像通过我们的 VGG 获取中间激活，并将其与目标激活进行比较来计算均方误差损失。我们运行一堆次数，然后将其打印出来。我们有我们的鸟，但没有它的表示形式。

targ_t = m_vgg(VV(img_tfm[None]))
targ_v = V(targ_t)
targ_t.shape
'''
torch.Size([1, 512, 18, 18])
'''
max_iter = 1000
show_iter = 100
optimizer = optim.LBFGS([opt_img_v], lr=0.5)

这是几乎没有人知道的事情之一，因此几乎在互联网上找到的任何实现风格转移的代码都会有各种可怕的黑客，而不是使用前向钩子。但前向钩子真的很容易。

要创建一个前向钩子，只需创建一个类。该类必须有一个名为hook_fn的东西。您的钩子函数将接收您挂钩的module，前向传递的input和output，然后您可以做任何您喜欢的事情。所以我要做的就是将这个模块的输出存储在某个属性中。就是这样。所以hook_fn实际上可以被称为您喜欢的任何东西，但“hook function”似乎是标准，因为您可以看到，在构造函数中发生的是我在某个属性中存储了m.register_forward_hook的结果（m将是我要挂钩的层），并传入您希望在调用模块的前向方法时调用的函数。当调用其前向方法时，它将调用self.hook_fn，该函数将在名为features的属性中存储输出。

class SaveFeatures():features=Nonedef __init__(self, m): self.hook = m.register_forward_hook(self.hook_fn)def hook_fn(self, module, input, output): self.features = outputdef close(self): self.hook.remove()

现在我们可以像以前一样创建一个 VGG。让我们将其设置为不可训练，这样我们就不会浪费时间和内存来计算梯度。让我们遍历并找到所有的最大池层。让我们遍历这个模块的所有子层，如果是一个最大池层，让我们输出索引减 1——这样就会给我最大池之前的层。通常，最大池或步长 2 卷积之前的层是一个非常完整的表示，因为下一层正在改变网格。所以这对我来说是一个很好的地方来获取内容损失。我们在该网格大小上拥有的最语义化、最有趣的内容。这就是为什么我要选择这些索引。

m_vgg = to_gpu(vgg16(True)).eval()
set_trainable(m_vgg, False)

这些是 VGG 中每个最大池之前的最后一层的索引[1:32:30]。

block_ends = [i-1 for i,o in enumerate(children(m_vgg))if isinstance(o,nn.MaxPool2d)
]
block_ends
'''
[5, 12, 22, 32, 42]
'''

我要获取32——没有特定的原因，只是尝试其他东西。所以我要说block_ends[3]（即 32）。children(m_vgg)[block_ends[3]]会给我 VGG 的第 32 层作为一个模块。

sf = SaveFeatures(children(m_vgg)[block_ends[3]])

然后，如果我调用SaveFeatures构造函数，它会执行：

self.hook = {VGG 的第 32 层}.register_forward_hook(self.hook_fn)

现在，每当我对这个 VGG 模型进行前向传递时，它都会将第 32 层的输出存储在sf.features中。

def get_opt():opt_img = np.random.uniform(0, 1, size=img.shape).astype(np.float32)opt_img = scipy.ndimage.filters.median_filter(opt_img, [8,8,1])opt_img_v = V(val_tfms(opt_img/2)[None], requires_grad=True)return opt_img_v, optim.LBFGS([opt_img_v])
opt_img_v, optimizer = get_opt()

在这里[1:33:33]，我调用了我的 VGG 网络，但我没有将其存储在任何地方。我没有说activations = m_vgg(VV(img_tfm[**None**]))。我调用它，丢弃答案，然后抓取我们在SaveFeatures对象中存储的特征。

m_vgg() — 这是在 PyTorch 中进行前向路径的方法。你不会说 m_vgg.forward()，你只是将其用作可调用。在 nn.module 上使用可调用会自动调用 forward。这就是 PyTorch 模块的工作方式。

所以我们称之为可调用的，最终调用我们的前向钩子，前向钩子将激活存储在 sf.features 中，所以现在我们有了我们的目标变量 — 就像以前一样，但以一种更加灵活的方式。

get_opt 包含了我们之前的相同的 4 行代码[1:34:34]。它只是给我一个要优化的随机图像和一个优化器来优化该图像。

m_vgg(VV(img_tfm[None]))
targ_v = V(sf.features.clone())
targ_v.shape
'''
torch.Size([1, 512, 36, 36])
'''
def actn_loss2(x):m_vgg(x)out = V(sf.features)return F.mse_loss(out, targ_v)*1000

现在我可以继续做完全相同的事情。但现在我将使用不同的损失函数 actn_loss2（激活损失 #2），它不会说 out=m_vgg，再次，它调用 m_vgg 进行前向传递，丢弃结果，并获取 sf.features。所以现在这是我的第 32 层激活，然后我可以在其上执行均方误差损失。你可能已经注意到，最后一个损失函数和这个都乘以了一千。为什么它们乘以一千？这就像所有试图使这个课程不正确的事情。我以前没有使用一千，它就无法训练。今天午餐时间，什么都不起作用。经过几天的尝试让这个东西工作，最终偶然注意到“天哪，损失函数的数字真的很低（如 10E-7）”，我想如果它们不那么低会怎样。所以我将它们乘以一千，然后它开始工作了。那为什么它不起作用呢？因为我们正在使用单精度浮点数，而单精度浮点数并不那么精确。特别是当你得到的梯度有点小，然后你乘以学习率可能也很小，最终得到一个很小的数字。如果它太小，它们可能会被四舍五入为零，这就是发生的事情，我的模型还没有准备好。我相信有比乘以一千更好的方法，但无论如何。它运行得很好。无论你将损失函数乘以多少，因为你关心的只是它的方向和相对大小。有趣的是，这与我们在训练 ImageNet 时所做的事情类似。我们使用了半精度浮点数，因为 Volta 张量核要求如此。如果你想要训练半精度浮点数，实际上你必须将损失函数乘以一个缩放因子。我们使用了 1024 或 512。我认为 fast.ai 现在是第一个具有所有必要技巧以在半精度浮点数中进行训练的库，因此如果你有幸拥有 Volta 或者你可以支付 AWS P3，如果你有一个学习对象，你只需说 learn.half，它现在就会神奇地正确地训练半精度浮点数。它也内置在模型数据对象中，一切都是自动的。我相信没有其他库能做到这一点。

n_iter=0
while n_iter <= max_iter: optimizer.step(partial(step,actn_loss2))
'''
Iteration: n_iter, loss: 0.2112911492586136
Iteration: n_iter, loss: 0.0902421623468399
Iteration: n_iter, loss: 0.05904778465628624
Iteration: n_iter, loss: 0.04517251253128052
Iteration: n_iter, loss: 0.03721420466899872
Iteration: n_iter, loss: 0.03215853497385979
Iteration: n_iter, loss: 0.028526008129119873
Iteration: n_iter, loss: 0.025799645110964775
Iteration: n_iter, loss: 0.02361033484339714
Iteration: n_iter, loss: 0.021835438907146454
'''

这只是在稍早的层上做同样的事情[1:37:35]。这只是让鸟看起来更像鸟。希望你能理解，较早的层越接近像素。有更多的网格单元，每个单元更小，更小的感受野，更简单的语义特征。所以我们越早得到，它看起来就越像一只鸟。

x = val_tfms.denorm(np.rollaxis(to_np(opt_img_v.data),1,4))[0]
plt.figure(figsize=(7,7))
plt.imshow(x);

sf.close()

事实上，这篇论文有一张很好的图片展示了各种不同的层，并放大到这座房子[1:38:17]。他们试图让这座房子看起来像《星夜》的图片。你可以看到后来，它变得非常混乱，而之前看起来像这座房子。所以这只是在做我们刚刚做的事情。我在我们的学习小组中注意到的一件事是，每当我告诉某人回答一个问题，每当我说去读这篇论文中有一些东西告诉你问题的答案时，总会有一种震惊的表情“读这篇论文？我？”但是说真的，论文已经做了这些实验并绘制了这些图片。论文中有很多东西。这并不意味着你必须读完论文的每一部分。但至少看看图片。所以看看 Gatys 的论文，里面有很好的图片。所以他们已经为我们做了实验，但看起来他们没有深入研究 — 他们只是得到了一些早期的结果。

我们接下来需要做的是创建风格损失。我们已经有了损失，即它有多像鸟。现在我们需要知道它有多像这幅绘画的风格。我们将做几乎相同的事情。我们将获取某一层的激活。现在问题是，某一层的激活，假设它是一个 5x5 的层（当然没有 5x5 的层，它是 224x224，但我们假装）。这里是一些激活，我们可以获取这些激活，无论是针对我们正在优化的图像还是我们的梵高绘画。让我们看看我们的梵高绘画。这就是它 —《星夜》

style_fn = PATH/'style'/'starry_night.jpg'
style_img = open_image(style_fn)
style_img.shape, img.shape
'''
((1198, 1513, 3), (291, 483, 3))
'''
plt.imshow(style_img);

我从维基百科下载了这幅图像，我想知道为什么加载如此缓慢[1:40:39] — 结果，我下载的维基百科版本是 30,000 x 30,000 像素。他们有这种严肃的画廊品质存档真的很酷。我不知道这个存在。不要试图在上面运行神经网络。完全毁了我的 Jupyter 笔记本。

所以我们可以为我们的梵高图像做到这一点，也可以为我们的优化图像做到这一点。然后我们可以比较这两者，最终我们会创建一幅内容类似于绘画但并非绘画的图像 — 这不是我们想要的。我们想要的是具有相同风格但不是绘画且没有内容的东西。所以我们想要丢弃所有的空间信息。我们不想要创造出一个这里有月亮，这里有星星，这里有教堂的东西。我们不想要任何这些。那么我们如何丢弃所有的特殊信息呢？

在这种情况下，这里有 19 个面 - 19 个切片。所以让我们拿到这个顶部切片，这将是一个 5x5 矩阵。现在，让我们展平它，我们得到一个 25 个元素的长向量。一下子，我们通过展平抛弃了大部分空间信息。现在让我们拿到第二个切片（即另一个通道）并做同样的事情。所以我们有通道 1 展平和通道 2 展平，它们都有 25 个元素。现在，让我们进行点积，我们可以在 Numpy 中用 @ 来做（注：这里是 Jeremy 对我的点积与矩阵乘法问题的回答）。点积将给我们一个数字。那个数字是什么？它告诉我们什么？假设激活在 VGG 网络的中间层附近，我们可能期望其中一些激活是笔触纹理有多强，一些是这个区域有多明亮，一些是这部分是房子的一部分还是圆形的一部分，或者其他部分是这幅画的哪部分有多暗。所以点积基本上是一个相关性。如果这个元素和这个元素都非常正或都非常负，它会给我们一个大结果。另外，如果它们相反，它会给一个小结果。如果它们都接近零，它不会给结果。所以基本上点积是衡量这两个东西有多相似的一个指标。所以如果通道 1 和通道 2 的激活相似，那么它基本上是在说 - 让我们举个例子[1:44:28]。比如第一个是笔触纹理有多强（C1），而另一个是笔触有多倾斜（C2）。

如果细胞（1,1）的 C1 和 C2 同时高，细胞（4,2）也是如此，那么它表明具有纹理的网格单元也倾向于具有对角线。因此，当具有纹理的网格单元也具有对角线时，点积会很高，当它们没有时，点积也不高。所以这就是 C1 @ C2。另外，C1 @ C1 实际上是 2-范数（即 C1 的平方和）。这基本上是在说纹理通道中有多少网格单元是活跃的，以及它们有多活跃。换句话说，C1 @ C1 告诉我们纹理绘画进行了多少。而 C2 @ C2 告诉我们对角线绘画进行了多少。也许 C3 是“颜色是否明亮？”，所以 C3 @ C3 将告诉我们明亮颜色单元有多频繁。

那么我们可以创建一个包含每个点积的 19x19 矩阵[1:47:17]。就像我们讨论过的，数学家们必须给每样东西起个名字，所以这个特定的矩阵，将其展平然后进行所有点积的操作，被称为 Gram 矩阵。

我告诉你一个秘密[1:48:29]。大多数深度学习从业者要么不知道，要么不记得所有这些东西，比如如果他们曾经在大学学过 Gram 矩阵。他们可能忘记了，因为之后他们可能熬夜了。实际上的工作方式是你意识到“哦，我可以创建一个非空间表示，展示通道之间的相关性”，然后当我写论文时，我不得不去问周围的人，“这个东西有个名字吗？” 然后有人会说“这不就是 Gram 矩阵吗？” 你去查一下，确实是。所以不要认为你必须先学习所有的数学。先运用你的直觉和常识，然后再担心数学叫什么，通常是这样。有时候也会反过来，不过不是对我，因为我不擅长数学。

所以这被称为 Gram 矩阵。当然，如果你是一个真正的数学家，非常重要的是你要说得好像你一直知道这是一个 Gram 矩阵，然后你就会说，哦是的，我们只是计算 Gram 矩阵。所以 Gram 矩阵就是这种映射——对角线可能是最有趣的部分。对角线显示哪些通道最活跃，然后非对角线显示哪些通道倾向于一起出现。总的来说，如果两幅图片有相同的风格，那么我们期望某些激活层会有相似的 Gram 矩阵。因为如果我们找到了捕捉很多关于画笔笔触和颜色的东西的激活层，那么仅仅对角线（在 Gram 矩阵中）可能就足够了。这是另一个有趣的作业，如果有人想尝试的话，可以尝试使用 Gatys 的风格迁移，而不是使用 Gram 矩阵，而是只使用 Gram 矩阵的对角线。这只需要改变一行代码。但我还没有看到有人尝试过，也不知道它是否会起作用，但它可能会很好。

“好的，是的，克里斯汀，你已经尝试过了。”“我已经尝试过了，大多数时候都有效，除非你有需要两种风格出现在同一个地方的有趣图片。所以看起来像是一半是草，一半是人群，你需要这两种风格。”（克里斯汀）。很酷，你仍然会做你的作业，但克里斯汀说她会替你做。

def scale_match(src, targ):h,w,_ = img.shapesh,sw,_ = style_img.shaperat = max(h/sh,w/sw); ratres = cv2.resize(style_img, (int(sw*rat), int(sh*rat)))return res[:h,:w]
style = scale_match(img, style_img)
plt.imshow(style)
style.shape, img.shape
'''
((291, 483, 3), (291, 483, 3))
'''

这是我们的绘画。我尝试调整绘画的大小，使其与我的鸟类图片大小相同。所以这就是所有这些在做的事情。不管我使用哪一部分，只要它有很多漂亮的风格就可以了。

我像以前一样获取了我的优化器和随机图像：

opt_img_v, optimizer = get_opt()

这一次，我为所有的block_ends调用SaveFeatures，这将给我一个 SaveFeatures 对象的数组——每个模块都会出现在最大池化之前的层中。因为这一次，我想玩弄不同的激活层风格，更具体地说，我想让你来玩。所以现在我有了一个完整的数组。

sfs = [SaveFeatures(children(m_vgg)[idx]) for idx in block_ends]

style_img是我的梵高的绘画。所以我拿我的style_img，通过我的转换来创建我的转换风格图像（style_tfm）。

style_tfm = val_tfms(style_img)

将其转换为一个变量，通过我的 VGG 模块的前向传播，现在我可以遍历所有的 SaveFeatures 对象并获取每组特征。请注意，我调用clone，因为以后，如果我再次调用我的 VGG 对象，它将替换这些内容。我还没有想过这是否有必要。如果你把它拿走了，那没关系。但我只是小心翼翼。现在这是每个block_end层的激活的数组。在这里，你可以看到所有这些形状：

m_vgg(VV(style_tfm[None]))
targ_styles = [V(o.features.clone()) for o in sfs]
[o.shape for o in targ_styles]
'''
[torch.Size([1, 64, 288, 288]),torch.Size([1, 128, 144, 144]),torch.Size([1, 256, 72, 72]),torch.Size([1, 512, 36, 36]),torch.Size([1, 512, 18, 18])]
'''

你可以看到，能够快速地编写一个列表推导式在你的 Jupyter 玩耍中非常重要。因为你真的希望能够立即看到这是我的通道（64、128、256，…），以及我们期望的网格大小减半（288、144、72…），因为所有这些都出现在最大池化之前。

因此，要进行 Gram MSE 损失，它将是输入的 Gram 矩阵与目标的 Gram 矩阵的 MSE 损失。Gram 矩阵只是x与x转置(x.t())的矩阵乘积，其中 x 简单地等于我已经将批处理和通道轴全部展平的输入。我只有一个图像，所以可以忽略批处理部分——基本上是通道。然后其他所有部分(-1)，在这种情况下是高度和宽度，是另一个维度，因为现在将是通道乘以高度和宽度，然后正如我们讨论过的，我们可以将其与其转置进行矩阵乘积。为了归一化，我们将其除以元素的数量(b*c*h*w)——如果我说input.numel（元素的数量）会更优雅，这将是相同的事情。再次，这给我了很小的数字，所以我乘以一个大数字使其变得更合理。所以这基本上就是我的损失。

def gram(input):b,c,h,w = input.size()x = input.view(b*c, -1)return torch.mm(x, x.t())/input.numel()*1e6def gram_mse_loss(input, target): return F.mse_loss(gram(input), gram(target))

现在我的风格损失是将我的图像优化，通过 VGG 前向传递，获取所有 SaveFeatures 对象中特征的数组，然后在每一层上调用我的 Gram MSE 损失。这将给我一个数组，然后我只需将它们相加。现在你可以用不同的权重将它们相加，你可以添加子集，或者其他。在这种情况下，我只是获取了所有的。

def style_loss(x):m_vgg(opt_img_v)outs = [V(o.features) for o in sfs]losses = [gram_mse_loss(o, s) for o,s in zip(outs, targ_styles)]return sum(losses) 

像以前一样将其传递给我的优化器：

n_iter=0
while n_iter <= max_iter: optimizer.step(partial(step,style_loss))
'''
Iteration: n_iter, loss: 230718.453125
Iteration: n_iter, loss: 219493.21875
Iteration: n_iter, loss: 202618.109375
Iteration: n_iter, loss: 481.5616760253906
Iteration: n_iter, loss: 147.41177368164062
Iteration: n_iter, loss: 80.62625122070312
Iteration: n_iter, loss: 49.52326965332031
Iteration: n_iter, loss: 32.36254119873047
Iteration: n_iter, loss: 21.831811904907227
Iteration: n_iter, loss: 15.61091423034668
'''

这里有一张随机图像，风格类似于梵高，我觉得挺酷的。

x = val_tfms.denorm(np.rollaxis(to_np(opt_img_v.data),1,4))[0]
plt.figure(figsize=(7,7))
plt.imshow(x);

再次，Gatys 已经为我们做好了。这里是不同层次的随机图像，风格类似于梵高。所以第一个，你可以看到，激活是简单的几何图形——一点也不有趣。后面的层次更有趣。所以我们有一种怀疑，我们可能想要主要使用后面的层次来进行风格损失，如果我们想要看起来好的话。

我添加了这个SaveFeatures.close，它只是调用self.hook.remove()。记住，我将 hook 存储为self.hook，所以hook.remove()会将其删除。最好将其删除，否则可能会一直使用内存。因此，在最后，我只需遍历每个 SaveFeatures 对象并关闭它：

for sf in sfs: sf.close()