深度学习 2：第 2 部分第 12 课

原文：medium.com/@hiromi_suenaga/deep-learning-2-part-2-lesson-12-215dfbf04a94

译者：飞龙

协议：CC BY-NC-SA 4.0

来自 fast.ai 课程的个人笔记。随着我继续复习课程以“真正”理解它，这些笔记将继续更新和改进。非常感谢 Jeremy 和Rachel 给了我这个学习的机会。

生成对抗网络（GANs）

视频 / 论坛

非常炙手可热的技术，但绝对值得成为课程中前沿深度学习部分的一部分，因为它们并不完全被证明对任何事情都有用，但它们几乎到了那个地步，肯定会成功。我们将专注于那些在实践中肯定会有用的事情，有许多领域可能会被证明有用，但我们还不知道。所以我认为它们在实践中肯定会有用的领域是你在幻灯片左侧看到的那种东西 —— 例如将绘画转化为渲染图片。这来自于两天前刚刚发布的一篇论文，所以目前正在进行非常活跃的研究。

从上一堂课 [1:04]： 我们的多样性研究员 Christine Payne 拥有斯坦福大学的医学硕士学位，因此她对构建医学语言模型感兴趣。我们在第四课中简要提到过的一件事，但上次并没有详细讨论的是，你实际上可以种子一个生成式语言模型，这意味着你已经在某个语料库上训练了一个语言模型，然后你将从该语言模型生成一些文本。你可以通过输入一些词来开始，告诉它“这是用来创建语言模型中隐藏状态的前几个词，请从这里生成”。Christine 做了一些聪明的事情，她用一个问题作为种子，重复这个问题三次，然后让它从那里生成。她向语言模型输入了许多不同的医学文本，并输入了下面看到的问题：

Jeremy 发现这个有趣的地方是，对于没有医学硕士学位的人来说，这几乎是一个可信的答案。但它与现实完全没有关系。他认为这是一种有趣的伦理和用户体验困境。Jeremy 参与了一个名为 doc.ai 的公司，该公司试图做很多事情，但最终提供一个应用程序供医生和患者使用，可以帮助他们解决医疗问题。他一直在对团队中的软件工程师说，请不要尝试使用 LSTM 或其他东西创建生成模型，因为它们会擅长创造听起来令人印象深刻但实际上是错误建议的东西 —— 就像政治评论员或终身教授可以以极大的权威说废话一样。所以他认为这是一个非常有趣的实验。如果你做了一些有趣的实验，请在论坛、博客、Twitter 上分享。让人们知道并受到了了不起的人的关注。

CIFAR10 [5:26]

cifar10-darknet.ipynb [7:17]

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

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

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

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 *= 2
        layers += [
            nn.AdaptiveAvgPool2d(1), 
            Flatten(), 
            nn.Linear(nf, num_classes)
        ]
        self.layers = nn.Sequential(*layers)

    def forward(self, x): 
        return self.layers(x)

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

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

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

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)
)

生成对抗网络（GAN）[48:49]

查看代码[54:52]

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

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

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

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')

class ConvBlock(nn.Module):
    def __init__(self, ni, no, ks, stride, bn=True, pad=None):
        super().__init__()
        if pad is None: 
            pad = ks//2//stride
        self.conv = nn.Conv2d(
            ni, no, 
            ks, stride, 
            padding=pad, 
            bias=False
        )
        self.bn = nn.BatchNorm2d(no) if bn else None
        self.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

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,ndf
        self.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 /= 2
        self.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)

生成器

生成器也是一种架构，本身不会做任何事情，直到我们有损失函数和数据。但张量的秩和大小是什么？生成器的输入将是一个随机数向量。在论文中，他们称之为“先验”。有多大？我们不知道。这个想法是不同的一堆随机数将生成一个不同的卧室。因此，我们的生成器必须将一个向量作为输入，通过顺序模型，将其转换为一个秩为 4 的张量（没有批量维度的秩为 3）-高度乘以宽度乘以 3。因此，在最后一步，nc（通道数）最终将变为 3，因为它将创建一个大小为 3 的通道图像。

class DeconvBlock(nn.Module):
    def __init__(self, ni, no, ks, stride, pad, bn=True):
        super().__init__()
        self.conv = nn.ConvTranspose2d(
            ni, no, 
            ks, stride, 
            padding=pad, bias=False
        )
        self.bn = nn.BatchNorm2d(no)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.relu(self.conv(x))
        return self.bn(x) if self.bn else x
