可微分层 [02:11]

Yann LeCun 一直在推广这样一个观点，即我们不称之为“深度学习”，而是“可微分编程”。我们在第一部分所做的一切实际上都是关于建立一个可微分函数和一个描述参数好坏的损失函数，然后按下开始按钮，它就开始工作了。如果你能配置一个评分函数来评估某个任务的表现，并且有一个相当灵活的神经网络架构，那么你就完成了。

是的，可微分编程只不过是现代深度学习技术的一个重新包装，就像深度学习是神经网络的现代化版本，具有超过两层的层次一样。

重要的一点是，人们现在通过组装参数化的功能块网络，并通过使用某种形式的基于梯度的优化从示例中训练它们来构建一种新型软件……这实际上非常类似于常规程序，只是它是参数化的，自动区分的，可训练/可优化的。

• Yann LeCun，FAIR 主任

2. 迁移学习 [03:23]

迁移学习是有效使用深度学习的最重要的单一事项。你几乎永远不会想要或需要从随机权重开始，除非没有人曾经在一个大致相似的数据集上训练过一个与你正在解决的问题有一定联系的模型 — 这几乎不会发生。Fastai 库专注于迁移学习，这使它与其他库不同。迁移学习的基本思想是：

• 给定一个执行 A 任务的网络，移除最后一层。

• 在最后随机添加几个层

• 微调这些层以执行 B 任务，同时利用原始网络学到的特征

• 然后选择性地对整个模型进行微调，现在你有了一个可能使用数量级更少的数据，更准确，训练速度更快的东西。

3. 架构设计 [05:17]

通常有一小范围的架构通常在很多时候都表现得相当不错。我们一直专注于使用 CNN 处理通常大小固定的有序数据，RNN 处理具有某种状态的序列。我们还稍微调整了一下激活函数 — 如果有单一分类结果，则使用 softmax，如果有多个结果，则使用 sigmoid。我们将在第 2 部分研究的一些架构设计更有趣。特别是关于目标检测的这个第一个会话。但总的来说，我们可能花更少的时间讨论架构设计，因为这通常不是难点。

4. 处理过拟合 [06:26]

Jeremy 喜欢构建模型的方式：

• 创建一些明显过度参数化的东西，肯定会过度拟合，训练它并确保它确实过拟合。在那一点上，你已经有了一个能够反映训练集的模型。然后只需做这些事情来减少过拟合。

如果你不从一个过拟合的地方开始，你就会迷失。所以你从一个过拟合的地方开始，为了让它过拟合得更少，你可以：

• 添加更多数据

• 添加更多数据增强

• 做一些像更多的批量归一化层、稠密网络，或者各种可以处理更少数据的东西。

• 添加正则化，如权重衰减和丢失

• 最后（这通常是人们首先做的事情，但这应该是你最后做的事情）减少你的架构复杂性。减少层数或激活数量。

5. 嵌入[07:46]

我们已经谈了很多关于嵌入 - 无论是用于自然语言处理还是任何种类的分类数据，现在你可以用神经网络来建模。就在今年初，几乎没有关于在深度学习中使用表格数据的例子，但现在越来越多的人开始使用神经网络来进行时间序列和表格数据分析。

%matplotlib inline
%reload_ext autoreload
%autoreload 2
from fastai.conv_learner import *
from fastai.dataset import *
from pathlib import Path
import json
from PIL import ImageDraw, ImageFont
from matplotlib import patches, patheffects
# torch.cuda.set_device(1) 

您可能会发现一行torch.cuda.set_device(1)被遗留下来，如果您只有一个 GPU，这会导致错误。这是在您有多个 GPU 时选择 GPU 的方法，所以只需将其设置为零或完全删除该行。

就像 ImageNet 是一个标准的对象分类数据集一样，还有许多标准的目标检测数据集[41:12]。经典的 ImageNet 等价物是 Pascal VOC。

• bbox：列，行（左上角），高度，宽度

• image_id：您需要将其与trn_j[IMAGES]（上面）连接起来，以查找file_name等。

• category_id：查看trn_j[CATEGORIES]（下面）

• segmentation：多边形分割（我们将使用它们）

• ignore：我们将忽略忽略标志

• iscrowd：指定这是该对象的一群，而不仅仅是其中一个

trn_j[ANNOTATIONS][:2]
'''
[{'area': 34104,
  'bbox': [155, 96, 196, 174],
  'category_id': 7,
  'id': 1,
  'ignore': 0,
  'image_id': 12,
  'iscrowd': 0,
  'segmentation': [[155, 96, 155, 270, 351, 270, 351, 96]]},
 {'area': 13110,
  'bbox': [184, 61, 95, 138],
  'category_id': 15,
  'id': 2,
  'ignore': 0,
  'image_id': 17,
  'iscrowd': 0,
  'segmentation': [[184, 61, 184, 199, 279, 199, 279, 61]]}]
'''

trn_j[CATEGORIES][:4]
'''
[{'id': 1, 'name': 'aeroplane', 'supercategory': 'none'},
 {'id': 2, 'name': 'bicycle', 'supercategory': 'none'},
 {'id': 3, 'name': 'bird', 'supercategory': 'none'},
 {'id': 4, 'name': 'boat', 'supercategory': 'none'}]
'''

使用常量而不是字符串很有帮助，因为我们可以获得制表符补全，不会输错。

FILE_NAME,ID,IMG_ID,CAT_ID,BBOX = 'file_name','id','image_id','category_id','bbox'
cats = dict((o[ID], o['name']) for o in trn_j[CATEGORIES])
trn_fns = dict((o[ID], o[FILE_NAME]) for o in trn_j[IMAGES])
trn_ids = [o[ID] for o in trn_j[IMAGES]]

侧记：当人们实时看到 Jeremy 在工作时，看到他的课程后最常评论的是[51:21]：

“哇，你实际上不知道自己在做什么，是吧”。他做的 99%的事情都不起作用，而那些确实起作用的事情只占很小的比例。他提到这一点是因为机器学习，特别是深度学习，非常令人沮丧。理论上，您只需定义正确的损失函数和足够灵活的架构，然后按下训练按钮，就完成了。但如果那确实是所有需要的，那么什么都不会花费任何时间。问题在于一直到它起作用的所有步骤，它都不起作用。就像它直接进入无限大，崩溃并显示不正确的张量大小等。他将努力向您展示一些调试技术，但这是最难教授的事情之一。它需要的主要是坚韧不拔。那些非常有效的人和那些似乎走得不远的人之间的区别从来不是智力问题。它总是关于坚持下去 - 基本上是永不放弃。这在这种深度学习中尤为重要，因为您不会得到持续的奖励循环。它是一种持续的不起作用，不起作用，不起作用，直到最终起作用的过程，所以有点烦人。

Fastai 使用 OpenCV。TorchVision 使用 PyTorch 张量进行数据增强等。很多人使用 Pillow PIL。Jeremy 对所有这些进行了大量测试，他发现 OpenCV 比 TorchVision 快 5 到 10 倍。对于星球卫星图像竞赛 [1:11:55]，TorchVision 非常慢，因为他们进行了大量的数据增强，只能利用 25%的 GPU 利用率。分析器显示这一切都在 TorchVision 中。

Pillow 速度相当快，但不及 OpenCV 快，也远不及线程安全[1:12:19]。Python 有一个叫做全局解释器锁（GIL）的东西，这意味着两个线程不能同时执行 Pythonic 的事情 —— 这使得 Python 成为现代编程的糟糕语言，但我们却被困在其中。OpenCV 释放了 GIL。fast.ai 库之所以如此快，是因为它不像其他库那样为数据增强使用多个处理器 —— 它实际上使用多个线程。它能够使用多个线程的原因是因为它使用了 OpenCV。不幸的是，OpenCV 有一个晦涩的 API，文档有些晦涩。这就是为什么 Jeremy 试图让使用 fast.ai 的人不需要知道它正在使用 OpenCV。您不需要知道要传递哪些标志来打开一个图像。您不需要知道如果读取失败，它不会显示异常 —— 它会静默地返回None。