class DCGAN_G(nn.Module):
    def __init__(self, isize, nz, nc, ngf, n_extra_layers=0):
        super().__init__()
        assert isize % 16 == 0, "isize has to be a multiple of 16"

        cngf, tisize = ngf//2, 4
        while tisize!=isize: 
            cngf*=2; tisize*=2
        layers = [DeconvBlock(nz, cngf, 4, 1, 0)]

        csize, cndf = 4, cngf
        while csize < isize//2:
            layers.append(DeconvBlock(cngf, cngf//2, 4, 2, 1))
            cngf //= 2; csize *= 2

        layers += [
            DeconvBlock(cngf, cngf, 3, 1, 1) 
            for t in range(n_extra_layers)
        ]
        layers.append(nn.ConvTranspose2d(cngf, nc, 4, 2, 1, bias=False))
        self.features = nn.Sequential(*layers)

    def forward(self, input): 
        return F.tanh(self.features(input))

问题：在 ConvBlock 中，为什么批量归一化在 ReLU 之后（即self.bn(self.relu(...))）？我通常期望先进行 ReLU，然后批量归一化，这实际上是 Jeremy 认为有意义的顺序。我们在 darknet 中使用的顺序是 darknet 论文中使用的顺序，所以每个人似乎对这些事情有不同的顺序。事实上，大多数人对 CIFAR10 有一个不同的顺序，即批量归一化→ReLU→卷积，这是一种奇特的思考方式，但事实证明，对于残差块来说，这通常效果更好。这被称为“预激活 ResNet”。有一些博客文章中，人们已经尝试了不同顺序的事物，似乎这很大程度上取决于特定数据集以及您正在处理的内容，尽管性能差异很小，除非是为了比赛，否则您不会在意。

反卷积

因此，生成器需要从一个向量开始，最终得到一个秩为 3 的张量。我们还不知道如何做到这一点。我们需要使用一种称为“反卷积”的东西，PyTorch 称之为转置卷积-相同的东西，不同的名称。反卷积是一种增加网格大小而不是减小网格大小的东西。因此，像所有事物一样，在 Excel 电子表格中最容易看到。

这是一个卷积。我们开始，假设有一个单通道的 4x4 网格单元。让我们通过一个单输出滤波器的 3x3 核心。所以我们有一个输入通道，一个滤波器核心，如果我们不添加任何填充，最终会得到 2x2。记住，卷积只是核心和适当网格单元的乘积的总和。所以这是我们标准的 3x3 卷积一个通道一个滤波器。

现在的想法是我们想要朝相反的方向发展。我们想要从我们的 2x2 开始，我们想要创建一个 4x4。具体来说，我们想要创建与我们开始的相同的 4x4。我们想通过使用卷积来实现这一点。我们如何做到这一点？

如果我们有一个 3x3 卷积，那么如果我们想要创建一个 4x4 输出，我们将需要创建这么多填充：

因为有这么多填充，我们最终会得到 4x4。所以假设我们的卷积滤波器只是一堆零，那么我们可以通过进行这个减法来计算每个单元格的错误：

然后我们可以通过对这些错误的绝对值求和来获得绝对值之和（L1 损失）：

现在我们可以使用优化，在 Excel 中称为“求解器”来进行梯度下降。所以我们将设置总单元格等于最小值，然后尝试通过改变我们的滤波器来减少我们的损失。你可以看到它提出了一个滤波器，使得结果几乎像数据一样。它并不完美，一般来说，你不能假设反卷积可以完全创建出你想要的完全相同的东西，因为这里没有足够的。因为滤波器中有 9 个东西，结果中有 16 个东西。但它做出了一个相当不错的尝试。所以这就是反卷积的样子 - 在一个 2x2 的网格单元上进行步长为 1 的 3x3 反卷积。

问题: 创建一个鉴别器来识别假新闻和真实新闻有多难？你不需要任何特殊的东西 - 那只是一个分类器。所以你可以使用之前课程和第 4 课的 NLP 分类器。在这种情况下，没有生成部分，所以你只需要一个数据集，其中说这些是我们认为是假新闻的东西，这些是我们认为是真实新闻的东西，它应该工作得非常好。据我们所知，如果你尝试，你应该得到和其他人一样好的结果 - 它是否足够实用，Jeremy 不知道。在这个阶段，你能做的最好的事情可能是生成一种分类，说这些东西看起来相当可疑，基于它们的写作方式，然后一些人可以去核实它们。NLP 分类器和 RNN 不能核实事实，但它可以识别这些是以那种高度通俗的风格写成的，通常假新闻就是这样写的，所以也许这些值得关注。这可能是你在不依赖某种外部数据源的情况下所能希望的最好的结果。但重要的是要记住，鉴别器基本上只是一个分类器，你不需要任何特殊的技术，超出我们已经学会的 NLP 分类的范围。

ConvTranspose2d

在 PyTorch 中进行反卷积，只需说：

nn.ConvTranspose2d(ni, no, ks, stride, padding=pad, bias=False)

• ni: 输入通道的数量

• no: 输出通道的数量

• ks: 卷积核大小

它被称为 ConvTranspose 的原因是因为事实证明这与卷积的梯度计算是相同的。这就是为什么他们这样称呼它。

可视化

deeplearning.net/software/theano/tutorial/conv_arithmetic.html

左边的是我们刚刚看到的进行 2x2 反卷积。如果有一个步长为 2，那么你不仅在外面周围有填充，而且你实际上还需要在中间放填充。它们实际上并不是这样实现的，因为这样做很慢。在实践中，你会以不同的方式实现它们，但所有这些都是在幕后发生的，所以你不必担心。我们之前已经讨论过这个卷积算术教程，如果你对卷积仍然不熟悉，并且想要熟悉反卷积，这是一个很好的网站。如果你想看这篇论文，它是A guide to convolution arithmetic for deep learning。

DeconvBlock 看起来与 ConvBlock 几乎相同，只是多了一个 Transpose。我们像以前一样进行卷积 → relu → 批量归一化，它有输入滤波器和输出滤波器。唯一的区别是步长为 2 意味着网格大小会加倍而不是减半。

问题：nn.ConvTranspose2d 和 nn.Upsample 似乎做着相同的事情，即从上一层扩展网格大小（高度和宽度）。我们可以说 nn.ConvTranspose2d 总是优于 nn.Upsample 吗，因为 nn.Upsample 仅仅是调整大小并用零或插值填充未知部分吗？不，不能。在 distill.pub 上有一篇名为 反卷积和棋盘伪影 的出色互动论文指出，我们现在正在做的事情极其不理想，但好消息是其他人都在这样做。

看一下这里，你能看到这些棋盘伪影吗？这些都来自实际论文，基本上他们注意到每一篇关于生成模型的论文都有这些棋盘伪影，他们意识到这是因为当您使用大小为三的内核的步幅 2 卷积时，它们会重叠。因此，一些网格单元会获得两倍的激活。

因此，即使您从随机权重开始，最终也会得到一个棋盘状的伪影。所以你越深入，情况就越糟。他们的建议没有那么直接，Jeremy 发现对于大多数生成模型，上采样更好。如果你使用 nn.Upsample，基本上是在做池化的相反操作 —— 它说让我们用四个（2x2）网格单元替换这一个。有许多方法可以进行上采样 —— 一种方法是将所有内容复制到这四个单元格中，另一种方法是使用双线性或双三次插值。有各种技术可以尝试创建平滑的上采样版本，您可以在 PyTorch 中选择任何一种。如果您进行了 2x2 的上采样，然后正常的 3x3 卷积，这是另一种与 ConvTranspose 相同的操作方式 —— 它将网格大小加倍，并对其进行一些卷积运算。对于生成模型，这几乎总是效果更好。在 distil.pub 的出版物中，他们指出也许这是一个好方法，但他们没有直接说出来，而 Jeremy 会直接说出来。话虽如此，对于 GANS，他还没有取得太大的成功，他认为可能需要一些调整才能使其正常工作。问题在于在早期阶段，它没有产生足够的噪音。他尝试过使用上采样的版本，您可以看到噪音看起来并不是很嘈杂。下周当我们研究风格转移和超分辨率时，您将看到 nn.Upsample 真正发挥作用。

生成器，我们现在可以从向量开始。我们可以决定并说好，让我们不把它看作一个向量，而实际上是一个 1x1 的网格单元，然后我们可以将其转换为 4x4，然后是 8x8 等等。这就是为什么我们必须确保它是一个合适的倍数，以便我们可以创建出正确大小的东西。正如您所看到的，它正在做与之前完全相反的事情。它每次使单元格大小增加 2，直到达到我们想要的一半大小，然后最后我们再添加 n 个，步幅为 1。然后我们再添加一个 ConvTranspose 最终得到我们想要的大小，然后我们完成了。最后我们通过一个 tanh，这将强制我们处于零到一的范围内，因为当然我们不希望输出任意大小的像素值。因此，我们有一个生成器架构，它输出一个给定大小的图像，具有正确数量的通道，值在零到一之间。

在这一点上，我们现在可以创建我们的模型数据对象。这些东西需要一段时间来训练，所以我们将其设置为 128x128（只是一个更快的便利方式）。因此，这将是输入的大小，但然后我们将使用转换将其转换为 64x64。

最近有更多的进展，试图将其提高到高分辨率大小，但它们仍然倾向于要求批量大小为 1 或大量的 GPU。所以我们试图做一些可以用单个消费者 GPU 完成的事情。这是一个 64x64 卧室的例子。

bs,sz,nz = 64,64,100
tfms = tfms_from_stats(inception_stats, sz)
md = ImageClassifierData.from_csv(
    PATH, 'bedroom', 
    CSV_PATH, 
    tfms=tfms, 
    bs=128, 
    skip_header=False, 
    continuous=True
)
md = md.resize(128)
x,_ = next(iter(md.val_dl))
plt.imshow(md.trn_ds.denorm(x)[0]);

将它们全部放在一起

我们将几乎所有事情都手动完成，所以让我们继续创建我们的两个模型 - 我们的生成器和鉴别器，正如你所看到的它们是 DCGAN，换句话说，它们是出现在这篇论文中的相同模块。值得回头看一下 DCGAN 论文，看看这些架构是什么，因为假定当你阅读 Wasserstein GAN 论文时，你已经知道这一点。

netG = DCGAN_G(sz, nz, 3, 64, 1).cuda()
netD = DCGAN_D(sz, 3, 64, 1).cuda()

问题：如果我们想要在 0 到 1 之间的值，我们不应该使用 sigmoid 吗？像往常一样，我们的图像已经被归一化为范围从-1 到 1，因此它们的像素值不再在 0 到 1 之间。这就是为什么我们希望值从-1 到 1，否则我们将无法为鉴别器提供正确的输入。

所以我们有一个生成器和一个鉴别器，我们需要一个返回“先验”向量（即一堆噪音）的函数。我们通过创建一堆零来实现这一点。nz是z的大小 - 在我们的代码中经常看到一个神秘的字母，那是因为那是他们在论文中使用的字母。这里，z是我们噪音向量的大小。然后我们使用正态分布生成 0 到 1 之间的随机数。这需要是一个变量，因为它将参与梯度更新。

def create_noise(b): 
   return V(torch.zeros(b, nz, 1, 1).normal_(0, 1))
preds = netG(create_noise(4))
pred_ims = md.trn_ds.denorm(preds)

fig, axes = plt.subplots(2, 2, figsize=(6, 6))
for i,ax in enumerate(axes.flat): 
    ax.imshow(pred_ims[i])

这里是创建一些噪音并生成四个不同噪音片段的示例。

def gallery(x, nc=3):
    n,h,w,c = x.shape
    nr = n//nc
    assert n == nr*nc
    return (
        x.reshape(nr, nc, h, w, c)
         .swapaxes(1,2)
         .reshape(h*nr, w*nc, c)
    )

我们需要一个优化器来更新我们的梯度。在 Wasserstein GAN 论文中，他们告诉我们使用 RMSProp：

我们可以很容易地在 PyTorch 中做到这一点：

optimizerD = optim.RMSprop(netD.parameters(), lr = 1e-4)
optimizerG = optim.RMSprop(netG.parameters(), lr = 1e-4)

在论文中，他们建议使用学习率为 0.00005（5e-5），我们发现1e-4似乎有效，所以我们将其增加了一点。

现在我们需要一个训练循环：

为了更容易阅读

训练循环将经过我们选择的一些时代（这将是一个参数）。记住，当你手动完成所有事情时，你必须记住所有手动步骤：

1. 当你训练模型时，你必须将模块设置为训练模式，并在评估时将其设置为评估模式，因为在训练模式下，批量归一化更新会发生，丢失会发生，在评估模式下，这两个事情会被关闭。

2. 我们将从我们的训练数据加载器中获取一个迭代器

3. 我们将看看我们需要经过多少步，然后我们将使用tqdm给我们提供一个进度条，然后我们将经过那么多步。

论文中算法的第一步是更新鉴别器（在论文中，他们称鉴别器为“评论家”，w是评论家的权重）。所以第一步是训练我们的评论家一点点，然后我们将训练我们的生成器一点点，然后我们将回到循环的顶部。论文中的内部for循环对应于我们代码中的第二个while循环。

现在我们要做的是我们现在有一个随机的生成器。所以我们的生成器将生成看起来像噪音的东西。首先，我们需要教我们的鉴别器区分噪音和卧室之间的区别 - 你希望这不会太难。所以我们只是按照通常的方式做，但有一些小调整：

1. 我们将获取一小批真实卧室照片，这样我们就可以从迭代器中获取下一批，将其转换为变量。

2. 然后我们将计算损失——这将是鉴别器认为这看起来假的程度（“真实的看起来假吗？”）。

3. 然后我们将创建一些假图像，为此我们将创建一些随机噪音，并将其通过我们的生成器，这个阶段它只是一堆随机权重。这将创建一个小批量的假图像。

4. 然后我们将通过与之前相同的鉴别器模块来获取该损失（“假的看起来有多假？”）。记住，当你手动做所有事情时，你必须在循环中将梯度归零（netD.zero_grad()）。如果你忘记了这一点，请回到第 1 部分课程，我们从头开始做所有事情。

5. 最后，总鉴别器损失等于真实损失减去假损失。

所以你可以在这里看到：

他们没有谈论损失，实际上他们只谈论了一个梯度更新。

在 PyTorch 中，我们不必担心获取梯度，我们只需指定损失并调用loss.backward()，然后鉴别器的optimizer.step()。有一个关键步骤，即我们必须将 PyTorch 模块中的所有权重（参数）保持在-0.01 和 0.01 的小范围内。为什么？因为使该算法工作的数学假设仅适用于一个小球。了解为什么这样是有趣的数学是有趣的，但这与这篇论文非常相关，了解它不会帮助你理解其他论文，所以只有在你感兴趣的情况下才去学习。Jeremy 认为这很有趣，但除非你对 GANs 非常感兴趣，否则这不会是你在其他地方会重复使用的信息。他还提到，在改进的 Wasserstein GAN 出现后，有更好的方法来确保你的权重空间在这个紧密球内，即惩罚梯度过高，所以现在有稍微不同的方法来做这个。但这行代码是关键贡献，它是使 Wasserstein GAN 成功的关键：

for p in netD.parameters(): p.data.clamp_(-0.01, 0.01)

在这之后，我们有一个可以识别真实卧室和完全随机糟糕生成的图像的鉴别器。现在让我们尝试创建一些更好的图像。所以现在将可训练的鉴别器设置为 false，将可训练的生成器设置为 true，将生成器的梯度归零。我们的损失再次是生成器的fw（鉴别器）应用于一些更多的随机噪音。所以这与之前完全相同，我们对噪音进行生成，然后将其传递给鉴别器，但这次，可训练的是生成器，而不是鉴别器。换句话说，在伪代码中，更新的是θ，即生成器的参数。它接受噪音，生成一些图像，尝试弄清楚它们是假的还是真实的，并使用这些梯度来更新生成器的权重，而不是之前我们是根据鉴别器来获取梯度，并使用 RMSProp 和 alpha 学习率来更新我们的权重。

def train(niter, first=True):
    gen_iterations = 0
    for epoch in trange(niter):
        netD.train(); netG.train()
        data_iter = iter(md.trn_dl)
        i,n = 0,len(md.trn_dl)
        with tqdm(total=n) as pbar:
            while i < n:
                set_trainable(netD, True)
                set_trainable(netG, False)
                d_iters = (
                    100 
                    if (first and (gen_iterations < 25) 
                              or  (gen_iterations % 500 == 0)) 
                    else 5
                )
                j = 0
                while (j < d_iters) and (i < n):
                    j += 1; i += 1
                    for p in netD.parameters(): 
                        p.data.clamp_(-0.01, 0.01)
                    real = V(next(data_iter)[0])
                    real_loss = netD(real)
                    fake = netG(create_noise(real.size(0)))
                    fake_loss = netD(V(fake.data))
                    netD.zero_grad()
                    lossD = real_loss-fake_loss
                    lossD.backward()
                    optimizerD.step()
                    pbar.update()

                set_trainable(netD, False)
                set_trainable(netG, True)
                netG.zero_grad()
                lossG = netD(netG(create_noise(bs))).mean(0).view(1)
                lossG.backward()
                optimizerG.step()
                gen_iterations += 1

        print(
            f'Loss_D {to_np(lossD)}; Loss_G {to_np(lossG)}; ' + 
            f'D_real {to_np(real_loss)}; Loss_D_fake {to_np(fake_loss)}'
        )

你会发现鉴别器被训练ncritic次（上面代码中的 d_iters），他们将其设置为 5，每次我们训练生成器一次。论文中谈到了这一点，但基本思想是如果鉴别器还不知道如何区分，那么让生成器变得更好是没有意义的。这就是为什么我们有第二个 while 循环。这里是 5：

d_iters = (
    100 
    if (first and (gen_iterations < 25) 
              or  (gen_iterations % 500 == 0)) 
    else 5
)

实际上，稍后的论文中添加的内容或者可能是补充材料是，不时地在开始时，您应该在鉴别器上执行更多步骤，以确保鉴别器是有能力的。

torch.backends.cudnn.benchmark=True

让我们为一个时代进行训练：

train(1, False)0%|          | 0/1 [00:00<?, ?it/s]
100%|██████████| 18957/18957 [19:48<00:00, 10.74it/s]
Loss_D [-0.67574]; Loss_G [0.08612]; D_real [-0.1782]; Loss_D_fake [0.49754]
100%|██████████| 1/1 [19:49<00:00, 1189.02s/it]

然后让我们创建一些噪音，这样我们就可以生成一些示例。

fixed_noise = create_noise(bs)

但在此之前，将学习率降低 10 倍，并再进行一次训练：

set_trainable(netD, True)
set_trainable(netG, True)
optimizerD = optim.RMSprop(netD.parameters(), lr = 1e-5)
optimizerG = optim.RMSprop(netG.parameters(), lr = 1e-5)
train(1, False)
'''
0%|          | 0/1 [00:00<?, ?it/s]
100%|██████████| 18957/18957 [23:31<00:00, 13.43it/s]
Loss_D [-1.01657]; Loss_G [0.51333]; D_real [-0.50913]; Loss_D_fake [0.50744]
100%|██████████| 1/1 [23:31<00:00, 1411.84s/it]
'''

然后让我们使用噪音传递给我们的生成器，然后通过我们的反标准化将其转换回我们可以看到的东西，然后绘制它：

netD.eval(); netG.eval();
fake = netG(fixed_noise).data.cpu()
faked = np.clip(md.trn_ds.denorm(fake),0,1)

plt.figure(figsize=(9,9))
plt.imshow(gallery(faked, 8));

我们有一些卧室。这些不是真实的卧室，有些看起来并不像卧室，但有些看起来很像卧室，这就是想法。这就是 GAN。最好的方法是将 GAN 视为一种基础技术，你可能永远不会像这样使用它，但你会以许多有趣的方式使用它。例如，我们将使用它来创建一个循环 GAN。

问题：为什么要特别使用 RMSProp 作为优化器，而不是 Adam 等等？我不记得论文中有明确讨论过这个问题。我不知道这是实验性的还是理论上的原因。看看论文中是怎么说的。

来自论坛

通过实验，我发现 Adam 和 WGAN 不仅效果更差 - 它导致生成器训练失败。

来自 WGAN 论文：

最后，作为一个负面结果，我们报告说当使用基于动量的优化器（如 Adam [8]（具有β1>0））对评论者进行训练时，WGAN 训练有时会变得不稳定，或者当使用高学习率时。由于评论者的损失是非平稳的，基于动量的方法似乎表现更差。我们确定动量可能是一个潜在原因，因为随着损失的增加和样本变得更糟，Adam 步骤和梯度之间的余弦通常变为负值。这种余弦为负值的唯一情况是在这些不稳定的情况下。因此，我们转而使用 RMSProp [21]，它被认为在非平稳问题上表现良好

问题: 在训练过程中，检测过拟合的一个合理方法是什么？或者在训练结束后评估这些 GAN 模型的性能的一个方法是什么？换句话说，训练/验证/测试集的概念如何转化为 GANs [1:41:57]？这是一个很棒的问题，很多人开玩笑说 GANs 是唯一不需要测试集的领域，人们利用这一点编造东西并说看起来很棒。GANs 存在一些著名的问题，其中之一被称为模式崩溃。模式崩溃发生在你查看卧室时，结果发现只有三种卧室，每个可能的噪声向量都映射到这三种卧室中的一种。你查看画廊，结果发现它们都是相同的东西或者只有三种不同的东西。模式崩溃很容易看到，如果崩溃到一个很小的模式数量，比如 3 或 4。但如果模式崩溃到 10,000 种模式怎么办？因此，只有 10,000 种可能的卧室，所有的噪声向量都崩溃到这些卧室。你不太可能在我们刚刚看到的画廊视图中看到，因为在 10,000 种卧室中很少会有两个相同的卧室。或者如果每个卧室基本上是输入的直接副本 —— 它基本上记住了一些输入。这可能正在发生吗？事实是，大多数论文在检查这些问题方面做得不好，有时甚至根本不检查。因此，我们如何评估 GANs 甚至也许我们应该真正正确地评估 GANs 是一个现在还不够广泛理解的问题。一些人正在努力推动。Ian Goodfellow 是最著名的深度学习书籍的第一作者，也是 GANs 的发明者，他一直在发送持续的推文提醒人们测试 GANs 的重要性。如果你看到一篇声称有异常 GAN 结果的论文，那么这绝对值得关注。他们是否谈到了模式崩溃？他们是否谈到了记忆化？等等。

问题: GANs 可以用于数据增强吗 [1:45:33]？是的，绝对可以使用 GAN 进行数据增强。你应该吗？我不知道。有一些论文尝试使用 GANs 进行半监督学习。我还没有找到任何特别引人注目的论文，在广泛研究的真正有趣的数据集上展示出最先进的结果。我有点怀疑，原因是在我的经验中，如果用合成数据训练模型，神经网络将变得极其擅长识别你合成数据的具体问题，并且最终学到的将是这些问题。还有很多其他方法可以做半监督模型，效果很好。有一些地方可以工作。例如，你可能还记得 Otavio Good 在第一部分的缩放卷积网络中创建的那个奇妙的可视化，其中显示了字母通过 MNIST，他，至少在那个时候，是自动遥控汽车比赛中的第一名，他使用合成增强数据训练了他的模型，基本上是拿真实的汽车绕着赛道行驶的视频，然后添加了虚假的人和虚假的其他汽车。我认为这样做效果很好，因为 A. 他有点天才，B. 因为我认为他有一个明确定义的小子集需要处理。但总的来说，使用合成数据真的很难。我尝试过几十年使用合成数据和模型（显然不包括 GANs，因为它们是相当新的），但总的来说，这很难做到。非常有趣的研究问题。

Cycle GAN [1:41:08]

实施循环 GAN

让我们看看代码。我们将要做一些几乎闻所未闻的事情，那就是我开始查看别人的代码，但并没有对整个东西感到恶心，然后自己重新做。我实际上说我相当喜欢这个，我喜欢它到足以向我的学生展示。这是代码的来源，这是一个为循环 GAN 创建原始代码的人之一，他们创建了一个 PyTorch 版本。我不得不稍微整理一下，但实际上它还是相当不错的。这个酷的地方是，你现在将看到几乎所有 fast.ai 的部分，或者其他相关的 fast.ai 部分，是由其他人以不同的方式编写的。所以你将看到他们如何处理数据集、数据加载器、模型、训练循环等等。

你会发现有一个cgan目录，这基本上几乎是原始的，只是做了一些清理，我希望有一天能提交为 PR。它是以一种不幸地使它与他们作为脚本使用的方式过于连接的方式编写的，所以我稍微整理了一下，以便我可以将其用作模块。但除此之外，它还是相当相似的。

from fastai.conv_learner import *
from fastai.dataset import *
from cgan.options.train_options import *

所以cgan是他们从 github 仓库复制的代码，做了一些小的改动。cgan迷你库的设置方式是，它假设配置选项是被传递到像脚本一样。所以他们有TrainOptions().parse方法，我基本上传入一个脚本选项的数组（我的数据在哪里，有多少线程，我想要丢弃吗，我要迭代多少次，我要怎么称呼这个模型，我要在哪个 GPU 上运行）。这给我们一个opt对象，你可以看到它包含了什么。你会看到它包含了一些我们没有提到的东西，那是因为它对我们没有提到的其他所有东西都有默认值。

opt = TrainOptions().parse(['--dataroot',    
   '/data0/datasets/cyclegan/horse2zebra', '--nThreads', '8', 
   '--no_dropout', '--niter', '100', '--niter_decay', '100', 
   '--name', 'nodrop', '--gpu_ids', '2'])

所以我们不再使用 fast.ai 的东西，我们将主要使用 cgan 的东西。

from cgan.data.data_loader import CreateDataLoader
from cgan.models.models import create_model

我们首先需要的是一个数据加载器。这也是一个很好的机会，让你再次练习使用你选择的编辑器或 IDE 浏览代码的能力。我们将从CreateDataLoader开始。你应该能够找到符号或在 vim 标签中直接跳转到CreateDataLoader，我们可以看到它创建了一个CustomDatasetDataLoader。然后我们可以看到CustomDatasetDataLoader是一个BaseDataLoader。我们可以看到它将使用标准的 PyTorch DataLoader，这很好。我们知道如果要使用标准的 PyTorch DataLoader，你需要传递一个数据集，我们知道数据集是包含长度和索引器的东西，所以当我们查看CreateDataset时，它应该会这样做。

这里是CreateDataset，这个库不仅仅是循环 GAN - 它处理对齐和不对齐的图像对。我们知道我们的图像对是不对齐的，所以我们要使用UnalignedDataset。

正如预期的那样，它有__getitem__和__len__。对于长度，A 和 B 是我们的马和斑马，我们有两组，所以较长的那个将是DataLoader的长度。__getitem__将会：

• 随机从我们的两匹马和斑马中抓取一些东西

• 用 Pillow（PIL）打开它们

• 通过一些转换运行它们

• 然后我们可以把马变成斑马，或者把斑马变成马，所以有一些方向

• 返回我们的马、斑马、马的路径和斑马的路径

希望你能看到这看起来与 fast.ai 所做的事情非常相似。当涉及到转换和性能时，fast.ai 显然做了更多，但请记住，这是为这个特定事情的研究代码，他们做了这么多工作，这是相当酷的。

data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
dataset_size = len(data_loader)
dataset_size
'''
1334
'''

我们有一个数据加载器，所以我们可以将我们的数据加载到其中[2:06:17]。这将告诉我们其中有多少个小批次（这是 PyTorch 数据加载器的长度）。

下一步是创建一个模型。同样的想法，我们有不同类型的模型，我们将要做一个循环 GAN。

这是我们的CycleGANModel。CycleGANModel中有相当多的内容，所以让我们逐步找出将要使用的内容。在这个阶段，我们只是调用了初始化器，所以当我们初始化它时，它将会定义两个生成器，一个用于我们的马，一个用于斑马。它有一种方法来生成一组假数据，然后我们将获取我们的 GAN 损失，正如我们所讨论的，我们的循环一致性损失是一个 L1 损失。他们将使用 Adam，显然对于循环 GAN，他们发现 Adam 效果很好。然后我们将为我们的马判别器、斑马判别器和生成器各自创建一个优化器。生成器的优化器将包含马生成器和斑马生成器的参数，所有这些都在一个地方。

因此，初始化器将设置我们需要的所有不同网络和损失函数，并将它们存储在这个model中[2:08:14]。

model = create_model(opt)

然后打印出并向我们展示我们拥有的 PyTorch 模型。看到他们正在使用 ResNets，你会发现 ResNets 看起来非常熟悉，所以我们有卷积、批量归一化、Relu。InstanceNorm基本上与批量归一化相同，但它是针对一幅图像应用的，区别并不特别重要。你可以看到他们正在做反射填充，就像我们一样。当你尝试像这样从头开始构建所有东西时，这是很多工作，你可能会忘记 fast.ai 自动为你做的一些好事。你必须手动完成所有这些工作，最终只能得到其中的一部分。所以随着时间的推移，希望很快，我们将把所有这些 GAN 内容整合到 fast.ai 中，这将变得简单而容易。

我们有我们的模型，记住模型包含损失函数、生成器、判别器，所有这些都在一个方便的地方[2:09:32]。我已经复制、粘贴并稍微重构了他们代码中的训练循环，这样我们就可以在笔记本中运行它。所以这个应该看起来很熟悉。一个循环用于遍历每个 epoch，一个循环用于遍历数据。在这之前，我们设置了dataset。实际上这不是一个 PyTorch 数据集，我认为这是他们稍微令人困惑地用来谈论他们的组合数据，我们称之为模型数据对象——他们需要的所有数据。用tqdm循环遍历它，以获得进度条，这样我们就可以看看模型中发生了什么。

total_steps = 0

for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay+1):
    epoch_start_time = time.time()
    iter_data_time = time.time()
    epoch_iter = 0

    for i, data in tqdm(enumerate(dataset)):
        iter_start_time = time.time()
        if total_steps % opt.print_freq == 0: 
             t_data = iter_start_time - iter_data_time
        total_steps += opt.batchSize
        epoch_iter += opt.batchSize
        model.set_input(data)
        model.optimize_parameters()

        if total_steps % opt.display_freq == 0:
            save_result = total_steps % opt.update_html_freq == 0

        if total_steps % opt.print_freq == 0:
            errors = model.get_current_errors()
            t = (time.time() - iter_start_time) / opt.batchSize

        if total_steps % opt.save_latest_freq == 0:
            print(
                'saving the latest model(epoch %d,total_steps %d)'
                % (epoch, total_steps)
            )
            model.save('latest')

        iter_data_time = time.time()
    if epoch % opt.save_epoch_freq == 0:
        print(
            'saving the model at the end of epoch %d, iters %d' 
            % (epoch, total_steps)
        )
        model.save('latest')
        model.save(epoch)

    print(
        'End of epoch %d / %d \t Time Taken: %d sec' %
        (
            epoch, opt.niter + opt.niter_decay, 
            time.time() - epoch_start_time
        )
    )
    model.update_learning_rate()

set_input[2:10:32]：这是一种与 fast.ai 中所做的不同方法。这很巧妙，它相当特定于循环 GAN，但基本上在这个模型内部的想法是，我们将进入我们的数据并获取适当的数据。我们要么将马转换为斑马，要么将斑马转换为马，取决于我们选择的方式，A要么是马要么是斑马，反之亦然。如果需要，将其放在适当的 GPU 上，然后获取适当的路径。因此，模型现在有一批马和一批斑马。

现在我们优化参数[2:11:19]。这样看起来很好。你可以看到每一步。首先，尝试优化生成器，然后尝试优化马判别器，然后尝试优化斑马判别器。zero_grad()是 PyTorch 的一部分，以及step()。因此，有趣的部分是实际执行生成器反向传播的部分。

这里是[2:12:04]。让我们跳到关键部分。这里有我们刚刚在论文中看到的所有公式。让我们拿一匹马生成一只斑马。现在让我们使用鉴别器来看看我们是否能够判断它是假的还是真的（pred_fake）。然后让我们将其放入我们之前设置的损失函数中，以基于该预测获得 GAN 损失。然后让我们以相反的方向做同样的事情，使用相反的鉴别器，然后再次通过损失函数。然后让我们做循环一致性损失。再次，我们拿我们创建的假的东西，尝试将其转回原始状态。让我们使用之前创建的循环一致性损失函数将其与真实原始状态进行比较。这里是那个 lambda - 所以有一些权重我们使用了，实际上我们只是使用了他们在选项中建议的默认值。然后对相反的方向做同样的事情，然后将它们全部加在一起。然后进行反向步骤。就是这样。

所以我们可以为第一个鉴别器做同样的事情[2:13:50]。因为基本上所有的工作现在都已经完成了，这里要做的事情就少得多了。就是这样。我们不会一步步走过来，但基本上是我们已经看到的相同的基本东西。

所以optimize_parameters()正在计算损失并执行优化器步骤。不时保存并打印一些结果。然后不时更新学习率，所以他们在这里也有一些学习率退火的机制。有点像 fast.ai，他们有这个调度器的概念，你可以用它来更新你的学习率。

对于那些对更好地理解深度学习 API、更多地为 fast.ai 做贡献，或者在一些不同的后端中创建自己版本的一些东西感兴趣的人，看看第二个 API 是很酷的，它涵盖了一些类似的东西的一些子集，以便了解他们是如何解决这些问题的，以及相似之处/不同之处是什么。

def show_img(im, ax=None, figsize=None):
    if not ax: 
        fig,ax = plt.subplots(figsize=figsize)
    ax.imshow(im)
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
    return ax
def get_one(data):
    model.set_input(data)
    model.test()
    return list(model.get_current_visuals().values())
model.save(201)
test_ims = []
for i,o in enumerate(dataset):
    if i>10: 
        break
    test_ims.append(get_one(o))
def show_grid(ims):
    fig,axes = plt.subplots(2,3,figsize=(9,6))
    for i,ax in enumerate(axes.flat): 
        show_img(ims[i], ax);
    fig.tight_layout()
for i in range(8): 
    show_grid(test_ims[i])

我们训练了一段时间，然后我们可以随便拿几个例子，这里有它们[2:15:29]。这里有马、斑马，然后再变回马。

我花了大约 24 小时来训练它，所以它有点慢[2:16:39]。我知道 Helena 经常在 Twitter 上抱怨这些事情花费的时间有多长。我不知道她是如何在这些事情上如此高效的。

# !wget https://people.eecs.berkeley.edu/~taesung_park/CycleGAN/datasets/horse2zebra.zip

我还要提到昨天刚出来的另一件事[2:16:54]：

多模态无监督图像到图像翻译

现在有一种多模态的无监督图像到图像的翻译。所以你现在基本上可以从这只狗创建不同的猫。

youtu.be/ab64TWzWn40

这不仅仅是创建你想要的输出的一个例子，而是创建多个例子。这是昨天或前天才出来的。我觉得这很惊人。所以你可以看到这项技术是如何发展的，我认为在音乐、语音、写作方面，或者为艺术家创造工具方面，可能有很多机会。

深度学习 2：第 2 部分第 13 课

原文：medium.com/@hiromi_suenaga/deep-learning-2-part-2-lesson-13-43454b21a5d0

译者：飞龙

协议：CC BY-NC-SA 4.0

来自 fast.ai 课程的个人笔记。随着我继续复习课程以“真正”理解它，这些笔记将继续更新和改进。非常感谢 Jeremy 和Rachel 给了我这个学习的机会。

论坛 / 视频

图像增强 - 我们将涵盖您可能熟悉的这幅画。然而，您可能之前没有注意到这幅画中有一只鹰。您之前可能没有注意到的原因是这幅画以前没有鹰。同样地，第一张幻灯片上的画以前也没有美国队长的盾牌。

这是一篇很酷的新论文，几天前刚发表，名为Deep Painterly Harmonization，它几乎完全使用了我们将在本课程中学习的技术，只是进行了一些微小的调整。但您可以看到基本思想是将一张图片粘贴在另一张图片上，然后使用某种方法将两者结合起来。这种方法被称为“风格转移”。

在我们讨论之前，我想提一下 William Horton 的这个非常酷的贡献，他将这种随机权重平均技术添加到了 fastai 库中，现在已经全部合并并准备就绪。他写了一整篇关于这个的文章，我强烈建议您查看，不仅因为随机权重平均让您可以从现有的神经网络中获得更高的性能，而且基本上不需要额外的工作（只需向您的 fit 函数添加两个参数：use_swa，swa_start），而且他描述了他构建这个过程以及他如何测试它以及他如何为库做出贡献。所以如果您有兴趣做类似的事情，我认为这很有趣。我认为 William 以前没有建立过这种类型的库，所以他描述了他是如何做到的。

medium.com/@hortonhearsafoo/adding-a-cutting-edge-deep-learning-training-technique-to-the-fast-ai-library-2cd1dba90a49

TrainPhase [2:01]

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

learn.fit_opt_sched(phases)

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)

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

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)
]

SGDR

所以酷的是，现在我们可以仅仅使用这些训练阶段来复制所有我们现有的计划。这里有一个名为phases_sgdr的函数，它使用新的训练阶段 API 来进行 SGDR。

def phases_sgdr(lr, opt_fn, num_cycle,cycle_len,cycle_mult):
    phases = [TrainingPhase(epochs = cycle_len/ 20, opt_fn=opt_fn, 
                       lr=lr/100),
              TrainingPhase(epochs = cycle_len * 19/20, 
                   opt_fn=opt_fn, lr=lr, lr_decay=DecayType.COSINE)]
    for i in range(1,num_cycle):
        phases.append(TrainingPhase(epochs=cycle_len*
                      (cycle_mult**i), opt_fn=opt_fn, lr=lr, 
                      lr_decay=DecayType.COSINE))
    return phases

所以你可以看到，如果他按照这个计划运行，这就是它的样子：

他甚至做了我训练时使用非常低的学习率一小段时间然后突然增加并进行几个周期的小技巧，而且这些周期的长度在增加[8:05]。而且这一切都在一个函数中完成。

1cycle

现在我们可以用一个小函数来实现新的 1cycle。

def phases_1cycle(cycle_len,lr,div,pct,max_mom,min_mom):
    tri_cyc = (1-pct/100) * cycle_len
    return [TrainingPhase(epochs=tri_cyc/2, opt_fn=optim.SGD, 
                          lr=(lr/div,lr), lr_decay=DecayType.LINEAR,
                          momentum=(max_mom,min_mom),  
                          momentum_decay=DecayType.LINEAR),
           TrainingPhase(epochs=tri_cyc/2, opt_fn=optim.SGD, 
                         lr=(lr,lr/div), lr_decay=DecayType.LINEAR, 
                          momentum=(min_mom,max_mom), 
                          momentum_decay=DecayType.LINEAR),
           TrainingPhase(epochs=cycle_len-tri_cyc, opt_fn=optim.SGD,
                         lr=(lr/div,lr/(100*div)), 
                         lr_decay=DecayType.LINEAR, 
                         momentum=max_mom)]