不要开始使用 PyTorch 进行数据增强或引入 Pillow —— 您会发现事情突然变得非常缓慢，或者多线程将不再起作用。您应该坚持使用 OpenCV 进行处理[1:14:10]

Matplotlib 之所以被命名为 Matplotlib，是因为它最初是 Matlab 绘图库的一个克隆。不幸的是，Matlab 的绘图库并不好，但那时候，这是每个人都知道的。在某个时候，Matplotlib 的开发人员意识到了这一点，并添加了第二个 API，即面向对象的 API。不幸的是，因为最初学习 Matplotlib 的人没有学习过 OO API，他们随后教导下一代人使用旧的 Matlab 风格 API。现在几乎没有例子或教程使用更好、更容易理解和更简单的 OO API。由于绘图在深度学习中非常重要，我们在这门课程中要学习的一件事就是如何使用这个 API。

技巧 1：plt.subplots [1:16:00]

Matplotlib 的plt.subplots是一个非常有用的包装器，用于创建图表，无论您是否有多个子图。请注意，Matplotlib 有一个可选的面向对象的 API，我认为这个 API 更容易理解和使用（尽管在线上很少有例子使用它！）

def show_img(im, figsize=None, ax=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

它返回两个东西 —— 你可能不会关心第一个（图形对象），第二个是 Axes 对象（或其数组）。基本上，你以前在哪里说 plt. 什么，现在你说 ax. 什么，它将绘制到特定的子图。当你想绘制多个图以便进行比较时，这很有帮助。

技巧 2：无论背景颜色如何都可见的文本 [1:17:59]

使文本在任何背景下都可见的一个简单但很少使用的技巧是使用白色文本和黑色轮廓，或者反之。这是如何在 matplotlib 中做到的。

def draw_outline(o, lw):
    o.set_path_effects([
        patheffects.Stroke(linewidth=lw, foreground='black'), 
        patheffects.Normal()
    ])

请注意参数列表中的 * 是 splat 操作符。在这种情况下，与写出 b[-2],b[-1] 相比，这是一个小快捷方式。

def draw_rect(ax, b):
    patch = ax.add_patch(patches.Rectangle(
        b[:2], *b[-2:], 
        fill=False, 
        edgecolor='white', 
        lw=2
    ))
    draw_outline(patch, 4)
def draw_text(ax, xy, txt, sz=14):
    text = ax.text(
        *xy, txt, 
        verticalalignment='top', 
        color='white',
        fontsize=sz, 
        weight='bold'
    )
    draw_outline(text, 1)
    ax = show_img(im)
b = bb_hw(im0_a[0])
draw_rect(ax, b)
draw_text(ax, b[:2], cats[im0_a[1]])

将所有内容打包起来 [1:21:20]

def draw_im(im, ann):
    ax = show_img(im, figsize=(16,8))
    for b,c in ann:
        b = bb_hw(b)
        draw_rect(ax, b)
        draw_text(ax, b[:2], cats[c], sz=16)
def draw_idx(i):
    im_a = trn_anno[i]
    im = open_image(IMG_PATH/trn_fns[i])
    print(im.shape)
    draw_im(im, im_a)
    draw_idx(17)

当你使用新数据集时，快速探索它的能力是值得的。

learn = ConvLearner.pretrained(f_model, md, metrics=[accuracy])
learn.opt_fn = optim.Adamlrf=learn.lr_find(1e-5,100)
learn.sched.plot()

我们故意删除了前几个点和最后几个点[1:38:54]，因为通常最后几个点会向无穷大飙升，以至于您无法看到任何东西，所以这通常是个好主意。但是当您只有很少的小批量时，这并不是一个好主意。当您的 LR 查找器图像看起来像上面时，您可以要求在每一端获取更多点（您还可以将批量大小设置得非常小）：

learn.sched.plot(n_skip=5, n_skip_end=1)

lr = 2e-2
learn.fit(lr, 1, cycle_len=1)
'''
epoch      trn_loss   val_loss   accuracy                      
    0      1.280753   0.604127   0.806941
'''

解冻几层：

lrs = np.array([lr/1000,lr/100,lr])
learn.freeze_to(-2)
learn.fit(lrs/5, 1, cycle_len=1)
'''
epoch      trn_loss   val_loss   accuracy                      
    0      0.780925   0.575539   0.821064
'''

解冻整个模型：

learn.unfreeze()
learn.fit(lrs/5, 1, cycle_len=2)
'''
epoch      trn_loss   val_loss   accuracy                       
    0      0.676254   0.546998   0.834285       
    1      0.460609   0.533741   0.833233
'''

准确率没有太大改善 —— 由于许多图像具有多个不同的对象，要达到那么高的准确率几乎是不可能的。

fig, axes = plt.subplots(3, 4, figsize=(12, 8))
for i,ax in enumerate(axes.flat):
    ima=md.val_ds.denorm(x)[i]
    b = md.classes[preds[i]]
    ax = show_img(ima, ax=ax)
    draw_text(ax, (0,0), b)
plt.tight_layout()

如何理解陌生的代码：

• 逐行运行代码，打印输入和输出。

方法 1[1:42:28]：您可以获取循环的内容，复制它，创建一个在其上方的单元格，粘贴它，取消缩进，设置i=0并将它们放在单独的单元格中。

方法 2[1:43:04]：使用 Python 调试器

您可以使用 Python 调试器pdb逐步执行代码。

• pdb.set_trace()设置断点

• %debug魔术以跟踪错误（在异常发生后）

您需要了解的命令：

• h（帮助）

• s（步入）

• n（下一行/跳过 —— 您也可以按回车键）

• c（继续到下一个断点）

• u（向上调用堆栈）

• d（向下调用堆栈）

• p（打印） —— 当有一个单字母变量也是一个命令时，强制打印。

• l（列出） —— 显示上面和下面的行

• q（退出） —— 非常重要

注释 [1:49:10]：[IPython.core.debugger](http://ipython.readthedocs.io/en/stable/api/generated/IPython.core.debugger.html)（右侧）使其看起来很漂亮：

围绕最大对象创建边界框可能看起来像是您以前没有做过的事情，但实际上它完全是您以前做过的事情。我们可以创建一个回归而不是分类神经网络。分类神经网络是具有 sigmoid 或 softmax 输出的神经网络，我们使用交叉熵、二元交叉熵或负对数似然损失函数。这基本上是使其成为分类器的原因。如果我们在最后没有 softmax 或 sigmoid，并且我们使用均方误差作为损失函数，那么现在它是一个预测连续数字而不是类别的回归模型。我们还知道我们可以有多个输出，就像在 planet 竞赛中一样（多分类）。如果我们将这两个想法结合起来并进行多列回归呢？

这是您考虑它像可微编程的地方。不是“我如何创建一个边界框模型？”而是更像：

• 我们需要四个数字，因此需要一个具有 4 个激活的神经网络

• 对于损失函数，什么样的函数在较低时意味着这四个数字更好？均方损失函数！

就是这样。让我们试试看。

现在我们将尝试找到最大对象的边界框。这只是一个具有 4 个输出的回归。因此，我们可以使用具有多个“标签”的 CSV。如果您还记得第 1 部分如何进行多标签分类，您的多个标签必须以空格分隔，并且文件名以逗号分隔。

BB_CSV = PATH/'tmp/bb.csv'
bb = np.array([trn_lrg_anno[o][0] for o in trn_ids])
bbs = [' '.join(str(p) for p in o) for o in bb]
df = pd.DataFrame({
    'fn': [trn_fns[o] for o in trn_ids], 
    'bbox': bbs
}, columns=['fn','bbox'])
df.to_csv(BB_CSV, index=False)
BB_CSV.open().readlines()[:5]
'''
['fn,bbox\n',
 '000012.jpg,96 155 269 350\n',
 '000017.jpg,77 89 335 402\n',
 '000023.jpg,1 2 461 242\n',
 '000026.jpg,124 89 211 336\n']
'''

f_model=resnet34
sz=224
bs=64

将continuous=True设置为告诉 fastai 这是一个回归问题，这意味着它不会对标签进行独热编码，并且将使用 MSE 作为默认的 crit。

请注意，我们必须告诉 transforms 构造函数我们的标签是坐标，以便它可以正确处理 transforms。

此外，我们使用 CropType.NO，因为我们希望将矩形图像“压缩”成正方形，而不是中心裁剪，以免意外裁剪掉一些对象。（在像 imagenet 这样的情况下，这不是太大的问题，因为有一个要分类的单个对象，通常很大且位于中心位置）。

tfms = tfms_from_model(
    f_model, sz, 
    crop_type=CropType.NO, 
    tfm_y=TfmType.COORD
)
md = ImageClassifierData.from_csv(
    PATH, JPEGS, BB_CSV, 
    tfms=tfms, 
    continuous=True
)

下周我们将看一下TfmType.COORD，但现在，只需意识到当我们进行缩放和数据增强时，需要对边界框进行操作，而不仅仅是图像。

x,y=next(iter(md.val_dl))ima=md.val_ds.denorm(to_np(x))[0]
b = bb_hw(to_np(y[0])); b
'''
array([  49.,    0.,  131.,  205.], dtype=float32)
'''
ax = show_img(ima)
draw_rect(ax, b)
draw_text(ax, b[:2], 'label')

fastai 允许您使用custom_head在卷积网络的顶部添加自己的模块，而不是默认添加的自适应池化和全连接网络。在这种情况下，我们不想进行任何池化，因为我们需要知道每个网格单元的激活。

最终层有 4 个激活，每个激活对应一个边界框坐标。我们的目标是连续的，而不是分类的，因此使用的 MSE 损失函数不会对模块输出进行任何 sigmoid 或 softmax 处理。

head_reg4 = nn.Sequential(Flatten(), nn.Linear(25088,4))
learn = ConvLearner.pretrained(f_model, md, custom_head=head_reg4)
learn.opt_fn = optim.Adam
learn.crit = nn.L1Loss()

• Flatten()：通常在 ResNet34 中，前一层具有7x7x512，因此将其展平为长度为 2508 的单个向量。

• L1Loss[1:58:22]：不是将平方误差相加，而是将误差的绝对值相加。这通常是您想要的，因为将平方误差相加会过度惩罚错误。因此，L1Loss 通常更好地处理。

learn.lr_find(1e-5,100)
learn.sched.plot(5)78%|███████▊  | 25/32 [00:04<00:01,  6.16it/s, loss=395]

lr = 2e-3
learn.fit(lr, 2, cycle_len=1, cycle_mult=2)
'''
epoch      trn_loss   val_loss                            
    0      49.523444  34.764141 
    1      36.864003  28.007317                           
    2      30.925234  27.230705
'''
lrs = np.array([lr/100,lr/10,lr])
learn.freeze_to(-2)
lrf=learn.lr_find(lrs/1000)
learn.sched.plot(1)

learn.fit(lrs, 2, cycle_len=1, cycle_mult=2)
'''
epoch      trn_loss   val_loss                            
    0      25.616161  22.83597  
    1      21.812624  21.387115                           
    2      17.867176  20.335539
'''
learn.freeze_to(-3)
learn.fit(lrs, 1, cycle_len=2)
'''
epoch      trn_loss   val_loss                            
    0      16.571885  20.948696 
    1      15.072718  19.925312
'''

验证损失是绝对值的平均值，像素偏离了。

learn.save('reg4')

x,y = next(iter(md.val_dl))
learn.model.eval()
preds = to_np(learn.model(VV(x)))
fig, axes = plt.subplots(3, 4, figsize=(12, 8))
for i,ax in enumerate(axes.flat):
    ima=md.val_ds.denorm(to_np(x))[i]
    b = bb_hw(preds[i])
    ax = show_img(ima, ax=ax)
    draw_rect(ax, b)
plt.tight_layout()

我们将在下周进一步修改这个。在这堂课之前，如果有人问你“你知道如何创建一个边界框模型吗？”，你可能会说“不，没有人教过我”。但实际上问题是：

• 您可以创建一个具有 4 个连续输出的模型吗？可以。

• 您能否创建一个损失函数，如果这 4 个输出接近另外 4 个数字，则较低？可以

然后你就完成了。

当你继续往下看时，它开始看起来有点糟糕 - 每当我们有多个对象时。这并不奇怪。总的来说，它做得相当不错。

笔记本

fastai 的尴尬问题：

分类器是任何具有分类或二元因变量的东西。与回归相对，回归是任何具有连续因变量的东西。命名有点混乱，但将在未来得到解决。在这里，continuous是True，因为我们的因变量是边界框的坐标 — 因此这实际上是一个回归器数据。

tfms = tfms_from_model(f_model, sz, crop_type=CropType.NO, 
                       aug_tfms=augs)
md = ImageClassifierData.from_csv(PATH, JPEGS, BB_CSV, tfms=tfms,
                                  **continuous=True**, bs=4)

augs = [RandomFlip(), 
        RandomRotate(30),
        RandomLighting(0.1,0.1)]

通常，我们使用 Jeremy 为我们创建的这些快捷方式，但它们只是随机增强的列表。但您可以轻松创建自己的（大多数，如果不是全部，都以“Random”开头）。

tfms = tfms_from_model(
    f_model, sz, 
    crop_type=CropType.NO,
    aug_tfms=augs
)
md = ImageClassifierData.from_csv(
    PATH, JPEGS, BB_CSV, 
    tfms=tfms,
    continuous=True, 
    bs=4
)
idx=3
fig,axes = plt.subplots(3,3, figsize=(9,9))
for i,ax in enumerate(axes.flat):
    x,y=next(iter(md.aug_dl))
    ima=md.val_ds.denorm(to_np(x))[idx]
    b = bb_hw(to_np(y[idx]))
    print(b)
    show_img(ima, ax=ax)
    draw_rect(ax, b)
'''
[115\.   63\.  240\.  311.]
[ 115\.   63\.  240\.  311.]
[ 115\.   63\.  240\.  311.]
[ 115\.   63\.  240\.  311.]
[ 115\.   63\.  240\.  311.]
[ 115\.   63\.  240\.  311.]
[ 115\.   63\.  240\.  311.]
[ 115\.   63\.  240\.  311.]
[ 115\.   63\.  240\.  311.]*

如您所见，图像会旋转并且光照会变化，但边界框不会移动，而且位置不正确[6:17]。这是数据增强的问题，当您的因变量是像素值或以某种方式与自变量相关联时，它们需要一起增强。如您在边界框坐标[ 115. 63. 240. 311.]中所看到的，我们的图像是 224 乘以 224 — 因此它既没有缩放也没有裁剪。因变量需要经历所有几何变换，就像自变量一样。

要执行此操作[7:10]，每个转换都有一个可选的tfm_y参数：

augs = [
    RandomFlip(tfm_y=TfmType.COORD),
    RandomRotate(30, tfm_y=TfmType.COORD),
    RandomLighting(0.1,0.1, tfm_y=TfmType.COORD)
]
tfms = tfms_from_model(
    f_model, sz, 
    crop_type=CropType.NO,
    tfm_y=TfmType.COORD, 
    aug_tfms=augs
)
md = ImageClassifierData.from_csv(
    PATH, JPEGS, BB_CSV, 
    tfms=tfms, 
    continuous=True, 
    bs=4
)

TrmType.COORD表示y值表示坐标。这需要添加到所有增强以及tfms_from_model中，后者负责裁剪、缩放、调整大小、填充等。

idx=3
fig,axes = plt.subplots(3,3, figsize=(9,9))
for i,ax in enumerate(axes.flat):
    x,y=next(iter(md.aug_dl))
    ima=md.val_ds.denorm(to_np(x))[idx]
    b = bb_hw(to_np(y[idx]))
    print(b)
    show_img(ima, ax=ax)
    draw_rect(ax, b)
'''
[ 48\.   34\.  112\.  188.]
[  65\.   36\.  107\.  185.]
[  49\.   27\.  131\.  195.]
[  24\.   18\.  147\.  204.]
[  61\.   34\.  113\.  188.]
[  55\.   31\.  121\.  191.]
[  52\.   19\.  144\.  203.]
[   7\.    0\.  193\.  222.]
[  52\.   38\.  105\.  182.]*

现在，边界框随图像移动并位于正确位置。您可能会注意到有时看起来像底部行中间的那个奇怪。这是我们拥有的信息的限制。如果对象占据原始边界框的角落，那么在图像旋转后，您的新边界框需要更大。因此，您必须小心不要对边界框进行过高的旋转，因为没有足够的信息使它们保持准确。如果我们正在进行多边形或分割，我们将不会遇到这个问题。

这就是为什么框变大了

tfm_y = TfmType.COORD
augs = [
    RandomFlip(tfm_y=tfm_y),
    RandomRotate(3, **p=0.5**, tfm_y=tfm_y),
    RandomLighting(0.05,0.05, tfm_y=tfm_y)
]
tfms = tfms_from_model(
    f_model, sz, 
    crop_type=CropType.NO, 
    tfm_y=tfm_y, 
    aug_tfms=augs
)
md = ImageClassifierData.from_csv(
    PATH, JPEGS, BB_CSV, 
    tfms=tfms, 
    continuous=True
)

因此，在这里，我们最多进行 3 度旋转，以避免这个问题[9:14]。它也只有一半的时间旋转（p=0.5）。

learn.summary()将通过模型运行一小批数据，并打印出每一层张量的大小。正如您所看到的，在Flatten层之前，张量的形状为 512 乘以 7 乘以 7。因此，如果它是一个秩为 1 的张量（即一个单一向量），其长度将为 25088（512 * 7 * 7），这就是为什么我们自定义标题的输入大小为 25088。输出大小为 4，因为它是边界框坐标。

head_reg4 = nn.Sequential(Flatten(), nn.Linear(25088,4))
learn = ConvLearner.pretrained(f_model, md, custom_head=head_reg4)
learn.opt_fn = optim.Adam
learn.crit = nn.L1Loss()

让我们将这两者结合起来，创建一个可以对每个图像中最大的对象进行分类和定位的东西。

训练神经网络有 3 件事情我们需要做：

1. 数据

2. 架构

3. 损失函数

架构将与我们用于分类器和边界框回归的相同，但我们将它们结合起来。换句话说，如果我们有c个类别，那么最终层中所需的激活数量是 4 加上c。4 用于边界框坐标和c个概率（每个类别一个）。

这次我们将使用额外的线性层，再加上一些 dropout，来帮助我们训练一个更灵活的模型。一般来说，如果预训练的主干适合，我们希望我们的自定义头部能够独立解决问题。因此，在这种情况下，我们尝试做了很多事情——分类器和边界框回归，所以单个线性层似乎不够。如果你想知道为什么第一个ReLU后面没有BatchNorm1d，那是因为 ResNet 主干已经有BatchNorm1d作为最后一层。

head_reg4 = nn.Sequential(
    Flatten(),
    nn.ReLU(),
    nn.Dropout(0.5),
    nn.Linear(25088,256),
    nn.ReLU(),
    nn.BatchNorm1d(256),
    nn.Dropout(0.5),
    nn.Linear(256, 4+len(cats)),
)
models = ConvnetBuilder(f_model, 0, 0, 0, custom_head=head_reg4)

learn = ConvLearner(md, models)
learn.opt_fn = optim.Adam

损失函数需要查看这些4 + len(cats)激活，并决定它们是否良好——这些数字是否准确反映了图像中最大对象的位置和类别。我们知道如何做到这一点。对于前 4 个激活，我们将像以前一样使用 L1Loss（L1Loss 类似于均方误差——它使用绝对值的和，而不是平方误差的和）。对于其余的激活，我们可以使用交叉熵损失。

def detn_loss(input, target):
    bb_t,c_t = target
    bb_i,c_i = input[:, :4], input[:, 4:]
    bb_i = F.sigmoid(bb_i)*224
    # I looked at these quantities separately first then picked a 
    # multiplier to make them approximately equal
    return F.l1_loss(bb_i, bb_t) + F.cross_entropy(c_i, c_t)*20
def detn_l1(input, target):
    bb_t,_ = target
    bb_i = input[:, :4]
    bb_i = F.sigmoid(bb_i)*224
    return F.l1_loss(V(bb_i),V(bb_t)).data
def detn_acc(input, target):
    _,c_t = target
    c_i = input[:, 4:]
    return accuracy(c_i, c_t)
learn.crit = detn_loss
learn.metrics = [detn_acc, detn_l1]

• input：激活

• target：真实值

• bb_t,c_t = target：我们的自定义数据集返回一个包含边界框坐标和类别的元组。这个赋值将对它们进行解构。

• bb_i,c_i = input[:, :4], input[:, 4:]：第一个:是用于批处理维度。

• b_i = F.sigmoid(bb_i)*224：我们知道我们的图像是 224x224。Sigmoid将强制它在 0 和 1 之间，并将其乘以 224，以帮助我们的神经网络处于必须的范围内。

**问题：**一般规则是，在 ReLU 之前还是之后放置 BatchNorm 更好[18:02]？Jeremy 建议在 ReLU 之后放置 BatchNorm，因为 BatchNorm 旨在朝着零均值一标准差移动。因此，如果你在它之后放置 ReLU，你就在零处截断它，所以没有办法创建负数。但如果你先放 ReLU 再放 BatchNorm，它确实有这个能力，并且会给出稍微更好的结果。话虽如此，无论哪种方式都不是太大的问题。你会在这门课程的这部分看到，大多数时候 Jeremy 会先 ReLU 再 BatchNorm，但有时会相反，当他想要与论文保持一致时。

问题：在 BatchNorm 之后使用 dropout 的直觉是什么？BatchNorm 不是已经很好地进行了正则化吗[19:12]？BatchNorm 做正则化的效果还可以，但是如果回想第 1 部分，我们讨论过避免过拟合的一系列方法，添加 BatchNorm 是其中之一，数据增强也是其中之一。但是仍然有可能过拟合。关于 dropout 的一个好处是它有一个参数来指定要丢弃多少。参数非常好，特别是决定要进行多少正则化，因为它让你可以构建一个很大的超参数化模型，然后决定要进行多少正则化。Jeremy 倾向于总是从p=0开始添加 dropout，然后随着添加正则化，他可以只需更改 dropout 参数，而不必担心是否保存了一个模型，他希望能够重新加载它，但如果一个中有 dropout 层而另一个中没有，它将无法加载。这样，保持一致性。

现在我们有了输入和目标，我们可以计算 L1 损失并添加交叉熵[20:39]：

F.l1_loss(bb_i, bb_t) + F.cross_entropy(c_i, c_t)*20

这是我们的损失函数。交叉熵和 L1 损失可能处于非常不同的尺度——在这种情况下，较大的那个将占主导地位。在这种情况下，Jeremy 打印出值并发现如果我们将交叉熵乘以 20，它们就会大致处于相同的尺度。

lr=1e-2
learn.fit(lr, 1, cycle_len=3, use_clr=(32,5))
'''
epoch      trn_loss   val_loss   detn_acc   detn_l1       
    0      72.036466  45.186367  0.802133   32.647586 
    1      51.037587  36.34964   0.828425   25.389733     
    2      41.4235    35.292709  0.835637   24.343577
[35.292709, 0.83563701808452606, 24.343576669692993]
'''

在训练时打印信息是很好的，所以我们抓取了 L1 损失并将其添加为指标。

learn.save('reg1_0')
learn.freeze_to(-2)
lrs = np.array([lr/100, lr/10, lr])
learn.fit(lrs/5, 1, cycle_len=5, use_clr=(32,10))
'''
epoch      trn_loss   val_loss   detn_acc   detn_l1       
    0      34.448113  35.972973  0.801683   22.918499 
    1      28.889909  33.010857  0.830379   21.689888     
    2      24.237017  30.977512  0.81881    20.817996     
    3      21.132993  30.60677   0.83143    20.138552     
    4      18.622983  30.54178   0.825571   19.832196
[30.54178, 0.82557091116905212, 19.832195997238159]
'''
learn.unfreeze()
learn.fit(lrs/10, 1, cycle_len=10, use_clr=(32,10))
'''
epoch      trn_loss   val_loss   detn_acc   detn_l1       
    0      15.957164  31.111507  0.811448   19.970753 
    1      15.955259  32.597153  0.81235    20.111022     
    2      15.648723  32.231941  0.804087   19.522853     
    3      14.876172  30.93821   0.815805   19.226574     
    4      14.113872  31.03952   0.808594   19.155093     
    5      13.293885  29.736671  0.826022   18.761728     
    6      12.562566  30.000023  0.827524   18.82006      
    7      11.885125  30.28841   0.82512    18.904158     
    8      11.498326  30.070133  0.819712   18.635296     
    9      11.015841  30.213772  0.815805   18.551489
[30.213772, 0.81580528616905212, 18.551488876342773]
'''

检测准确率在 80%左右，与之前相同。这并不令人惊讶，因为 ResNet 是设计用于分类的，所以我们不会指望能够以这种简单的方式改进事情。它确实不是设计用于边界框回归的。实际上，它是明确设计成不关心几何形状的——它取最后的 7x7 激活网格并将它们全部平均在一起，丢弃了所有关于每个位置的信息。

有趣的是，当我们同时进行准确性（分类）和边界框时，L1 似乎比我们只进行边界框回归时要好一点[22:46]。如果这对你来说是违反直觉的，那么这将是本课后需要考虑的主要问题之一，因为这是一个非常重要的想法。这个想法是——找出图像中的主要对象是比较困难的部分。然后确定边界框的确切位置和类别是一种简单的方式。因此，当你有一个同时指出对象是什么和对象在哪里的单个网络时，它将共享所有关于找到对象的计算。所有这些共享的计算非常高效。当我们反向传播类别和位置的错误时，所有这些信息都将帮助计算找到最大对象的周围。因此，每当你有多个任务共享某些概念，这些任务需要完成它们的工作，它们很可能应该至少共享网络的一些层。今天晚些时候，我们将看一个模型，其中大部分层都是共享的，除了最后一层。

以下是结果[24:34]。与以前一样，在图像中有单个主要对象时表现良好。

笔记本

我们希望继续构建比上一个模型稍微复杂的模型，这样如果某些东西停止工作，我们就知道出了什么问题。以下是上一个笔记本中的函数：

%matplotlib inline
%reload_ext autoreload
%autoreload 2
from fastai.conv_learner import *
from fastai.dataset import *

import json, pdb
from PIL import ImageDraw, ImageFont
from matplotlib import patches, patheffects
torch.backends.cudnn.benchmark=True

MC_CSV = PATH/'tmp/mc.csv'
trn_anno[12]
'''
[(array([ 96, 155, 269, 350]), 7)]
'''
mc = [set([cats[p[1]] for p in trn_anno[o]]) for o in trn_ids]
mcs = [' '.join(str(p) for p in o) for o in mc]
df = pd.DataFrame({
    'fn': [trn_fns[o] for o in trn_ids], 
    'clas': mcs
}, columns=['fn','clas'])
df.to_csv(MC_CSV, index=False)

有一个学生指出，通过使用 Pandas，我们可以比使用collections.defaultdict更简单地完成一些事情，并分享了这个gist。您越了解 Pandas，就越会意识到它是解决许多不同问题的好方法。

问题：当您在较小的模型基础上逐步构建时，您是否重复使用它们作为预训练权重？还是将其丢弃然后从头开始重新训练？当 Jeremy 像这样逐步弄清楚事情时，他通常倾向于丢弃，因为重用预训练权重会引入不必要的复杂性。但是，如果他试图达到一个可以在非常大的图像上训练的点，他通常会从更小的模型开始，并经常重用这些权重。

f_model=resnet34
sz=224
bs=64
tfms = tfms_from_model(f_model, sz, crop_type=CropType.NO)
md = ImageClassifierData.from_csv(PATH, JPEGS, MC_CSV, tfms=tfms)
learn = ConvLearner.pretrained(f_model, md)
learn.opt_fn = optim.Adamlr = 2e-2
learn.fit(lr, 1, cycle_len=3, use_clr=(32,5))
'''
epoch      trn_loss   val_loss   <lambda>                  
    0      0.104836   0.085015   0.972356  
    1      0.088193   0.079739   0.972461                   
    2      0.072346   0.077259   0.974114
[0.077258907, 0.9741135761141777]
'''
lrs = np.array([lr/100, lr/10, lr])
learn.freeze_to(-2)learn.fit(lrs/10, 1, cycle_len=5, use_clr=(32,5))
'''
epoch      trn_loss   val_loss   <lambda>                   
    0      0.063236   0.088847   0.970681  
    1      0.049675   0.079885   0.973723                   
    2      0.03693    0.076906   0.975601                   
    3      0.026645   0.075304   0.976187                   
    4      0.018805   0.074934   0.975165
[0.074934497, 0.97516526281833649]
'''
learn.save('mclas')
learn.load('mclas')
y = learn.predict()
x,_ = next(iter(md.val_dl))
x = to_np(x)
fig, axes = plt.subplots(3, 4, figsize=(12, 8))
for i,ax in enumerate(axes.flat):
    ima=md.val_ds.denorm(x)[i]
    ya = np.nonzero(y[i]>0.4)[0]
    b = '\n'.join(md.classes[o] for o in ya)
    ax = show_img(ima, ax=ax)
    draw_text(ax, (0,0), b)
plt.tight_layout()

多类别分类非常直接。在这一行中使用set的一个小调整，以便每种对象类型只出现一次。

mc = [set([cats[p[1]] for p in trn_anno[o]]) for o in trn_ids]

架构是，我们将有一个 ResNet 主干，后面跟着一个或多个 2D 卷积（现在只有一个），这将给我们一个4x4的网格。

class StdConv(nn.Module):
    def __init__(self, nin, nout, stride=2, drop=0.1):
        super().__init__()
        self.conv = nn.Conv2d(
            nin, nout, 3, 
            stride=stride, 
            padding=1
        )
        self.bn = nn.BatchNorm2d(nout)
        self.drop = nn.Dropout(drop)

    def forward(self, x): 
        return self.drop(self.bn(F.relu(self.conv(x))))

def flatten_conv(x,k):
    bs,nf,gx,gy = x.size()
    x = x.permute(0,2,3,1).contiguous()
    return x.view(bs,-1,nf//k)
class OutConv(nn.Module):
    def __init__(self, k, nin, bias):
        super().__init__()
        self.k = k
        self.oconv1 = nn.Conv2d(
            nin, (len(id2cat)+1)*k, 3, 
            padding=1
        )
        self.oconv2 = nn.Conv2d(nin, 4*k, 3, padding=1)
        self.oconv1.bias.data.zero_().add_(bias)

    def forward(self, x):
        return [
            flatten_conv(self.oconv1(x), self.k),
            flatten_conv(self.oconv2(x), self.k)
        ]
class SSD_Head(nn.Module):
    def __init__(self, k, bias):
        super().__init__()
        self.drop = nn.Dropout(0.25)
        self.sconv0 = StdConv(512,256, stride=1)
        self.sconv2 = StdConv(256,256)
        self.out = OutConv(k, 256, bias)

    def forward(self, x):
        x = self.drop(F.relu(x))
        x = self.sconv0(x)
        x = self.sconv2(x)
        return self.out(x)

head_reg4 = SSD_Head(k, -3.)
models = ConvnetBuilder(f_model, 0, 0, 0, custom_head=head_reg4)
learn = ConvLearner(md, models)
learn.opt_fn = optim.Adam

SSD_Head

1. 我们从 ReLU 和 dropout 开始

2. 然后是步幅为 1 的卷积。我们从步幅为 1 的卷积开始的原因是因为这不会改变几何形状 —— 它只让我们增加一层额外的计算。它让我们不仅可以创建一个线性层，而且现在我们的自定义头部中有一个小型神经网络。StdConv在上面定义了 —— 它执行卷积、ReLU、BatchNorm 和 dropout。您看到的大多数研究代码不会像这样定义一个类，而是一遍又一遍地写整个代码。不要这样做。重复的代码会导致错误和理解不足。

3. 步幅为 2 的卷积 [44:56]

4. 最后，步骤 3 的输出是4x4，传递给OutConv。OutConv有两个单独的卷积层，每个都是步幅为 1，因此不会改变输入的几何形状。其中一个的长度是类别数（现在忽略k和+1是为了“背景” —— 即没有检测到对象），另一个的长度是 4。与其有一个输出4+c的单个卷积层，不如有两个卷积层并将它们的输出返回到列表中。这使得这些层可以稍微专门化。我们谈到了这样一个想法，当您有多个任务时，它们可以共享层，但它们不必共享所有层。在这种情况下，我们的两个任务是创建一个分类器和创建和创建边界框回归，除了最后一个层外，它们共享每一个层。

5. 最后，我们展平卷积，因为 Jeremy 编写的损失函数期望展平的张量，但我们完全可以重写它以不这样做。

第一版本本周发布。它非常重视阐述性编程的概念，即编程代码应该是您可以用来解释一个想法的东西，理想情况下，可以像数学符号一样容易地向理解您编码方法的人解释。这个想法已经存在很长时间了，但最好的描述是杰里米最崇拜的计算机科学英雄肯·艾弗森在 1979 年的图灵奖演讲中描述的。他在 1964 年之前就一直在研究这个问题，但 1964 年是他发布这种编程方法的第一个例子，称为 APL，25 年后，他获得了图灵奖。然后他把接力棒传给了他的儿子埃里克·艾弗森。Fastai 风格指南是对这些想法的一种尝试。

损失函数需要查看这 16 组激活中的每一组，每组都有四个边界框坐标和c+1类概率，并决定这些激活是否接近或远离图像中与该网格单元最接近的对象。如果没有任何东西，那么它是否正确地预测了背景。这是非常难做到的。

损失函数需要将图像中的每个对象与这些卷积网格单元中的一个进行匹配，以便说“这个网格单元负责这个特定对象”，然后它可以继续说“好的，这 4 个坐标有多接近，类概率有多接近”。

这是我们的目标[49:56]：

我们的因变量看起来像左边的那个，我们最终的卷积层将是4x4x(c+1)，在这种情况下c=20。然后我们将其展平为一个向量。我们的目标是设计一个函数，该函数接受一个因变量和模型输出的一些特定激活，并在这些激活不是地面真实边界框的良好反映时返回更高的数字；或者如果是一个好的反映，则返回更低的数字。

x,y = next(iter(md.val_dl))
x,y = V(x),V(y)
learn.model.eval()
batch = learn.model(x)
b_clas,b_bb = batch
b_clas.size(),b_bb.size()
'''
(torch.Size([64, 16, 21]), torch.Size([64, 16, 4]))
'''

确保这些形状是合理的。现在让我们看看地面真实y[53:24]：

idx=7
b_clasi = b_clas[idx]
b_bboxi = b_bb[idx]
ima=md.val_ds.ds.denorm(to_np(x))[idx]
bbox,clas = get_y(y[0][idx], y[1][idx])
bbox,clas
'''
(Variable containing:
  0.6786  0.4866  0.9911  0.6250
  0.7098  0.0848  0.9911  0.5491
  0.5134  0.8304  0.6696  0.9063
 [torch.cuda.FloatTensor of size 3x4 (GPU 0)], 
 Variable containing:
   8
  10
  17
 [torch.cuda.LongTensor of size 3 (GPU 0)])
'''

请注意，边界框坐标已缩放到 0 和 1 之间 - 基本上我们将图像视为 1x1，因此它们是相对于图像大小的。

我们已经有了show_ground_truth函数。这个torch_gt（gt：地面真相）函数简单地将张量转换为 numpy 数组。

def torch_gt(ax, ima, bbox, clas, prs=None, thresh=0.4):
    return show_ground_truth(
        ax, ima, 
        to_np((bbox*224).long()),
        to_np(clas), 
        to_np(prs) 
        if prs is not None 
        else None, thresh
    )
fig, ax = plt.subplots(figsize=(7,7))
torch_gt(ax, ima, bbox, clas)

以上是一个地面真相。这是我们最终卷积层的4x4网格单元[54:44]：

fig, ax = plt.subplots(figsize=(7,7))
torch_gt(ax, ima, anchor_cnr, b_clasi.max(1)[1])

每个正方形框，不同的论文称其为不同的东西。您将听到的三个术语是：锚框、先验框或默认框。我们将坚持使用术语锚框。

对于这个损失函数，我们将通过一个匹配问题，看看这 16 个框中的每一个与给定正方形中的这三个地面真实对象哪一个有最高的重叠量。为了做到这一点，我们必须有一种衡量重叠量的方法，这种标准函数称为 Jaccard 指数（IoU）。

我们将逐个查看这三个对象与每个 16 个锚框的 Jaccard 重叠[57:11]。这将给我们一个3x16矩阵。

这是我们所有锚框（中心、高度、宽度）的坐标：

anchors
'''
Variable containing:
 0.1250  0.1250  0.2500  0.2500
 0.1250  0.3750  0.2500  0.2500
 0.1250  0.6250  0.2500  0.2500
 0.1250  0.8750  0.2500  0.2500
 0.3750  0.1250  0.2500  0.2500
 0.3750  0.3750  0.2500  0.2500
 0.3750  0.6250  0.2500  0.2500
 0.3750  0.8750  0.2500  0.2500
 0.6250  0.1250  0.2500  0.2500
 0.6250  0.3750  0.2500  0.2500
 0.6250  0.6250  0.2500  0.2500
 0.6250  0.8750  0.2500  0.2500
 0.8750  0.1250  0.2500  0.2500
 0.8750  0.3750  0.2500  0.2500
 0.8750  0.6250  0.2500  0.2500
 0.8750  0.8750  0.2500  0.2500
[torch.cuda.FloatTensor of size 16x4 (GPU 0)]
'''

这是 3 个地面真实对象和 16 个锚框之间的重叠量：

overlaps = jaccard(bbox.data, anchor_cnr.data)
overlaps
'''
Columns 0 to 7   
0.0000  0.0000  0.0000  0.0000  0.0000  0.0000  0.0000  0.0000    0.0000  0.0000  0.0000  0.0000  0.0000  0.0000  0.0000  0.0000    0.0000  0.0000  0.0000  0.0000  0.0000  0.0000  0.0000  0.0000 Columns 8 to 15   
0.0000  0.0091 0.0922  0.0000  0.0000  0.0315  0.3985  0.0000  0.0356  0.0549 0.0103  0.0000  0.2598  0.4538  0.0653  0.0000  0.0000  0.0000 0.0000  0.1897  0.0000  0.0000  0.0000  0.0000 [torch.cuda.FloatTensor of size 3x16 (GPU 0)]
'''

现在我们可以取维度 1（按行）的最大值，这将告诉我们每个地面真实对象的最大重叠量以及索引：

overlaps.max(1)
'''
(
  0.3985
  0.4538
  0.1897
 [torch.cuda.FloatTensor of size 3 (GPU 0)], 
  14
  13
  11
 [torch.cuda.LongTensor of size 3 (GPU 0)])
'''

我们还将查看维度 0（按列）的最大值，这将告诉我们每个网格单元与所有地面真实对象之间的最大重叠量是多少：

overlaps.max(0)
'''
(
  0.0000
  0.0000
  0.0000
  0.0000
  0.0000
  0.0000
  0.0000
  0.0000
  0.0356
  0.0549
  0.0922
  0.1897
  0.2598
  0.4538
  0.3985
  0.0000
 [torch.cuda.FloatTensor of size 16 (GPU 0)], 
  0
  0
  0
  0
  0
  0
  0
  0
  1
  1
  0
  2
  1
  1
  0
  0
 [torch.cuda.LongTensor of size 16 (GPU 0)])
'''

这里特别有趣的是，它告诉我们每个网格单元与之重叠最多的地面真实对象的索引是什么。零在这里有点过载 - 零可能意味着重叠量为零，也可能意味着它与对象索引零的重叠最大。这将被证明并不重要，但只是供参考。

有一个名为map_to_ground_truth的函数，我们现在不用担心。这是非常简单的代码，但稍微难以理解。基本上它的作用是以 SSD 论文中描述的方式将这两组重叠组合起来，将每个锚框分配给一个地面真实对象。它的分配方式是每个三个（按行最大）都被分配为是。对于其余的锚框，它们被分配给它们与至少 0.5 重叠的任何东西（按列）。如果两者都不适用，则被视为包含背景的单元格。

gt_overlap,gt_idx = map_to_ground_truth(overlaps)
gt_overlap,gt_idx
'''
(
  0.0000
  0.0000
  0.0000
  0.0000
  0.0000
  0.0000
  0.0000
  0.0000
  0.0356
  0.0549
  0.0922
  1.9900
  0.2598
  1.9900
  1.9900
  0.0000
 [torch.cuda.FloatTensor of size 16 (GPU 0)], 
  0
  0
  0
  0
  0
  0
  0
  0
  1
  1
  0
  2
  1
  1
  0
  0
 [torch.cuda.LongTensor of size 16 (GPU 0)])
'''

现在您可以看到所有分配的列表。任何gt_overlap < 0.5的地方都被分配为背景。三行最大锚框具有较高的数字以强制分配。现在我们可以将这些值组合到类别中：

gt_clas = clas[gt_idx]; gt_clas
'''
Variable containing:
  8
  8
  8
  8
  8
  8
  8
  8
 10
 10
  8
 17
 10
 10
  8
  8
[torch.cuda.LongTensor of size 16 (GPU 0)]
'''

然后添加一个阈值，最后得出正在预测的三个类：

thresh = 0.5
pos = gt_overlap > thresh
pos_idx = torch.nonzero(pos)[:,0]
neg_idx = torch.nonzero(1-pos)[:,0]
pos_idx 
'''
 11
 13
 14
[torch.cuda.LongTensor of size 3 (GPU 0)]
'''

这里是每个锚框预测的含义：

gt_clas[1-pos] = len(id2cat)
[id2cat[o] if o<len(id2cat) else 'bg' for o in gt_clas.data]
'''
['bg',
 'bg',
 'bg',
 'bg',
 'bg',
 'bg',
 'bg',
 'bg',
 'bg',
 'bg',
 'bg',
 'sofa',
 'bg',
 'diningtable',
 'chair',
 'bg']
'''

那就是匹配阶段。对于 L1 损失，我们可以：

1. 取匹配的激活（pos_idx = [11, 13, 14]）

2. 从中减去地面真实边界框

3. 取差的绝对值

4. 取平均值。

对于分类，我们可以做一个交叉熵

gt_bbox = bbox[gt_idx]
loc_loss = ((a_ic[pos_idx] - gt_bbox[pos_idx]).abs()).mean()
clas_loss  = F.cross_entropy(b_clasi, gt_clas)
loc_loss,clas_loss
'''
(Variable containing:
 1.00000e-02 
   6.5887
 [torch.cuda.FloatTensor of size 1 (GPU 0)], 
 Variable containing:
  1.0331
 [torch.cuda.FloatTensor of size 1 (GPU 0)])
'''

最终我们将得到 16 个预测的边界框，其中大多数将是背景。如果您想知道它在背景边界框方面的预测是什么，答案是它完全忽略了它。

fig, axes = plt.subplots(3, 4, figsize=(16, 12))
for idx,ax in enumerate(axes.flat):
    ima=md.val_ds.ds.denorm(to_np(x))[idx]
    bbox,clas = get_y(y[0][idx], y[1][idx])
    ima=md.val_ds.ds.denorm(to_np(x))[idx]
    bbox,clas = get_y(bbox,clas); bbox,clas
    a_ic = actn_to_bb(b_bb[idx], anchors)
    torch_gt(
        ax, ima, a_ic, 
        b_clas[idx].max(1)[1], 
        b_clas[idx].max(1)[0].sigmoid(), 
        0.01
    )
plt.tight_layout()

def ssd_1_loss(b_c,b_bb,bbox,clas,print_it=False):
    bbox,clas = get_y(bbox,clas)
    a_ic = actn_to_bb(b_bb, anchors)
    overlaps = jaccard(bbox.data, anchor_cnr.data)
    gt_overlap,gt_idx = map_to_ground_truth(overlaps,print_it)
    gt_clas = clas[gt_idx]
    pos = gt_overlap > 0.4
    pos_idx = torch.nonzero(pos)[:,0]
    gt_clas[1-pos] = len(id2cat)
    gt_bbox = bbox[gt_idx]
    loc_loss = ((a_ic[pos_idx] - gt_bbox[pos_idx]).abs()).mean()
    clas_loss  = loss_f(b_c, gt_clas)
    return loc_loss, clas_loss

def ssd_loss(pred,targ,print_it=False):
    lcs,lls = 0.,0.
    for b_c,b_bb,bbox,clas in zip(*pred,*targ):
        loc_loss,clas_loss = ssd_1_loss(b_c,b_bb,bbox,clas,print_it)
        lls += loc_loss
        lcs += clas_loss
    if print_it: 
        print(f'loc: {lls.data[0]}, clas: {lcs.data[0]}')
    return lls+lcs

ssd_loss函数是我们设置的标准，它循环遍历每个小批量中的图像，并调用ssd_1_loss函数（即一个图像的 SSD 损失）。

ssd_1_loss是所有操作发生的地方。它从bbox和clas开始解构。让我们更仔细地看一下get_y[1:10:38]：

def get_y(bbox,clas):
    bbox = bbox.view(-1,4)/sz
    bb_keep = ((bbox[:,2]-bbox[:,0])>0).nonzero()[:,0]
    return bbox[bb_keep],clas[bb_keep]

你在互联网上找到的很多代码都不能用于小批量。它一次只能做一件事，而我们不想要这样。在这种情况下，所有这些函数（get_y、actn_to_bb、map_to_ground_truth）都是在一次处理，不完全是一个小批量，而是一次处理一堆地面真实对象。数据加载器每次被馈送一个小批量以执行卷积层。因为我们可以在每个图像中有不同数量的地面真实对象，但张量必须是严格的矩形形状，fastai 会自动用零填充它（任何较短的目标值）[1:11:08]。这是最近添加的一个功能，非常方便，但这意味着你必须确保去掉这些零。因此，get_y会去掉任何只是填充的边界框。

1. 去掉填充

2. 将激活转换为边界框

3. 计算 Jaccard 指数

4. 进行地面真实的映射

5. 检查是否有大约 0.4~0.5 的重叠（不同的论文使用不同的值）

6. 找到匹配的索引

7. 为那些不匹配的分配背景类

8. 然后最终得到定位的 L1 损失，分类的二元交叉熵损失，并将它们返回，加入ssd_loss

记住，-log(pt)是交叉熵损失，焦点损失只是一个缩放版本。当我们定义二项式交叉熵损失时，您可能已经注意到默认情况下没有权重：

class BCE_Loss(nn.Module):
    def __init__(self, num_classes):
        super().__init__()
        self.num_classes = num_classes

    def forward(self, pred, targ):
        t = one_hot_embedding(targ, self.num_classes+1)
        t = V(t[:,:-1].contiguous()) #.cpu()
        x = pred[:,:-1]
        w = self.get_weight(x,t)
        return F.binary_cross_entropy_with_logits(
            x, t, w, 
            size_average=False
        ) / self.num_classes

    def get_weight(self,x,t): return None

当您调用F.binary_cross_entropy_with_logits时，可以传入权重。由于我们只想将交叉熵乘以某个值，我们可以定义get_weight。这是焦点损失的全部内容[1:50:23]：

class FocalLoss(BCE_Loss):
    def get_weight(self,x,t):
        alpha,gamma = 0.25,2.
        p = x.sigmoid()
        pt = p*t + (1-p)*(1-t)
        w = alpha*t + (1-alpha)*(1-t)
        return w * (1-pt).pow(gamma)

如果您想知道为什么 alpha 和 gamma 是 0.25 和 2，这篇论文的另一个优点是，因为他们尝试了许多不同的值，并发现这些值效果很好：

learn.lr_find(lrs/1000,1.)
learn.sched.plot(n_skip_end=2)

learn.fit(lrs, 1, cycle_len=10, use_clr=(20,10))
'''
epoch      trn_loss   val_loss                            
    0      24.263046  28.975235 
    1      20.459562  16.362392                           
    2      17.880827  14.884829                           
    3      15.956896  13.676485                           
    4      14.521345  13.134197                           
    5      13.460941  12.594139                           
    6      12.651842  12.069849                           
    7      11.944972  11.956457                           
    8      11.385798  11.561226                           
    9      10.988802  11.362164
[11.362164]
'''
learn.save('fl0')
learn.load('fl0')
learn.freeze_to(-2)
learn.fit(lrs/4, 1, cycle_len=10, use_clr=(20,10))
'''
epoch      trn_loss   val_loss                            
    0      10.871668  11.615532 
    1      10.908461  11.604334                           
    2      10.549796  11.486127                           
    3      10.130961  11.088478                           
    4      9.70691    10.72144                            
    5      9.319202   10.600481                           
    6      8.916653   10.358334                           
    7      8.579452   10.624706                           
    8      8.274838   10.163422                           
    9      7.994316   10.108068
[10.108068]
'''
learn.save('drop4')
learn.load('drop4')
plot_results(0.75)

这次情况看起来好多了。因此，我们现在的最后一步是基本上弄清楚如何只提取感兴趣的部分。

我们要做的就是遍历每对这些边界框，如果它们重叠超过一定数量，比如 0.5，使用 Jaccard 并且它们都预测相同的类别，我们将假设它们是相同的东西，并且我们将选择具有更高p值的那个。

这是非常无聊的代码，Jeremy 自己没有写，而是复制了别人的。没有特别的原因要去研究它。

def nms(boxes, scores, overlap=0.5, top_k=100):
    keep = scores.new(scores.size(0)).zero_().long()
    if boxes.numel() == 0: 
        return keep
    x1 = boxes[:, 0]
    y1 = boxes[:, 1]
    x2 = boxes[:, 2]
    y2 = boxes[:, 3]
    area = torch.mul(x2 - x1, y2 - y1)
    v, idx = scores.sort(0)  # sort in ascending order
    idx = idx[-top_k:]  # indices of the top-k largest vals
    xx1 = boxes.new()
    yy1 = boxes.new()
    xx2 = boxes.new()
    yy2 = boxes.new()
    w = boxes.new()
    h = boxes.new()

    count = 0
    while idx.numel() > 0:
        i = idx[-1]  # index of current largest val
        keep[count] = i
        count += 1
        if idx.size(0) == 1: break
        idx = idx[:-1]  # remove kept element from view
        # load bboxes of next highest vals
        torch.index_select(x1, 0, idx, out=xx1)
        torch.index_select(y1, 0, idx, out=yy1)
        torch.index_select(x2, 0, idx, out=xx2)
        torch.index_select(y2, 0, idx, out=yy2)
        # store element-wise max with next highest score
        xx1 = torch.clamp(xx1, min=x1[i])
        yy1 = torch.clamp(yy1, min=y1[i])
        xx2 = torch.clamp(xx2, max=x2[i])
        yy2 = torch.clamp(yy2, max=y2[i])
        w.resize_as_(xx2)
        h.resize_as_(yy2)
        w = xx2 - xx1
        h = yy2 - yy1
        # check sizes of xx1 and xx2.. after each iteration
        w = torch.clamp(w, min=0.0)
        h = torch.clamp(h, min=0.0)
        inter = w*h
        # IoU = i / (area(a) + area(b) - i)
        rem_areas = torch.index_select(area, 0, idx)  
        # load remaining areas)
        union = (rem_areas - inter) + area[i]
        IoU = inter/union  # store result in iou
        # keep only elements with an IoU <= overlap
        idx = idx[IoU.le(overlap)]
    return keep, count
def show_nmf(idx):
    ima=md.val_ds.ds.denorm(x)[idx]
    bbox,clas = get_y(y[0][idx], y[1][idx])
    a_ic = actn_to_bb(b_bb[idx], anchors)
    clas_pr, clas_ids = b_clas[idx].max(1)
    clas_pr = clas_pr.sigmoid()

    conf_scores = b_clas[idx].sigmoid().t().data

    out1,out2,cc = [],[],[]
    for cl in range(0, len(conf_scores)-1):
        c_mask = conf_scores[cl] > 0.25
        if c_mask.sum() == 0: 
            continue
        scores = conf_scores[cl][c_mask]
        l_mask = c_mask.unsqueeze(1).expand_as(a_ic)
        boxes = a_ic[l_mask].view(-1, 4)
        ids, count = nms(boxes.data, scores, 0.4, 50)
        ids = ids[:count]
        out1.append(scores[ids])
        out2.append(boxes.data[ids])
        cc.append([cl]*count)
    cc = T(np.concatenate(cc))
    out1 = torch.cat(out1)
    out2 = torch.cat(out2)

    fig, ax = plt.subplots(figsize=(8,8))
    torch_gt(ax, ima, out2, cc, out1, 0.1)
    for i in range(12): 
        show_nmf(i)

这里还有一些需要修复的地方[1:53:43]。技巧将是使用称为特征金字塔的东西。这就是我们将在第 14 课中做的事情。

当这篇论文出来时，Jeremy 很兴奋，因为这和 YOLO 是第一种单次通过的高质量目标检测方法。在深度学习世界中存在这种连续的历史重复，即涉及多次通过多个不同部分的事物，特别是当它们涉及一些非深度学习部分（如 R-CNN）时，随着时间的推移，它们总是被转化为单一的端到端深度学习模型。因此，我倾向于忽略它们，直到发生这种情况，因为那是人们已经找到如何将其展示为深度学习模型的时候，一旦他们这样做，它们通常会变得更快更准确。因此，SSD 和 YOLO 非常重要。

这个模型有 4 段。论文非常简洁，这意味着您需要非常仔细地阅读它们。但部分原因是，您需要知道哪些部分需要仔细阅读。当他们说“在这里我们将证明该模型的误差界限”时，您可以忽略，因为您不关心证明误差界限。但是当他们说这就是模型时，您需要仔细阅读。

Jeremy 阅读了一个部分2.1 模型[1:56:37]

如果您直接阅读这样的论文，这 4 段可能毫无意义。但是现在我们已经阅读过了，您阅读这些内容时，希望会想到“哦，这就是 Jeremy 说的，只是他们比 Jeremy 说得更好，用词更少[2:00:37]。如果您开始阅读一篇论文并说“到底是什么”，那么技巧就是开始回顾引文。

Jeremy 阅读匹配策略和训练目标（也称为损失函数）[2:01:44]

使用深度神经网络的可扩展目标检测

• “训练目标”是损失函数

• 双条和两个 2，像这样表示均方误差

  

• log©和 log(1-c)，以及 x 和(1-x)它们都是二元交叉熵的组成部分。

  

这周，浏览代码和论文，看看发生了什么。记住 Jeremy 为了让你更容易理解，他将损失函数复制到一个单元格中，并将其拆分，使每个部分都在单独的单元格中。然后在每次出售后，他打印或绘制该值。希望这是一个好的起点。