所以如果我们符合这个，我们会得到这个三角形，然后是一个稍微平坦的部分，动量是一个很酷的东西 - 动量有一个动量衰减。在第三个训练阶段，我们有一个固定的动量。所以它同时处理动量和学习率。

区分学习率+ 1cycle

我还没有尝试过的一件事，但我认为会非常有趣的是使用区分学习率和 1cycle 的组合。还没有人尝试过。这将非常有趣。我遇到的唯一一篇使用区分学习率的论文使用了一种称为 LARS 的东西。它被用来通过查看每层的梯度和均值之间的比率并使用该比率自动更改每层的学习率来训练 ImageNet，从而使用非常大的批量大小。他们发现他们可以使用更大的批量大小。这是我看到这种方法使用的唯一其他地方，但是您可以尝试结合区分学习率和不同有趣的调度尝试很多有趣的事情。

您自己的 LR 查找器

现在您可以编写不同类型的 LR finder，特别是因为现在有这个stop_div参数，基本上意味着当损失变得太糟糕时，它将停止训练。

添加的一个有用功能是plot函数中的linear参数。如果您在学习率查找器中使用线性调度而不是指数调度，这是一个好主意，如果您调整到大致正确的区域，那么您可以使用线性来找到确切的区域。然后您可能希望使用线性比例来绘制它。因此，您现在也可以将 linear 传递给 plot。

您可以在每个阶段更改优化器。这比您想象的更重要，因为实际上针对 ImageNet 在非常大的批量大小上快速训练的当前最先进技术实际上是从 RMSProp 开始的，然后他们在第二部分切换到 SGD。因此，这可能是一个有趣的实验，因为至少有一篇论文现在已经表明这样可以很好地工作。再次强调，这是一个尚未被充分认识的问题。

更改数据

然后我发现最有趣的部分是您可以更改您的数据。为什么我们要更改我们的数据？因为您还记得第 1 和第 2 课，您可以在开始时使用小图像，然后稍后使用更大的图像。理论上，您可以使用这种方法更快地训练第一部分，然后记住，如果您将高度减半并将宽度减半，则每层的激活数量就会减少四分之一，因此速度可能会更快。它甚至可能泛化得更好。因此，您现在可以创建几种不同大小，例如，他有 28 和 32 大小的图像。这是 CIFAR10，所以您可以做的事情有限。然后，如果您在调用fit_opt_sched时在data_list参数中传入数据数组，它将在每个阶段使用不同的数据集。

data1 = get_data(28,batch_size)
data2 = get_data(32,batch_size)learn = ConvLearner.from_model_data(ShallowConvNet(), data1)phases = [TrainingPhase(epochs=1, opt_fn=optim.Adam, lr=1e-2, 
                        lr_decay=DecayType.COSINE),
          TrainingPhase(epochs=2, opt_fn=optim.Adam, lr=1e-2, 
                        lr_decay=DecayType.COSINE)]learn.fit_opt_sched(phases, data_list=[data1,data2])

这真的很酷，因为我们现在可以像在 DAWN bench 条目中那样使用它，并查看当我们实际上用很少的代码增加大小时会发生什么。那么当我们这样做时会发生什么？答案在 DAWN bench 上对 ImageNet 的训练中。

你可以看到，谷歌用半小时在一组 TPU 上赢得了比赛。最好的非 TPU 集群结果是 fast.ai + 学生在不到 3 小时内击败了拥有 128 台计算机的英特尔，而我们只用了一台计算机。我们还击败了在 TPU 上运行的谷歌，所以使用这种方法，我们已经证明了：

• 最快的 GPU 结果

• 最快的单机结果

• 最快的公开可用基础设施结果

这些 TPU 机架，除非你是谷歌，否则无法使用。而且成本很低（72.54 美元），这个英特尔的成本是 1200 美元的计算成本——他们甚至没有写在这里，但如果你同时使用 128 台计算机，每台有 36 个核心，每台有 140G，那就是你得到的结果，与我们的单个 AWS 实例相比。所以这在我们可以做的事情方面是一种突破。我们可以在一个公开可用的机器上训练 ImageNet，这个成本是 72 美元，顺便说一句，实际上是 25 美元，因为我们使用了一个 spot 实例。我们的学生 Andrew Shaw 建立了整个系统，让我们可以同时运行一堆 spot 实例实验，并且几乎自动化，但 DAWN bench 没有引用我们使用的实际数字。所以实际上是 25 美元，而不是 72 美元。所以这个 data_list 的想法非常重要和有帮助。

CIFAR10 结果

我们的 CIFAR10 结果现在也正式发布了，你可能还记得之前最好的结果是一个多小时。这里的诀窍是使用 1cycle，所以 Sylvain 的训练阶段 API 中的所有东西实际上都是我们用来获得这些顶级结果的东西。另一位 fast.ai 学生 bkj 采用了这个方法，并做了自己的版本，他采用了一个 Resnet18，并在顶部添加了我们学到的 concat pooling，并使用了 Leslie Smith 的 1cycle，所以他上了排行榜。所以前三名都是 fast.ai 的学生，这太棒了。

CIFAR10 成本结果

成本也是一样的——前三名，你可以看到，Paperspace。Brett 在 Paperspace 上运行，得到了最便宜的结果，略胜于 bkj。

所以我认为你可以看到，目前训练更快、更便宜的有趣机会很多都是关于学习率退火、尺寸退火，以及在不同时间使用不同参数进行训练，我仍然认为大家只是触及了表面。我认为我们可以做得更快、更便宜。这对于资源受限的环境中的人们非常有帮助，基本上除了谷歌，也许还有 Facebook。

架构也很有趣，上周我们看了一下简化版本的 darknet 架构。但有一个架构我们还没有谈到，那就是理解 Inception 网络所必需的。Inception 网络实际上非常有趣，因为他们使用了一些技巧使得事情更加高效。我们目前没有使用这些技巧，我觉得也许我们应该尝试一下。最有趣、最成功的 Inception 网络是他们的 Inception-ResNet-v2 网络，其中大部分块看起来像这样：

它看起来很像标准的 ResNet 块，因为有一个恒等连接，还有一个卷积路径，我们把它们加在一起。但实际上并不完全是这样。首先，中间的卷积路径是一个 1x1 卷积，值得思考一下 1x1 卷积实际上是什么。

1x1 卷积

1x1 卷积简单地说，对于输入中的每个网格单元，您基本上有一个向量。1 乘 1 乘滤波器数量的张量基本上是一个向量。对于输入中的每个网格单元，您只需与该张量进行点积。然后，当然，对于我们正在创建的 192 个激活之一，它将是这些向量之一。因此，基本上对网格单元（1,1）进行 192 个点积，然后对网格单元（1,2）或（1,3）等进行 192 个点积。因此，您将得到与输入具有相同网格大小和输出中的 192 个通道的内容。因此，这是一种非常好的方法，可以减少或增加输入的维度，而不改变网格大小。这通常是我们使用 1x1 卷积的方式。在这里，我们有一个 1x1 卷积和另一个 1x1 卷积，然后将它们相加。然后有第三个路径，这第三个路径没有被添加。虽然没有明确提到，但这第三个路径是被连接的。有一种形式的 ResNet 基本上与 ResNet 相同，但我们不使用加号，而是使用连接。这被称为 DenseNet。这只是一个使用连接而不是加法的 ResNet。这是一个有趣的方法，因为这样，身份路径实际上被复制。因此，您可以一直保持这种流动，因此正如我们将在下周看到的那样，这对于分割等需要保留原始像素、第一层像素和第二层像素不变的情况非常有用。

连接而不是添加分支是一件非常有用的事情，我们正在连接中间分支和右侧分支。最右侧的分支正在做一些有趣的事情，首先是 1x1 卷积，然后是 1x7，然后是 7x1。那里发生了什么？所以，那里发生的事情基本上是我们真正想要做的是 7x7 卷积。我们想要做 7x7 卷积的原因是，如果有多个路径（每个路径具有不同的内核大小），那么它可以查看图像的不同部分。最初的 Inception 网络将 1x1、3x3、5x5、7x7 连接在一起或类似的东西。因此，如果我们可以有一个 7x7 滤波器，那么我们可以一次查看图像的很多部分并创建一个非常丰富的表示。因此，Inception 网络的干部，即 Inception 网络的前几层实际上也使用了这种 7x7 卷积，因为您从这个 224x224x3 开始，希望将其转换为 112x112x64。通过使用 7x7 卷积，您可以在每个输出中获得大量信息以获得这些 64 个滤波器。但问题是 7x7 卷积是很费力的。您需要将 49 个内核值乘以每个通道的每个输入像素的 49 个输入。因此，计算量很大。您可能可以在第一层中使用它（也许可以），实际上，ResNet 的第一个卷积就是 7x7 卷积。

但对于《盗梦空间》来说并非如此。它们不使用 7x7 卷积，而是使用 1x7 接着 7x1。因此，基本思想是 Inception 网络或其所有不同版本的基本思想是有许多不同的卷积宽度的独立路径。在这种情况下，概念上的想法是中间路径是 1x1 卷积宽度，右侧路径将是 7 卷积宽度，因此它们正在查看不同数量的数据，然后将它们组合在一起。但我们不希望在整个网络中都使用 7x7 卷积，因为这太耗费计算资源了。

但是如果你考虑一下[23:18]，如果我们有一些输入进来，我们有一些我们想要的大滤波器，但它太大了无法处理。我们能做什么？让我们做 5x5。我们可以创建两个滤波器 —— 一个是 1x5，一个是 5x1。我们将前一层的激活传递给 1x5。我们从中取出激活，然后通过 5x1 传递，最后得到一些结果。现在另一端出来了什么？与其将其视为首先我们取激活，然后通过 1x5，然后通过 5x1，不如一起考虑这两个操作，看看一个 5x1 点积和一个 1x5 点积一起做会发生什么？实际上，你可以取一个 1x5 和 5x1，它们的外积将给你一个 5x5。现在你不能通过取这个积来创建任何可能的 5x5 矩阵，但是你可以创建很多 5x5 矩阵。所以这里的基本思想是当你考虑操作的顺序时（如果你对这里的理论更感兴趣，你应该查看 Rachel 的数值线性代数课程，这基本上是关于这个的整个课程）。但从概念上来说，很多时候你想要做的计算实际上比整个 5x5 卷积更简单。在线性代数中我们经常使用的术语是有一些低秩近似。换句话说，1x5 和 5x1 结合在一起 —— 那个 5x5 矩阵几乎和你理想情况下应该计算的 5x5 矩阵一样好。所以在实践中这往往是情况 —— 因为现实世界的本质是现实世界往往比随机性更具结构性。

酷的地方是[26:16]，如果我们用 1x7 和 7x1 替换我们的 7x7 卷积，对于每个单元格，它有 14 个输入通道乘以输出通道的点积要做，而 7x7 卷积则有 49 个要做。所以速度会快得多，我们希望它的效果几乎一样好。从定义上来说，它肯定捕捉到了尽可能多的信息宽度。

如果你对这方面的知识感兴趣，特别是在深度学习领域，你可以搜索分解卷积。这个想法是 3 年或 4 年前提出的。它可能已经存在更长时间了，但那是我第一次看到它的时候。结果表明它的效果非常好，Inception 网络广泛使用它。他们实际上在他们的干部中使用它。我们之前谈过，我们倾向于添加-on —— 我们倾向于说这是主干，例如我们有 ResNet34。这是主干，其中包含所有的卷积，然后我们可以添加一个自定义头部，通常是最大池化或全连接层。更好的做法是谈论主干包含两个部分：一个是干部，另一个是主干。原因是进来的东西只有 3 个通道，所以我们希望有一系列操作将其扩展为更丰富的东西 —— 通常是 64 个通道之类的东西。

在 ResNet 中，干部非常简单。它是一个 7x7 步幅 2 卷积，后面跟着一个步幅 2 最大池（如果我记得正确的话）。Inception 有一个更复杂的干部，其中包括多个路径的组合和连接，包括因子化卷积（1x7 和 7x1）。我很感兴趣的是，如果你在 Inception 干部上堆叠一个标准的 ResNet 会发生什么。我认为这将是一个非常有趣的尝试，因为 Inception 干部是一个非常精心设计的东西，以及如何将 3 通道输入转换为更丰富的东西似乎非常重要。而所有这些工作似乎都被抛弃了。我们喜欢 ResNet，它的效果非常好。但是如果我们在 Inception 干部上放置一个密集的网络骨干呢？或者如果我们用标准 ResNet 中的 1x7 和 7x1 因子化卷积替换 7x7 卷积呢？有很多事情我们可以尝试，我认为这将是非常有趣的。所以这是关于潜在研究方向的一些想法。

这就是我小小一堆随机东西部分的内容[29:51]。稍微接近这个实际主题的是图像增强。我将简要谈一下一篇新论文，因为它与我刚刚讨论的内容和我们接下来要讨论的内容有很大联系。这是一篇关于渐进式 GAN 的论文，来自 Nvidia：渐进增长的 GANs 用于提高质量、稳定性和变化。渐进式 GANs 采用了逐渐增加图像大小的想法。这是我所知道的唯一另一个人们实际上逐渐增加图像大小的方向。令我惊讶的是，这篇论文实际上非常受欢迎，知名度很高，而且受欢迎，但是人们还没有将逐渐增加图像大小的基本思想应用到其他地方，这显示了你可以在深度学习研究社区中期望找到的创造力水平。

他们真的回到了 4x4 GAN 开始[31:47]。实际上，他们试图复制 4x4 像素，然后是 8x8（上面左上角的那些）。这是 CelebA 数据集，所以我们试图重新创建名人的图片。然后他们去 16x16，32，64，128，然后 256。他们做的一个非常聪明的事情是，随着尺寸的增加，他们还向网络添加更多层。这有点说得通，因为如果你在做更多的 ResNet 类型的事情，那么你应该能够在每个网格单元大小输出一些有意义的东西，所以你应该能够在其上叠加东西。当他们这样做时，他们做了另一个聪明的事情，他们添加了一个跳过连接，并逐渐改变线性插值参数，使其越来越远离旧的 4x4 网络，朝向新的 8x8 网络。一旦完全移动到新网络，他们就会丢弃那个额外的连接。细节并不太重要，但它使用了我们谈论过的基本思想，逐渐增加图像大小和跳过连接。这是一篇很棒的论文，因为这是一种罕见的情况，好的工程师实际上构建了一些以非常明智的方式工作的东西。现在这并不奇怪，这实际上来自 Nvidia 自己。Nvidia 并不发表很多论文，有趣的是，当他们这样做时，他们构建了一些非常实用和明智的东西。所以我认为这是一篇很棒的论文，如果你想整合我们学到的许多不同的东西，而且没有太多的重新实现，所以这是一个有趣的项目，也许你可以继续研究并找到其他东西。

接下来会发生什么[33:45]。我们最终会升级到 1024x1024，你会看到图像不仅分辨率更高，而且质量更好。所以我要看看你能否猜出以下哪一个是假的：

它们全都是假的。这是下一个阶段。你一直往上走，然后突然爆炸。所以 GANs 和其他东西变得疯狂，你们中的一些人可能在这周看到了这个[34:16]。这个视频刚刚发布，是巴拉克·奥巴马的演讲，让我们来看一下：

youtu.be/cQ54GDm1eL0

正如你所看到的，他们使用这种技术来实际移动奥巴马的脸，就像乔丹·皮尔的脸在移动一样。你现在基本上拥有了所有需要的技术。这是一个好主意吗？

人工智能伦理[35:31]

有意外的后果

关键是要考虑你正在构建什么，以及它可能如何被使用。现在有很多努力投入到人脸识别中，包括我们的课程。我们一直在花费大量时间思考如何识别东西以及它在哪里。有很多很好的理由希望在这方面做得更好，比如改善农业产量、改善医学诊断和治疗规划、改善你的乐高分类机器人系统等等。但它也被广泛用于监视、宣传和虚假信息。再次，问题是我该怎么办？我不完全知道。但至少重要的是要考虑这个问题，谈论这个问题。

失控的反馈循环

有时候你可以做一些非常好的事情。例如，meetup.com 做了一件我认为是非常好的事情的事情，他们早就意识到一个潜在的问题，即更多的男性倾向于参加他们的聚会。这导致他们的协同过滤系统，你现在熟悉正在构建的系统，向男性推荐更多技术内容。这导致更多的男性参加更多的技术内容，从而导致推荐系统向男性推荐更多技术内容。当我们将算法和人类结合在一起时，这种失控的反馈循环是非常常见的。那么 Meetup 做了什么？他们故意做出了向女性推荐更多技术内容的决定，不是因为对世界应该如何的高尚想法，而只是因为这是有道理的。失控的反馈循环是一个 bug——有女性想要参加技术聚会，但当你去参加一个技术聚会，里面全是男性，你就不去了，然后它就会向男性推荐更多，依此类推。因此，Meetup 在这里做出了一个非常强有力的产品管理决策，即不按照算法建议的做。不幸的是，这种情况很少见。大多数这种失控的反馈循环，例如在预测性警务中，算法告诉警察去哪里，很多时候是更多的黑人社区，这些社区最终会涌入更多的警察，导致更多的逮捕，这有助于告诉更多的警察去更多的黑人社区等等。

AI 中的偏见

算法偏见的问题现在非常普遍，随着算法在特定政策决策、司法决策以及日常决策中的广泛使用，这个问题变得越来越严重。其中一些问题实际上是产品管理决策中的人员在最初就应该看到的，这些问题在任何定义下都是没有意义和不合理的。例如，阿贝·龚指出的这些问题——这些问题既用于预审，即谁需要支付保释金，这些人甚至还没有被定罪，也用于判决以及谁获得假释。尽管存在所有的缺陷，这在去年被威斯康星州最高法院维持了。所以你是否必须因为支付不起保释金而留在监狱，你的刑期有多长，你在监狱里待多久取决于你父亲做了什么，你的父母是否离婚，你的朋友是谁，以及你住在哪里。现在事实证明这些算法实际上非常糟糕，最近的一些分析显示它们基本上比随机还要糟糕。但即使公司在这些统计上的相关性上很有信心，有人能想象出一个世界，在那里根据你父亲的行为来决定发生什么吗？

在基本层面上，很多事情显然是不合理的，很多事情只是以这种你可以从经验上看到的方式失败了，这种失控的反馈循环一定发生过，这种过度概括一定发生过。例如，任何领域工作的人都应该准备这些交叉表，使用这些算法。因此，对黑人和白人被告重新犯罪的可能性的预测，我们可以很简单地计算出来。那些被标记为高风险但没有再犯的人中，23.5%是白人，而非洲裔美国人大约是白人的两倍。而那些被标记为低风险但再犯的人中，白人只有非洲裔美国人的一半，而非洲裔美国人只有 28%。这就是这种情况，至少如果你正在使用我们谈论过的技术，并以任何方式将其投入生产，为其他人构建 API，为人们提供培训，或者其他什么——那么至少确保你所做的事情可以被追踪，以便人们知道发生了什么，至少他们是知情的。我认为假设人们是邪恶的，试图破坏社会是错误的。我认为我更愿意从一个假设开始，即如果人们做了愚蠢的事情，那是因为他们不知道更好的方法。所以至少确保他们有这些信息。我发现很少有机器学习从业者考虑他们的界面中应该呈现什么信息。然后我经常会和数据科学家交谈，他们会说“哦，我正在研究的东西对社会没有影响。”真的吗？有很多人认为他们正在做的事情完全毫无意义吗？来吧。人们付钱让你做这件事是有原因的。它会以某种方式影响人们。所以考虑一下这是什么。

在招聘中的责任

我知道的另一件事是很多参与其中的人都在招聘人才，如果你在招聘人才，我想你现在都非常熟悉 fast.ai 的理念，这基本上是这样一个前提，我认为人们总体上并不邪恶，我认为他们需要被告知并拥有工具。因此，我们正在尽可能地为尽可能多的人提供他们需要的工具，特别是我们正在尝试将这些工具交到更广泛人群的手中。因此，如果你参与招聘决策，也许你可以记住这种理念。如果你不仅仅是招聘更广泛的人才，而且还提拔更广泛的人才，并为更广泛的人提供适当的职业管理，除了其他任何事情，你的公司会做得更好。事实证明，更多样化的团队更有创造力，往往比不那么多样化的团队更快更好地解决问题，而且你也可能避免这些糟糕的失误，这在某种程度上对世界是有害的，而在另一层面，如果你被发现，它们可能毁掉你的公司。

IBM 和“死亡计算器”

他们也可以摧毁你，或者至少让你在历史上看起来很糟糕。举几个例子，一个是回到第二次世界大战。IBM 提供了跟踪大屠杀所需的所有基础设施。这些是他们使用的表格，它们有不同的代码 - 犹太人是 8，吉普赛人是 12，毒气室中的死亡是 6，所有这些都记录在这些打孔卡上。现在你可以去博物馆看这些打孔卡，这实际上已经被一位瑞士法官审查过，他说 IBM 的技术支持促进了纳粹分子的任务并促使他们犯下反人类罪行。回顾这些时期的历史，看看当时 IBM 的人们在想什么是很有趣的。当时人们明显在想的是展示技术优势的机会，测试他们的新系统的机会，当然还有他们赚取的巨额利润。当你做了一些事情，即使在某个时候会变成问题，即使你被告知要这样做，这对你个人来说也可能成为问题。例如，大家都记得大众柴油排放丑闻。谁是唯一一个入狱的人？那就是只是在做他的工作的工程师。如果所有这些关于实际上不要搞砸世界的东西还不足以说服你，那么它也可能毁掉你的生活。如果你做了一些事情，结果导致问题，即使有人告诉你要这样做，你绝对可能被追究刑事责任。亚历山大·科根就是那个交出剑桥分析数据的人。他是一位剑桥学者。现在是一位全球著名的剑桥学者，因为他为摧毁民主的基础做出了自己的贡献。这不是我们想要留在历史上的方式。

问题： 在你的一条推特中，你说 dropout 被专利化了[56:50]。我认为这是关于 Google 的 WaveNet 专利。这是什么意思？你能分享更多关于这个主题的见解吗？这意味着我们将来要付费使用 dropout 吗？专利持有人之一是 Geoffrey Hinton。那又怎样？这不是很棒吗？发明就是关于专利的，啦啦啦。我的答案是否定的。专利已经变得疯狂。我们每周讨论的可以被专利化的东西数量会有几十个。很容易想出一个小调整，然后如果你把它变成专利来阻止每个人在接下来的 14 年内使用那个小调整，最终我们就会面临现在的情况，所有东西都以 50 种不同的方式被专利化。然后你会遇到这些专利流氓，他们通过购买大量垃圾专利然后起诉任何无意中做了那件事的人，比如给按钮加上圆角。那么对于我们来说，深度学习中有很多东西被专利化意味着什么？我不知道。

做这个工作的主要人员之一是 Google，而且来自 Google 的人回应这个专利时倾向于认为 Google 这样做是因为他们想要防御性地拥有它，所以如果有人起诉他们，他们可以说不要起诉我们，我们会反诉你，因为我们有所有这些专利。问题是据我所知，他们还没有签署所谓的防御性专利承诺，所以基本上你可以签署一个法律约束文件，说我们的专利组合只会用于防御而不是进攻。即使你相信 Google 的所有管理层永远不会变成专利流氓，你必须记住管理层会变化。给你一个具体的例子，我知道，Google 的最近的 CFO 对 PNL 有更积极的态度，我不知道，也许她会决定他们应该开始变现他们的专利，或者也许做出那个专利的团队可能会被分拆然后卖给另一家公司，最终可能会落入私募股权手中并决定变现专利或其他。所以我认为这是一个问题。最近在法律上有一个从软件专利转向实际上没有任何法律地位的大变化，所以这些可能最终都会被驳回，但现实是，任何不是大公司的人都不太可能有财务能力来抵抗这些庞大的专利流氓。

如果你写代码，就无法避免使用专利的东西。我不会感到惊讶，如果你写的大部分代码都有专利。实际上，有趣的是，最好的做法不是研究专利，因为如果你故意侵犯，惩罚会更严重。所以最好的做法是把手放在耳朵上，唱首歌，然后继续工作。所以关于 dropout 被专利化的事情，忘记我说过的。你不知道那个。你跳过那部分。

风格迁移[1:01:28]

%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)

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

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);

sz=288

trn_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);

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

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])*

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

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)

Broyden–Fletcher–Goldfarb–Shanno（BFGS）

这里有一些新的细节。其中一个是一个奇怪的优化器（optim.LBFGS）。任何完成过某些数学和计算机科学课程的人进入深度学习领域都会发现我们使用像 Adam 和 SGD 这样的东西，并且总是假设该领域的人对计算机科学一无所知，立即说“你们有人尝试过使用 BFGS 吗？”实际上，我们并没有使用来训练神经网络的完全不同类型的优化算法的长期历史。当然，事实上，那些花了几十年研究神经网络的人确实对计算机科学有所了解，结果表明这些技术整体上并不工作得很好。但实际上，这对我们来说会很有效，并且这是一个很好的机会，让那些在学校没有学习过这种类型的优化算法的人了解一个有趣的算法。BFGS（四个不同人的首字母缩写），L 代表有限内存。它是一个优化器，也就是说，有一些损失函数，它将使用一些梯度（并非所有优化器都使用梯度，但我们使用的所有优化器都会）来找到一个方向，并尝试通过调整一些参数使损失函数降低。它只是一个优化器。但它是一种有趣的优化器，因为它在每一步上做的工作比我们习惯的要多一点。具体来说，它的工作方式与我们习惯的方式相同，即我们只是选择一个起点，而在这种情况下，我们选择了一个随机图像，正如你所看到的。像往常一样，我们计算梯度。但我们不仅仅是采取一步，而是实际上在找到梯度的同时，我们还尝试找到二阶导数。二阶导数表示梯度变化的速度。

梯度：函数变化的速度

二阶导数：梯度变化的速度

换句话说，它有多曲折？基本思想是，如果你知道它不太曲折，那么你可能可以跳得更远。但如果它非常曲折，那么你可能不想跳得太远。因此，在更高维度中，梯度被称为雅可比矩阵，而二阶导数被称为海森矩阵。你会经常看到这些词，但它们的意思就是这样。再次强调，数学家们也必须为每件事发明新词。他们就像深度学习研究人员一样——也许有点傲慢。使用 BFGS，我们将尝试计算二阶导数，然后我们将使用它来确定前进的方向和距离——因此，这不是对未知领域的一次疯狂跳跃。

现在的问题是，实际计算 Hessian（二阶导数）几乎肯定不是一个好主意。因为在你要前进的每个可能方向上，对于你测量梯度的每个方向，你还必须在每个方向上计算 Hessian。这变得非常庞大。所以我们不是真的计算它，我们走几步，基本上看一下梯度在每一步变化了多少，然后用那个小函数来近似 Hessian。再次强调，这似乎是一个非常明显的事情，但直到后来有人想到了，这花了相当长的时间。跟踪每一步都需要大量内存，所以别跟踪每一步，只保留最后的十步或二十步。第二部分，就是 L 到 LBFGS。有限内存的 BFGS 意味着保留最后的 10 或 20 个梯度，用它来近似曲率的量，然后用曲率和梯度来估计前进的方向和距离。在深度学习中通常不是一个好主意，有很多原因。这比 Adam 或 SGD 更新更费力，也使用更多内存，当你有一个 GPU 来存储和数亿个权重时，内存就成了一个更大的问题。但更重要的是，小批量是非常颠簸的，所以弄清楚曲率以决定到底要前进多远，有点像我们说的磨亮了粪便（是的，澳大利亚和英国的表达方式，你懂的）。有趣的是，实际上使用二阶导数信息，结果就像是一个吸引鞍点的磁铁。因此，有一些有趣的理论结果基本上说，如果使用二阶导数信息，它实际上会把你引向函数的恶劣平坦区域。所以通常不是一个好主意。

def actn_loss(x): 
    return F.mse_loss(m_vgg(x), targ_v)*1000
def step(loss_fn):
    global n_iter
    optimizer.zero_grad()
    loss = loss_fn(opt_img_v)
    loss.backward()
    n_iter+=1
    if n_iter%show_iter==0: 
        print(f'Iteration: n_iter, loss: **{loss.data[0]}**')
    return loss

但在这种情况下，我们不是在优化权重，而是在优化像素，所以所有规则都改变了，实际上 BFGS 是有意义的。因为每次它做更多的工作，它是一种不同类型的优化器，PyTorch 中的 API 也有点不同。正如你在这里看到的，当你说optimizer.step时，你实际上传入了损失函数。所以我们的损失函数是调用step，传入一个特定的损失函数，即我们的激活损失（actn_loss）。在循环内部，你不会说 step，step，step。而是看起来像这样。所以有点不同，你可以尝试重写这个来使用 SGD，它仍然会工作。只是会花更长的时间，我还没有尝试过用 SGD，我很想知道它需要多长时间。

n_iter=0
while n_iter <= max_iter: 
    optimizer.step(partial(step,actn_loss))
'''
Iteration: n_iter, loss: 0.8466196656227112
Iteration: n_iter, loss: 0.34066855907440186
Iteration: n_iter, loss: 0.21001280844211578
Iteration: n_iter, loss: 0.15562333166599274
Iteration: n_iter, loss: 0.12673595547676086
Iteration: n_iter, loss: 0.10863320529460907
Iteration: n_iter, loss: 0.0966048613190651
Iteration: n_iter, loss: 0.08812198787927628
Iteration: n_iter, loss: 0.08170554041862488
Iteration: n_iter, loss: 0.07657770067453384
'''

所以你可以看到损失函数在下降。我们的 VGG 模型第 37 层的激活与目标激活之间的均方误差，记住目标激活是应用于我们的鸟的 VGG。明白了吗？所以现在我们有了一个内容损失。现在，关于这个内容损失，我要说的一件事是我们不知道哪一层会起到最好的作用。所以如果我们能多做一些实验就好了。现在的情况很烦人：

也许我们甚至想使用多个层。所以，与其截断我们想要的层之后的所有层，不如我们能够以某种方式抓取几个层的激活值。现在，我们已经知道一种方法可以在我们做 SSD 时做到这一点，我们实际上编写了一个具有多个输出的网络。记得吗？不同的卷积层，我们吐出了一个不同的oconv东西？但我真的不想去添加到 torch.vision ResNet 模型中，特别是如果以后我想尝试 torch.vision VGG 模型，然后我想尝试 NASNet-A 模型，我不想去修改它们的输出。此外，我希望能够轻松地按需打开和关闭某些激活。所以我们之前简要提到过这个想法，PyTorch 有这些名为 hooks 的奇妙东西。您可以有前向钩子，让您将任何您喜欢的东西插入到计算的前向传递中，或者有后向钩子，让您将任何您喜欢的东西插入到后向传递中。所以我们将创建世界上最简单的前向钩子。

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

前向钩子[1:29:42]

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

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

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

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

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()

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

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
'''

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:39:29]

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);

def scale_match(src, targ):
    h,w,_ = img.shape
    sh,sw,_ = style_img.shape
    rat = max(h/sh,w/sw); rat
    res = 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()

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

style_tfm = val_tfms(style_img)

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])]
'''

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

def gram_mse_loss(input, target): 
        return F.mse_loss(gram(input), gram(target))

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);

for sf in sfs: sf.close()

风格转移

风格转移是将内容损失和风格损失加在一起，并加上一些权重。所以没有太多可以展示的。

获取我的优化器，获取我的图像：

opt_img_v, optimizer = get_opt()

我的综合损失是一个特定层次的 MSE 损失，我所有层次的风格损失，将风格损失相加，加到内容损失上，我正在缩放内容损失。实际上，我已经将风格损失缩放为 1E6。所以它们都被精确地缩放了。将它们加在一起。再次，你可以尝试对不同的风格损失进行加权，或者你可以删除其中一些，所以这是最简单的版本。

def comb_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)]
    cnt_loss   = F.mse_loss(outs[3], targ_vs[3])*1000000
    style_loss = sum(losses)
    return cnt_loss + style_loss

训练它：

n_iter=0
while n_iter <= max_iter: 
    optimizer.step(partial(step,comb_loss))
'''
Iteration: n_iter, loss: 1802.36767578125
Iteration: n_iter, loss: 1163.05908203125
Iteration: n_iter, loss: 961.6024169921875
Iteration: n_iter, loss: 853.079833984375
Iteration: n_iter, loss: 784.970458984375
Iteration: n_iter, loss: 739.18994140625
Iteration: n_iter, loss: 706.310791015625
Iteration: n_iter, loss: 681.6689453125
Iteration: n_iter, loss: 662.4088134765625
Iteration: n_iter, loss: 646.329833984375
'''
x = val_tfms.denorm(np.rollaxis(to_np(opt_img_v.data),1,4))[0]
plt.figure(figsize=(9,9))
plt.imshow(x, interpolation='lanczos')
plt.axis('off');

for sf in sfs: sf.close()

天啊，它看起来真的很好。所以我觉得这很棒。这里的主要要点是，如果你想用神经网络解决问题，你所要做的就是设置一个损失函数，然后优化某些东西。而损失函数是一个较低的数字是你更满意的东西。因为当你优化它时，它会使那个数字尽可能低，它会做你想要它做的事情。所以在这里，Gatys 提出了一个损失函数，当它看起来像我们想要的东西时，它会是一个较小的数字，看起来像我们想要的风格。这就是我们所要做的。

实际上，除了实现了 Gram MSE 损失，这只是 6 行代码，这就是我们的损失函数：

将其传递给我们的优化器，等大约 5 秒钟，我们就完成了。记住，我们可以一次处理一批，所以我们可以等待 5 秒钟，64 个就完成了。所以我认为这真的很有趣，自从这篇论文发表以来，它确实激发了很多有趣的工作。不过对我来说，大部分有趣的工作还没有发生，因为对我来说，有趣的工作是将人类创造力与这些工具结合起来的工作。我还没有看到可以下载或使用的工具，艺术家可以控制并可以以交互方式进行操作。与Google Magenta项目的人交谈很有趣，这是他们的创意人工智能项目，他们在音乐方面所做的一切都是关于这个的。它正在构建音乐家可以实时使用的工具。由于 Magenta 的存在，您将在音乐领域看到更多这样的东西。如果您访问他们的网站，您会看到各种按键，可以实际更改鼓点、旋律、音调等。您肯定会看到 Adobe 或 Nvidia 开始发布一些小型原型并开始这样做，但这种创意人工智能的爆发尚未发生。我认为我们已经拥有了我们所需的所有技术，但没有人将其整合到一起并说“看看我建造的东西，看看人们用我的东西建造的东西”。所以这只是一个巨大的机会领域。

所以我在课堂开始时提到的那篇论文[2:01:16] ——基本上是将美国队长的盾牌添加到任意绘画中使用了这种技术。不过，诀窍是通过一些微小的调整使粘贴的美国队长盾牌能够很好地融入其中。但那篇论文只有几天的历史，所以尝试这个项目将是一个非常有趣的项目，因为您可以使用所有这些代码。它确实利用了这种方法。然后，您可以从使内容图像类似于带有盾牌的绘画开始，然后样式图像可以是不带盾牌的绘画。这将是一个很好的开始，然后您可以看看他们在这篇论文中尝试解决的具体问题，以使其更好。但您现在可以开始。

问题：之前有很多人表达了对 Pyro 和概率编程的兴趣。所以 TensorFlow 现在有了这个 TensorFlow 概率或其他东西。有很多概率编程框架。我认为它们很有趣，但至今未经证明，因为我还没有看到任何使用概率编程系统完成的事情，而没有使用它们更好。基本前提是它允许你创建更多关于你认为世界是如何运作的模型，然后插入参数。所以 20 年前当我还在管理咨询行业工作时，我们经常使用电子表格，然后我们会使用这些蒙特卡洛模拟插件——有一个叫做 At Risk(?)，一个叫做 Crystal Ball。我不知道几十年后它们是否还存在。基本上它们让你可以更改电子表格中的一个单元格，说这不是一个具体的值，而实际上代表一个具有这个均值和标准差的值分布，或者它有这个分布，然后你会点击一个按钮，电子表格会从这些分布中随机抽取一千次数字重新计算，并显示你的结果的分布，可能是利润或市场份额或其他什么。那时我们经常使用它们。显然，人们认为电子表格是做这种工作的更明显的地方，因为你可以更自然地看到所有这些，但我不知道。我们将看到。在这个阶段，我希望它能够被证明有用，因为我觉得它非常吸引人，符合我过去经常做的工作。实际上，围绕这种东西有整个实践，他们过去称之为系统动力学，这实际上是建立在这种东西之上的，但它并没有走得太远。

问题：然后有一个关于通用风格转移预训练的问题。我不认为你可以为通用风格进行预训练，但你可以为特定风格的通用照片进行预训练，这就是我们要达到的目标。尽管可能最终会成为一项作业。我还没有决定。但我会做所有的部分。

问题：请让他谈谈多 GPU。哦，是的，我还没有关于那个的幻灯片。我们马上就要谈到了。

在我们开始之前，再分享一张来自 Gatys 论文的有趣图片。他们有更多图片，只是没有适合我的幻灯片，但是有不同的卷积层用于风格。不同的风格和内容比例，这里是不同的图片。显然这不再是梵高的风格，这是一个不同的组合。所以你可以看到，如果你只做风格，你看不到任何图片。如果你做很多内容，但是使用足够低的卷积层，看起来还可以，但背景有点愚蠢。所以你可能想要在中间某个地方。所以你可以尝试一下，做一些实验，但也可以使用论文来帮助指导你。

数学

实际上，我想现在开始研究数学，下周我们将讨论多 GPU 和超分辨率，因为这是来自论文的内容，我真的希望在我们讨论完论文后，你们能阅读论文，并在论坛上提出任何不清楚的问题。但这篇论文中有一部分我想谈谈，讨论如何解释它。所以论文说，我们将得到一个输入图像x，这个小东西通常表示它是一个向量，Rachel，但这个是一个矩阵。我猜它可能是两者之一。我不知道。通常小写粗体字母表示向量，或者带有上箭头的小写字母表示向量。通常大写字母表示矩阵，或者带有两个箭头的小写字母表示矩阵。在这种情况下，我们的图像是一个矩阵。我们基本上将其视为向量，所以也许我们只是在超前一步。

所以我们有一个输入图像x，它可以通过 CNN 的特定层中的滤波器响应（即激活）进行编码。滤波器响应就是激活。希望你们都能理解。CNN 的基本功能就是生成激活层。一个层有一堆滤波器，产生一定数量的通道。今年表示第 L 层有大写 Nl个滤波器。再次强调，这里的大写字母不代表矩阵。所以我不知道，数学符号是如此不一致。所以在第 L 层有 Nl 个不同的滤波器，这意味着也有同样数量的特征图。所以确保你能看到这个字母 Nl 和这个字母是一样的。所以你必须非常小心地阅读字母并认识到它就像啪一下，这个字母和那个字母是一样的。显然，Nl 个滤波器创建了 Nl 个特征图或通道，每个尺寸为 Ml（好吧，我看到这里正在发生展开）。这就像 numpy 符号中的 M[l]。这是第l层。所以 M 是第l层。尺寸是高度乘以宽度——所以我们将其展平。所以第 l 层的响应可以存储在矩阵 F 中（现在l在顶部，出于某种原因）。这不是 f^l，这只是另一个索引。我们只是为了好玩而移动它。这里我们说它是 R 的元素——这是一个特殊的 R，表示实数 N 乘以 M（这表示它的维度是 N 乘以 M）。这非常重要，不要继续。就像 PyTorch 一样，确保你首先理解维度的秩和大小，数学也是一样。这些是你停下来思考为什么是 N 乘以 M 的地方。N 是滤波器的数量，M 是高度乘以宽度。所以你还记得我们做.view(b*c, -1)的时候吗？这就是。所以尝试将代码映射到数学上。所以 F 是x：

如果我对你更友好，我会使用与论文相同的字母。但我太忙于让这个该死的东西运行起来，无法仔细做到这一点。所以你可以回去将其重命名为大写 F。

所以我们将 L 移到顶部是因为我们现在要有更多的索引。在 Numpy 或 PyTorch 中，我们通过方括号索引事物，然后用逗号分隔很多东西。在数学中的方法是用小写字母围绕你的字母——到处都扔上去。所以这里，Fl是 F 的第l层，然后ij是第l层中第i个滤波器在第j位置的激活。所以位置j的大小是 M，即高度乘以宽度的大小。这是容易混淆的事情。通常你会看到一个ij，然后假设它是在图像的高度乘以宽度的位置进行索引，但实际上不是，对吧？它是在通道中对展平图像的第i个滤波器/通道的第j个位置进行索引。它甚至告诉你——它是第l层中展平图像中第j个位置的第i个滤波器/通道。所以除非你理解 F 是什么，否则你将无法进一步阅读论文。这就是为什么这些是你停下来确保你感到舒适的地方。

所以现在，内容损失，我不会花太多时间，但基本上我们只是要检查激活值与预测值的平方[2:12:03]。所以这就是我们的内容损失。风格损失将是类似的，但使用格拉姆矩阵 G：

我真的很想向你展示这个。我觉得这很棒。有时我真的喜欢数学符号中可以做的事情，它们也是你通常可以在 J 和 APL 中做的事情，这种隐式循环正在这里进行。这是在说什么呢？嗯，它在说我的层l中的格拉姆矩阵，对于一个轴上的第i个位置和另一个轴上的第j个位置等于我的 F 矩阵（所以我的展平矩阵）对于该层中的第i个通道与同一层中的第j个通道，然后我将进行求和。我们将取第k个位置并将它们相乘然后将它们全部加起来。所以这正是我们之前计算格拉姆矩阵时所做的事情。所以这里发生了很多事情，因为对我来说，这是非常巧妙的符号 —— 有三个隐式循环同时进行，加上求和中的一个显式循环，然后它们一起工作来为每一层创建这个格拉姆矩阵。所以让我们回去看看你是否能匹配这个。所以所有这一切都同时发生，这非常棒。

就是这样。所以下周，我们将看到一个非常类似的方法，基本上再次进行风格转移，但这次我们实际上会训练一个神经网络来为我们做这件事，而不是进行优化。我们还将看到你可以做同样的事情来进行超分辨率。我们还将回顾一些 SSD 的内容，以及进行一些分割。所以如果你忘记了 SSD，这周可能值得进行一点复习。好的，谢谢大家。下周见。