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

原文：medium.com/@hiromi_suenaga/deep-learning-2-part-2-lesson-10-422d87c3340c

译者：飞龙

协议：CC BY-NC-SA 4.0

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

视频 / 论坛

上周回顾[0:16]

自然语言处理

我们的目标是：

我们在每节课中都看到了这个想法，即采用预训练模型，去掉一些顶部的东西，用新的东西替换它，并让它做一些类似的事情。我们深入研究了这一点，ConvLearner.pretrained有一种标准的方法，可以在顶部添加一些东西，做一些特定的事情（即分类）。然后我们发现实际上我们可以在末尾添加任何我们喜欢的 PyTorch 模块，并使用custom_head让它做任何我们喜欢的事情，所以突然间你会发现我们可以做一些非常有趣的事情。

事实上，杨露说“如果我们做一个不同类型的自定义头部会怎样？”不同的自定义头部是让我们拍摄原始图片，旋转它们，然后将我们的因变量设为该旋转的相反方向，看看它是否能学会将其旋转回来。事实上，我认为现在 Google 相册有这个选项，它会自动为您旋转照片。但酷的是，正如他在这里展示的，你可以通过完全按照我们之前的课程来构建这个网络。但是你的自定义头部会输出一个单一数字，即旋转的角度，你的数据集有一个因变量，即旋转的角度。

forums.fast.ai/t/fun-with-lesson8-rotation-adjustment-things-you-can-do-without-annotated-dataset/14261/1

所以你突然意识到，有了这个骨干加自定义头部的想法，你几乎可以做任何你想做的事情 [16:30]。

• 今天，我们将探讨相同的想法，并看看它如何应用于自然语言处理。

• 在下一课中，我们将进一步探讨，如果自然语言处理和计算机视觉让你可以做相同的基本想法，我们如何将两者结合起来。我们将学习一个模型，实际上可以从图像中学习找到单词结构，从单词结构中找到图像，或从图像中找到图像。如果你想进一步做像从图像到句子（即图像字幕）或从句子到图像这样的事情，那将是基础。

• 从那里开始，我们必须更深入地思考计算机视觉，看看我们可以用这个预训练网络加自定义头部的想法做些什么其他事情。因此，我们将研究各种图像增强技术，如增加低分辨率照片的分辨率以猜测缺失的部分，或在照片上添加艺术滤镜，或将马的照片变成斑马的照片等等。

• 最后，这将使我们回到边界框。为了达到这个目标，我们首先要学习分割，这不仅仅是找出边界框在哪里，还要找出图像中每个像素所属的部分 - 所以这个像素是人的一部分，这个像素是汽车的一部分。然后我们将使用这个想法，特别是一个叫做 UNet 的想法，事实证明 UNet 的这个想法，我们可以应用到边界框上 - 这被称为特征金字塔。我们将使用这个方法来获得边界框的非常好的结果。这就是我们从这里开始的路径。这一切都将相互建立，但会带领我们进入许多不同的领域。

torchtext 转 fastai.text [18:56]：

IMDb [20:32]

from fastai.text import *
import html

BOS = 'xbos'  *# beginning-of-sentence tag*
FLD = 'xfld'  *# data field tag*PATH=Path('data/aclImdb/')

标准化格式[21:27]

CLAS_PATH=Path('data/imdb_clas/')
CLAS_PATH.mkdir(exist_ok=True)
LM_PATH=Path('data/imdb_lm/')
LM_PATH.mkdir(exist_ok=True)

CLASSES = ['neg', 'pos', 'unsup']
def get_texts(path):
    texts,labels = [],[]
    for idx,label in enumerate(CLASSES):
        for fname in (path/label).glob('*.*'):
            texts.append(fname.open('r').read())
            labels.append(idx)
    return np.array(texts),np.array(labels)
trn_texts,trn_labels = get_texts(PATH/'train')
val_texts,val_labels = get_texts(PATH/'test')
len(trn_texts),len(val_texts)
'''
(75000, 25000)
'''

col_names = ['labels','text']

np.random.seed(42)
trn_idx = np.random.permutation(len(trn_texts))
val_idx = np.random.permutation(len(val_texts))

trn_texts = trn_texts[trn_idx]
val_texts = val_texts[val_idx]
trn_labels = trn_labels[trn_idx]
val_labels = val_labels[val_idx]

df_trn = pd.DataFrame({
    'text':trn_texts, 
    'labels':trn_labels
}, columns=col_names)
df_val = pd.DataFrame({
    'text':val_texts, 
    'labels':val_labels
}, columns=col_names)
df_trn[df_trn['labels']!=2].to_csv(
    CLAS_PATH/'train.csv',
    header=False, 
    index=False
)
df_val.to_csv(
    CLAS_PATH/'test.csv', 
    header=False, 
    index=False
)
(CLAS_PATH/'classes.txt').open('w') \
    .writelines(f'**{o}\n**' for o in CLASSES)
(CLAS_PATH/'classes.txt').open().readlines()
'''
['neg\n', 'pos\n', 'unsup\n']
'''

trn_texts,val_texts = sklearn.model_selection.train_test_split(
    np.concatenate([trn_texts,val_texts]), 
    test_size=0.1
)
len(trn_texts), len(val_texts)
'''
(90000, 10000)
'''

df_trn = pd.DataFrame({
    'text':trn_texts, 
    'labels': [0]*len(trn_texts)
}, columns=col_names)
df_val = pd.DataFrame({
    'text':val_texts, 
    'labels': [0]*len(val_texts)
}, columns=col_names)
df_trn.to_csv(LM_PATH/'train.csv', header=False, index=False)
df_val.to_csv(LM_PATH/'test.csv', header=False, index=False)

语言模型标记[28:03]

chunksize=24000

re1 = re.compile(r'  +')
def fixup(x):
   x = x.replace('#39;', "'").replace('amp;', '&')
        .replace('#146;', "'").replace('nbsp;', ' ')
        .replace('#36;', '$').replace('**\\**n', "**\n**")
        .replace('quot;', "'").replace('<br />', "**\n**")
        .replace('**\\**"', '"').replace('<unk>','u_n')
        .replace(' @.@ ','.').replace(' @-@ ','-')
        .replace('**\\**', ' **\\** ')
    return re1.sub(' ', html.unescape(x))
def get_texts(df, n_lbls=1):
    labels = df.iloc[:,range(n_lbls)].values.astype(np.int64)
    texts = f'**\n{BOS}** **{FLD}** 1 ' + df[n_lbls].astype(str)
    for i in range(n_lbls+1, len(df.columns)): 
        texts += f' **{FLD}** {i-n_lbls} ' + df[i].astype(str)
    texts = texts.apply(fixup).values.astype(str) 
    tok = Tokenizer().proc_all_mp(partition_by_cores(texts))
    return tok, list(labels)

def get_all(df, n_lbls):
    tok, labels = [], []
    for i, r in enumerate(df):
        print(i)
        tok_, labels_ = get_texts(r, n_lbls)
        tok += tok_;
        labels += labels_
    return tok, labels

df_trn = pd.read_csv(
    LM_PATH/'train.csv', 
    header=None, 
    chunksize=chunksize
)
df_val = pd.read_csv(
    LM_PATH/'test.csv', 
    header=None, 
    chunksize=chunksize
)
tok_trn, trn_labels = get_all(df_trn, 1)
tok_val, val_labels = get_all(df_val, 1)
'''
0
1
2
3
0
'''
(LM_PATH/'tmp').mkdir(exist_ok=True)

' '.join(tok_trn[0])

np.save(LM_PATH/'tmp'/'tok_trn.npy', tok_trn)
np.save(LM_PATH/'tmp'/'tok_val.npy', tok_val)
tok_trn = np.load(LM_PATH/'tmp'/'tok_trn.npy')
tok_val = np.load(LM_PATH/'tmp'/'tok_val.npy')

freq = Counter(p for o in tok_trn for p in o)
freq.most_common(25)
'''
[('the', 1207984),
 ('.', 991762),
 (',', 985975),
 ('and', 587317),
 ('a', 583569),
 ('of', 524362),
 ('to', 484813),
 ('is', 393574),
 ('it', 341627),
 ('in', 337461),
 ('i', 308563),
 ('this', 270705),
 ('that', 261447),
 ('"', 236753),
 ("'s", 221112),
 ('-', 188249),
 ('was', 180235),
 ('\n\n', 178679),
 ('as', 165610),
 ('with', 159164),
 ('for', 158981),
 ('movie', 157676),
 ('but', 150203),
 ('film', 144108),
 ('you', 124114)]
'''

max_vocab = 60000
min_freq = 2
itos = [o for o,c in freq.most_common(max_vocab) if c>min_freq]
itos.insert(0, '_pad_')
itos.insert(0, '_unk_')

stoi = collections.defaultdict(
    lambda:0, 
    {v:k for k,v in enumerate(itos)}
)
len(itos)
'''
60002
'''

trn_lm = np.array([[stoi[o] for o in p] for p in tok_trn])
val_lm = np.array([[stoi[o] for o in p] for p in tok_val])

np.save(LM_PATH/'tmp'/'trn_ids.npy', trn_lm)
np.save(LM_PATH/'tmp'/'val_ids.npy', val_lm)
pickle.dump(itos, open(LM_PATH/'tmp'/'itos.pkl', 'wb'))

trn_lm = np.load(LM_PATH/'tmp'/'trn_ids.npy')
val_lm = np.load(LM_PATH/'tmp'/'val_ids.npy')
itos = pickle.load(open(LM_PATH/'tmp'/'itos.pkl', 'rb'))

vs=len(itos)
vs,len(trn_lm)
'''
(60002, 90000)
'''

预训练

这是一种新的见解，实际上并不新，我们想要预先训练一些东西。我们从第 4 课中知道，如果我们通过首先创建一个语言模型，然后将其微调为分类器来预训练我们的分类器，那是有帮助的。实际上，这给我们带来了一个新的最先进的结果 - 我们得到了最好的 IMDb 分类器结果，这个结果比之前发布的要好得多。然而，我们还没有走得那么远，因为 IMDb 电影评论与任何其他英文文档并没有太大不同；与随机字符串或甚至中文文档相比，它们之间的差异并不大。所以就像 ImageNet 让我们能够训练识别看起来像图片的东西的模型一样，我们可以将其用于与 ImageNet 无关的东西，比如卫星图像。为什么我们不训练一个擅长英语的语言模型，然后微调它以擅长电影评论呢。

这个基本的想法让 Jeremy 尝试在维基百科上构建一个语言模型。Stephen Merity 已经处理了维基百科，找到了几乎大部分内容的子集，但是丢弃了一些无关紧要的小文章，只留下了较大的文章。他称之为 wikitext103。Jeremy 拿到了 wikitext103 并在上面训练了一个语言模型。他使用了与他即将向你展示的训练 IMDb 语言模型完全相同的方法，但是他训练了一个 wikitext103 语言模型。他保存了这个模型，并且让任何想要使用它的人都可以在这个 URL 上找到。现在的想法是让我们训练一个 IMDb 语言模型，它以这些权重为起点。希望对你们来说，这是一个非常明显、非常不具争议的想法，因为这基本上是我们迄今为止在几乎每一堂课上所做的。但是当 Jeremy 去年六月或七月首次向 NLP 社区的人们提到这一点时，他们对此毫无兴趣，并被告知这是愚蠢的。因为 Jeremy 很固执，他忽略了他们，尽管他们对 NLP 了解更多，但还是尝试了。让我们看看发生了什么。

wikitext103 转换 [46:11]

# ! wget -nH -r -np -P {PATH} http://files.fast.ai/models/wt103/

em_sz,nh,nl = 400,1150,3

PRE_PATH = PATH/'models'/'wt103'
PRE_LM_PATH = PRE_PATH/'fwd_wt103.h5'

wgts = torch.load(
    PRE_LM_PATH, 
    map_location=lambda storage, loc: storage
)
enc_wgts = to_np(wgts['0.encoder.weight'])
row_m = enc_wgts.mean(0)

itos2 = pickle.load((PRE_PATH/'itos_wt103.pkl').open('rb'))
stoi2 = collections.defaultdict(
    lambda:-1, 
    {v:k for k,v in enumerate(itos2)}
)

new_w = np.zeros((vs, em_sz), dtype=np.float32)
for i,w in enumerate(itos):
    r = stoi2[w]
    new_w[i] = enc_wgts[r] if r >= 0 else row_m

wgts['0.encoder.weight'] = T(new_w)
wgts['0.encoder_with_dropout.embed.weight'] = T(np.copy(new_w))
wgts['1.decoder.weight'] = T(np.copy(new_w))

语言模型[50:18]

关于 fastai 文档项目的简要讨论[53:07]

回到语言模型[1:02:20]

wd=1e-7
bptt=70
bs=52
opt_fn = partial(optim.Adam, betas=(0.8, 0.99))
t = len(np.concatenate(trn_lm))
t, t//64
'''
(24998320, 390598)
'''

trn_dl = LanguageModelLoader(np.concatenate(trn_lm), bs, bptt)
val_dl = LanguageModelLoader(np.concatenate(val_lm), bs, bptt)
md = LanguageModelData(
    PATH, 1, vs, 
    trn_dl, val_dl, 
    bs=bs, 
    bptt=bptt
)

选择 dropout

你选择的 dropout 很重要。通过大量实验，Jeremy 发现了一些对语言模型非常有效的 dropout。但如果你的语言模型数据较少，你需要更多的 dropout。如果你有更多的数据，你可以从更少的 dropout 中受益。你不想过度正则化。Jeremy 的观点是，这些比例已经相当不错，所以只需调整这个数字（下面的0.7），我们只需将其乘以某个值。如果你过拟合，那么你需要增加这个数字，如果你欠拟合，你需要减少这个数字。因为除此之外，这些比例似乎相当不错。

drops = np.array([0.25, 0.1, 0.2, 0.02, 0.15]) * 0.7
learner= md.get_model(
    opt_fn, em_sz, nh, nl, 
    dropouti=drops[0], 
    dropout=drops[1], 
    wdrop=drops[2],
    dropoute=drops[3], 
    dropouth=drops[4]
)
learner.metrics = [accuracy]
learner.freeze_to(-1)

测量准确性

有一个看似不起眼但实际上非常有争议的重要观点是，当我们看语言模型时，我们应该衡量准确性。通常对于语言模型，我们看的是一个损失值，即交叉熵损失，但具体来说，我们几乎总是取 e 的幂次方，NLP 社区称之为“困惑度”。所以困惑度就是e^(交叉熵)。基于交叉熵损失进行比较存在很多问题。不确定现在是否有时间详细讨论，但基本问题就像我们学到的关于焦点损失的那个东西。交叉熵损失 - 如果你是对的，它希望你非常确信自己是对的。因此，它会严厉惩罚那些不说“我非常确定这是错误”的模型，而实际上是错误的。而准确性完全不关心你有多自信 - 它关心的是你是否正确。这在现实生活中更常见。准确性是我们猜测下一个词正确的频率，这是一个更稳定的数字来跟踪。这是 Jeremy 做的一个简单小事。

learner.model.load_state_dict(wgts)
lr=1e-3
lrs = lrlearner.fit(lrs/2, 1, wds=wd, use_clr=(32,2), cycle_len=1)
'''
epoch      trn_loss   val_loss   accuracy                     
    0      4.398856   4.175343   0.28551
[4.175343, 0.2855095456305303]
'''
learner.save('lm_last_ft')
learner.load('lm_last_ft')
learner.unfreeze()
learner.lr_find(start_lr=lrs/10, end_lr=lrs*10, linear=True)
learner.sched.plot()

我们训练一段时间，将交叉熵损失降至 3.9，相当于约 49.40 的困惑度（e³.9）。要让你了解语言模型的情况，如果你看一下大约 18 个月前的学术论文，你会看到他们谈论的最先进的困惑度超过一百。我们理解语言的能力以及衡量语言模型准确性或困惑度的速度并不是理解语言的一个可怕的代理。如果我能猜到你接下来要说什么，我需要很好地理解语言以及你可能会谈论的事情。困惑度数字已经下降了很多，这是令人惊讶的，而且它还会下降很多。在过去的 12-18 个月里，NLP 真的感觉像是 2011-2012 年的计算机视觉。我们开始理解迁移学习和微调，基本模型变得更好了很多。你对 NLP 能做什么和不能做什么的想法正在迅速过时。当然，NLP 仍然有很多不擅长的地方。就像在 2012 年，计算机视觉有很多不擅长的地方一样。但它的变化速度非常快，现在是非常好的时机，要么变得非常擅长 NLP，要么基于 NLP 创办初创公司，因为两年前计算机绝对擅长的一堆事情，现在还不如人类，而明年，它们将比人类好得多。

learner.fit(lrs, 1, wds=wd, use_clr=(20,10), cycle_len=15)
'''
epoch      trn_loss   val_loss   accuracy                     
    0      4.332359   4.120674   0.289563  
    1      4.247177   4.067932   0.294281                     
    2      4.175848   4.027153   0.298062                     
    3      4.140306   4.001291   0.300798                     
    4      4.112395   3.98392    0.302663                     
    5      4.078948   3.971053   0.304059                     
    6      4.06956    3.958152   0.305356                     
    7      4.025542   3.951509   0.306309                     
    8      4.019778   3.94065    0.30756                      
    9      4.027846   3.931385   0.308232                     
    10     3.98106    3.928427   0.309011                     
    11     3.97106    3.920667   0.30989                      
    12     3.941096   3.917029   0.310515                     
    13     3.924818   3.91302    0.311015                     
    14     3.923296   3.908476   0.311586
[3.9084756, 0.3115861900150776]
'''

问题：您一周内阅读论文与编码的比例是多少？天哪，你觉得呢，Rachel？你看到我。我的意思是，更多的是编码，对吧？“编码要多得多。我觉得每周也会有很大的变化”（Rachel）。有了那些边界框的东西，有很多论文，但没有明确的指引，所以我甚至不知道该先读哪一篇，然后我读了引用，但一个也不懂。所以有几周时间只是读论文，然后才知道从哪里开始编码。不过这种情况很少见。每次我开始读一篇论文，我总是确信自己不够聪明，无法理解，无论是哪篇论文。但最终我总能理解。但我尽量花尽可能多的时间编码。

几乎总是在我读完一篇论文后，即使我读完了说这是我要解决的问题的部分，我会停下来，尝试实现我认为可能解决这个问题的东西。然后我会回去读论文，读一点关于如何解决这些问题的部分，然后我会说“哦，这是个好主意”，然后尝试实现这些。这就是为什么例如，我实际上没有实现 SSD。我的自定义头部与他们的头部不同。因为我大致了解了它，然后尝试尽力创建一些东西，然后回到论文中看原因。所以当我看到焦点损失论文时，Rachel 会告诉你，我因为为什么找不到小物体而把自己逼疯了？为什么总是预测背景？我读了焦点损失论文，然后我说“原来如此！”当你深刻理解他们试图解决的问题时，情况会好得多。我发现绝大多数时间，当我读到解决问题的部分时，我会说“是的，但是我想出的这三个想法他们没有尝试。”然后你突然意识到你有了新的想法。否则，如果你只是机械地实现论文，你往往不会有关于更好方法的这些见解。

问题：您的辍学率在培训过程中是否保持不变，或者您是否相应地调整它和权重？变化的辍学率真的很有趣，最近有一些论文建议逐渐改变辍学率。逐渐减小或逐渐增加它可能是个好主意，我不确定哪个更好。也许我们中的某个人可以在这一周尝试找到它。我还没有看到它被广泛使用。我在最近写的论文中尝试了一点，取得了一些好结果。我想我是逐渐减小它的，但我记不清了。

问题：我是否正确地认为这个语言模型是建立在词嵌入上的？尝试使用短语或句子嵌入是否有价值？我问这个问题是因为我前几天从谷歌那里看到了通用句子编码器。这比那个好多了。这不仅仅是一个句子的嵌入，这是一个完整的模型。嵌入的定义就像一个固定的东西。一个句子或短语嵌入总是创建一个模型。我们有一个试图理解语言的模型。这不仅仅是一个短语或句子——最终是一个文档，而且我们不仅仅是通过整个过程训练嵌入。多年来，这一直是自然语言处理的一个巨大问题，就是他们对嵌入的依赖。即使是最近最令人兴奋的来自 AI2（艾伦人工智能研究所）的论文，他们发现在许多模型中取得了更好的结果，但再次，这是一个嵌入。他们采用了一个固定的模型，并创建了一组固定的数字，然后将其输入到模型中。但是在计算机视觉中，多年来我们已经知道，拥有固定的特征集的方法，称为计算机视觉中的超列，人们在 3 或 4 年前就停止使用了，因为对整个模型进行微调效果更好。对于那些在自然语言处理方面花费了很多时间而在计算机视觉方面花费不多时间的人，你们将不得不开始重新学习。关于这个想法，你们被告知的所有关于这些叫做嵌入的东西以及你提前学习它们然后应用这些固定的东西，无论是单词级别还是短语级别或其他级别的所有东西——不要这样做。你实际上想要创建一个预训练模型并对其进行端到端的微调，然后你会看到一些具体的结果。

问题：对于使用准确度而不是困惑度作为模型的度量标准，我们是否可以将其纳入损失函数而不仅仅将其用作度量标准？不，无论是计算机视觉还是自然语言处理或其他任何领域，你都不想这样做。这太颠簸了。所以交叉熵作为损失函数是可以的。我并不是说取代，我是同时使用。我认为查看准确度和查看交叉熵是好的。但对于你的损失函数，你需要一些平滑的东西。准确度效果不是很好。

learner.save('lm1')
learner.save_encoder('lm1_enc')

save_encoder

你会看到有两个不同版本的save。save像往常一样保存整个模型。save_encoder只保存那一部分。

换句话说，在顺序模型中，它只保存rnn_enc而不保存LinearDecoder(n_tok, emb_sz, dropout, tie_encoder=enc)（这实际上是将其转换为语言模型的部分）。在分类器中，我们不关心那部分，我们只关心rnn_end。这就是为什么我们在这里保存两个不同的模型。

learner.sched.plot_loss()

分类器标记

现在让我们创建分类器。我们将快速浏览一下，因为它是相同的。但当你在这一周回顾代码时，确信它是相同的。

df_trn = pd.read_csv(
    CLAS_PATH/'train.csv', 
    header=None, 
    chunksize=chunksize
)
df_val = pd.read_csv(
    CLAS_PATH/'test.csv', 
    header=None, 
    chunksize=chunksize)
tok_trn, trn_labels = get_all(df_trn, 1)
tok_val, val_labels = get_all(df_val, 1)
'''
0
1
0
1
'''
(CLAS_PATH/'tmp').mkdir(exist_ok=True)
np.save(CLAS_PATH/'tmp'/'tok_trn.npy', tok_trn)
np.save(CLAS_PATH/'tmp'/'tok_val.npy', tok_val)
np.save(CLAS_PATH/'tmp'/'trn_labels.npy', trn_labels)
np.save(CLAS_PATH/'tmp'/'val_labels.npy', val_labels)
tok_trn = np.load(CLAS_PATH/'tmp'/'tok_trn.npy')
tok_val = np.load(CLAS_PATH/'tmp'/'tok_val.npy')

我们不创建一个新的itos词汇表，显然我们想要使用语言模型中已有的相同词汇表，因为我们即将重新加载相同的编码器。

itos = pickle.load((LM_PATH/'tmp'/'itos.pkl').open('rb'))
stoi = collections.defaultdict(
    lambda:0, 
    {v:k for k,v in enumerate(itos)}
)
len(itos)
'''
60002
'''
trn_clas = np.array([[stoi[o] for o in p] for p in tok_trn])
val_clas = np.array([[stoi[o] for o in p] for p in tok_val])
np.save(CLAS_PATH/'tmp'/'trn_ids.npy', trn_clas)
np.save(CLAS_PATH/'tmp'/'val_ids.npy', val_clas)

分类器

trn_clas = np.load(CLAS_PATH/'tmp'/'trn_ids.npy')
val_clas = np.load(CLAS_PATH/'tmp'/'val_ids.npy')
trn_labels = np.squeeze(np.load(CLAS_PATH/'tmp'/'trn_labels.npy'))
val_labels = np.squeeze(np.load(CLAS_PATH/'tmp'/'val_labels.npy'))

模型超参数的构建是相同的。我们可以更改丢失率。选择一个尽可能大的批量大小，以防内存不足。

bptt,em_sz,nh,nl = 70,400,1150,3
vs = len(itos)
opt_fn = partial(optim.Adam, betas=(0.8, 0.99))
bs = 48
min_lbl = trn_labels.min()
trn_labels -= min_lbl
val_labels -= min_lbl
c=int(trn_labels.max())+1

TextDataset

这一部分很有趣。这里有一些有趣的东西。

trn_ds = TextDataset(trn_clas, trn_labels)
val_ds = TextDataset(val_clas, val_labels)

这里的基本思想是，对于分类器，我们确实希望查看一个文档。这个文档是积极的还是消极的？所以我们确实希望打乱文档。但是这些文档的长度不同，所以如果我们把它们全部放入一个批次中（这是 fastai 为您做的一个方便的事情）- 您可以将不同长度的东西放入一个批次中，它会自动填充它们，所以您不必担心这个问题。但是如果它们的长度差异很大，那么您将浪费大量的计算时间。如果有一件事是 2000 个字长，而其他所有东西都是 50 个字长，那意味着您最终会得到一个 2000 宽的张量。这相当恼人。所以詹姆斯·布拉德伯里是斯蒂芬·梅里蒂的同事之一，也是提出 torchtext 的人，他提出了一个聪明的想法，即“让我们按长度对数据集进行排序”。因此，使得列表中的前几个东西总体上比最后的东西短，但也有一点随机性。

这是 Jeremy 如何实现的。我们需要的第一件事是一个数据集。因此，我们有一个传递文档及其标签的数据集。这里有一个继承自 Dataset 的 TextDataSet，下面还显示了 PyTorch 中的 Dataset：

实际上，Dataset 什么也不做。它说如果您没有__getitem__，您将会收到一个错误。对于__len__也是如此。因此，这是一个抽象类。对于 TextDataset，我们将传入我们的 x 和 y，__getitem__将获取 x 和 y，并将它们返回-这不能更简单。可选地，1.他们可以颠倒它，2.在末尾添加一个流的结束，3.在开头添加一个流的开始。但我们没有做这些事情，所以我们实际上所做的就是将 x 和 y 放在一起，__getitem__将它们作为元组返回。长度是 x 的长度。这就是 Dataset 的全部内容-一个具有长度的东西，您可以对其进行索引。

将其转换为 DataLoader

trn_samp = SortishSampler(
    trn_clas, 
    key=lambda x: len(trn_clas[x]), 
    bs=bs//2
)
val_samp = SortSampler(val_clas, key=lambda x: len(val_clas[x]))
trn_dl = DataLoader(
    trn_ds, bs//2, 
    transpose=True, 
    num_workers=1,
    pad_idx=1, 
    sampler=trn_samp
)
val_dl = DataLoader(
    val_ds, bs, 
    transpose=True, 
    num_workers=1, 
    pad_idx=1, 
    sampler=val_samp
)
md = ModelData(PATH, trn_dl, val_dl)

要将其转换为 DataLoader，您只需将数据集传递给 DataLoader 构造函数，现在它将每次给您一个批次。通常您可以说 shuffle 等于 true 或 shuffle 等于 false，它会决定是否为您随机化。但在这种情况下，我们实际上将传递一个 sampler 参数，sampler 是一个我们将定义的类，告诉数据加载器如何进行洗牌。

• 对于验证集，我们将定义一个实际上只是排序的东西。它只是确定性地对其进行排序，以便所有最短的文档将在开头，所有最长的文档将在末尾，这将最小化填充的数量。

• 对于训练采样器，我们将创建一个称为 sort-ish 采样器的东西，它也进行排序（ish！）

PyTorch 的一个伟大之处在于，他们为数据加载器提出了一个 API 的想法，我们可以通过其中的新类来使其以不同的方式运行。SortSampler 是一个具有数据源长度的长度和一个迭代器的东西，迭代器只是一个按长度排序的数据源的迭代器（作为 key 传入）。对于 SortishSampler，它基本上做了同样的事情，稍微有些随机性。这只是 PyTorch 中 Jeremy 发现的另一个美丽设计。他可以采用詹姆斯·布拉德伯里的想法，他围绕这个想法写了一整套新的类，并且可以在 PyTorch 内部使用内置的钩子。您会注意到数据加载器实际上不是 PyTorch 的数据加载器-它实际上是 fastai 的数据加载器。但它基本上几乎完全抄袭了 PyTorch，但在某些方面进行了定制，以使其更快，主要是使用多线程而不是多处理。

问题：预训练的 LSTM 深度和bptt需要与我们正在训练的新模型匹配吗[1:39:00]？不，bptt根本不需要匹配。这就像我们一次看多少东西。这与架构无关。

现在我们可以调用我们之前看到的get_rnn_classifier函数[1:39:16]。它将创建几乎完全相同的编码器，我们将传入与之前相同的架构细节。但这次，我们添加的头部有一些额外的功能。其中一个是你可以添加多个隐藏层。在layers=[em_sz*3, 50, c]中：

• em_sz * 3：这是我头部（即分类器部分）的输入。

• 50：这是第一层的输出

• c：这是第二层的输出

你可以添加任意数量的层。所以你基本上可以在最后创建一个小型多层神经网络分类器。同样，对于drops=[dps[4], 0.1]，这些是在每个层之后要进行的丢弃。

# part 1
dps = np.array([0.4, 0.5, 0.05, 0.3, 0.1])
dps = np.array([0.4,0.5,0.05,0.3,0.4])*0.5
m = get_rnn_classifer(
    bptt, 20*70, c, vs, 
    emb_sz=em_sz, 
    n_hid=nh, 
    n_layers=nl, 
    pad_token=1,
    layers=[em_sz*3, 50, c], 
    drops=[dps[4], 0.1],
    dropouti=dps[0], 
    wdrop=dps[1],        
    dropoute=dps[2], 
    dropouth=dps[3]
)
opt_fn = partial(optim.Adam, betas=(0.7, 0.99))

我们将像以前一样使用 RNN_Learner。

learn = RNN_Learner(md, TextModel(to_gpu(m)), opt_fn=opt_fn)
learn.reg_fn = partial(seq2seq_reg, alpha=2, beta=1)
learn.clip=25.
learn.metrics = [accuracy]

我们将为不同层使用判别学习率[1:40:20]。

lr=3e-3
lrm = 2.6
lrs = np.array([lr/(lrm**4), lr/(lrm**3), lr/(lrm**2), lr/lrm, lr])
lrs=np.array([1e-4,1e-4,1e-4,1e-3,1e-2])

你可以尝试使用权重衰减或不使用。Jeremy 已经在尝试一些东西。

wd = 1e-7
wd = 0
learn.load_encoder('lm2_enc')

我们开始只训练最后一层，得到 92.9%的准确率：

learn.freeze_to(-1)
learn.lr_find(lrs/1000)
learn.sched.plot()
learn.fit(lrs, 1, wds=wd, cycle_len=1, use_clr=(8,3))
'''
epoch      trn_loss   val_loss   accuracy                      
    0      0.365457   0.185553   0.928719
[0.18555279, 0.9287188090884525]
'''
learn.save('clas_0')
learn.load('clas_0')

然后我们再解冻一层，得到 93.3%的准确率：

learn.freeze_to(-2)
learn.fit(lrs, 1, wds=wd, cycle_len=1, use_clr=(8,3))
'''
epoch      trn_loss   val_loss   accuracy                      
    0      0.340473   0.17319    0.933125
[0.17319041, 0.9331253991245995]
'''
learn.save('clas_1')
learn.load('clas_1')
learn.unfreeze()
learn.fit(lrs, 1, wds=wd, cycle_len=14, use_clr=(32,10))
'''
epoch      trn_loss   val_loss   accuracy                      
    0      0.337347   0.186812   0.930782  
    1      0.284065   0.318038   0.932062                      
    2      0.246721   0.156018   0.941747                      
    3      0.252745   0.157223   0.944106                      
    4      0.24023    0.159444   0.945393                      
    5      0.210046   0.202856   0.942858                      
    6      0.212139   0.149009   0.943746                      
    7      0.21163    0.186739   0.946553                      
    8      0.186233   0.1508     0.945218                      
    9      0.176225   0.150472   0.947985                      
    10     0.198024   0.146215   0.948345                      
    11     0.20324    0.189206   0.948145                      
    12     0.165159   0.151402   0.947745                      
    13     0.165997   0.146615   0.947905
[0.14661488, 0.9479046703071374]
'''
learn.sched.plot_loss()
learn.save('clas_2')

然后我们微调整个模型[1:40:47]。这是在我们的论文出现之前使用预训练模型的主要尝试：

在翻译中学到：上下文化的词向量

他们所做的是他们使用了一个预训练的翻译模型，但他们没有微调整个模型。他们只是取出了翻译模型的激活，当他们尝试 IMDb 时，他们得到了 91.8% —— 而我们只是微调了一个层就轻松超过了这个结果。他们不是最先进的，最先进的是 94.1%，而我们在微调整个模型 3 个 epochs 后达到了 94.8%，这显然是一个巨大的差异，因为从错误率来看，这已经从 5.9%下降到了 4.6%。一个简单的小技巧是回到这个笔记本的开头，颠倒所有文档的顺序，然后重新运行整个过程。当你到达fwd_wt_103这部分时，用bwd替换fwd，即将 forward 替换为 backward。这是一个向后的英语语言模型，学习如何向后阅读英语。因此，如果你重新做这整个过程，将所有文档倒置，并将其更改为向后，你现在有了第二个分类器，根据反向文档的情感将事物分类为正面或负面。然后，你可以取这两个预测的平均值，基本上你就有了一个双向模型（你分别训练了每个部分），这将使你达到 95.4%的准确率。所以我们基本上将它从 5.9%降低到了 4.6%。这种最先进技术的 20%变化几乎是闻所未闻的。这种情况并不经常发生。所以你可以看到使用迁移学习的这个想法，它是非常强大的，每个新领域都认为自己的领域太特殊，无法做到。所以这对我们所有人来说都是一个巨大的机会。

文本分类的通用语言模型微调[1:44:02]

让我展示一下他做了什么。

他拿走了我所有的代码，所以我已经做了所有的 fastai.text，正如你所看到的，它让我们能够处理大型语料库。Sebastian 读书很多，他说“这里有一篇 Yann LeCun 和一些人刚刚发表的论文，他们尝试了很多分类数据集，所以我打算在所有这些数据集上运行你的代码。” 所以这些数据集是：

其中一些文档有成千上万的文件，比我尝试的要大得多——但我认为它应该可以工作。

在我们进行下去的过程中，他有一些好主意，所以你应该确保阅读这篇论文。他说“嗯，你在课程中称之为差异学习率的东西，差异有点意思。也许我们应该重新命名它”，所以我们重新命名了。现在它被称为区分性学习率。所以我们在第一部分学到的这个想法，即对不同层使用不同的学习率，经过一些文献研究，似乎以前没有做过，所以现在正式成为一个事情——区分性学习率。这是我们在第一课中学到的东西，但现在它有了一个带有希腊字母和一切的方程式：

当你看到一个带有希腊字母的方程式时，并不一定意味着它比我们在第一课中做的任何事情更复杂，因为这个并不复杂。

再次，像逐层解冻一样的想法，似乎以前从未做过，所以现在是一个事情，它有一个非常聪明的名字“逐步解冻”。

倾斜三角形学习率

然后，如约，我们将看一下倾斜三角形学习率。这实际上不是我的想法。Leslie Smith，你们现在都知道的我最喜欢的研究人员之一，前段时间给我发了封邮件说：“我对循环学习率已经厌倦了。我不再这样做了。我现在做一个稍微不同的版本，其中有一个快速上升的周期，然后慢慢下降。我经常发现这样效果更好。”我试着回顾我所有的旧数据集，对所有数据集都效果更好——我尝试过的每一个。这就是学习率的样子。你可以通过在fit中添加use_clr=来在 fastai 中使用它。第一个数字是最高学习率和最低学习率之间的比率，因此初始学习率是峰值的 1/32。第二个数字是第一个峰值和最后一个峰值之间的比率。基本思想是，如果你正在进行一个长度为 10 的周期，你希望第一个时期是上升的部分，其他 9 个时期是下降的部分，那么你会使用 10。我发现这样效果非常好，这也是 Leslie 的建议，大约两天前，他写了这篇令人惊叹的论文：神经网络超参数的纪律方法。在这篇论文中，他描述了与此略有不同的内容，但基本思想相同。这是一篇必读的论文。它包含了 fastai 经常深入讨论的各种想法，其他人都没有谈论过。不幸的是，Leslie 在真正有时间编辑它之前不得不离开度假，所以阅读起来有点慢，但不要让这阻止你。它很棒。

右边的方程是我和 Sebastian 的论文中的。Sebastian 问：“Jeremy，你能把你写的代码背后的数学方程发给我吗？”我说：“不行，我只是写了代码。我无法把它转化为数学”，所以他为此找到了数学解。

连接池[1:51:36]

所以你可能已经注意到，我们分类器的第一层等于嵌入大小的 3 倍。为什么是 3 倍？因为，再次强调，这似乎是以前没有人做过的事情，所以一个新的想法“连接池”。我们对激活序列进行平均池化，对激活序列进行最大池化，以及最终的一组激活，并将它们全部连接在一起。这是我们在第一部分讨论过的内容，但在文献中似乎没有出现过，所以现在称为“连接池”，现在有一个方程，但这就是全部的实现。所以你可以阅读这篇论文，看看 fastai 代码如何实现每个部分。

BPT3C[1:52:46]

一个有趣的地方是RNN_Encoder和 MultiBatchRNN 编码器之间的区别。那里有什么不同？关键区别在于，语言模型的普通 RNN 编码器，我们可以一次只做一个bptt块。但是对于分类器，我们需要处理整个文档。在我们决定它是积极的还是消极的之前，我们需要处理整个电影评论。整个电影评论可能很容易就有 2000 个字，而且我无法将 2000 个字的梯度适应我的 GPU 内存中的每一个权重。那我们该怎么办？所以这个想法非常简单，就是我一次处理整个序列长度的一个bptt批次。然后我调用super().forward（换句话说，RNN_Encoder）来获取它的输出，然后我有这个最大序列长度参数，它说“好的，只要你不超过那个序列长度，就开始将其附加到我的输出列表中。”换句话说，它发送回这个池的东西只有我们要求它保留的那么多激活。这样，你可以弄清楚你的特定 GPU 可以处理多少max_seq。所以它仍然使用整个文档，但是假设max_seq是 1000 个字，你最长的文档长度是 2000 个字。它仍然会通过 RNN 为这前 1000 个字创建状态，但实际上不会存储前 1000 个字的激活以进行反向传播。它只会保留最后 1000 个字。这意味着它无法将损失反向传播到在前 1000 个字中创建的任何状态，基本上那已经消失了。所以这是一个非常简单的代码片段，老实说，当我写它时，我没有花太多时间考虑，因为它似乎显而易见这是唯一可能起作用的方式。但是再次，这似乎是一个新事物，所以我们现在有了文本分类的时间反向传播。你可以看到这篇论文中有很多小片段。

结果

结果是什么？在我们尝试的每个数据集上，我们得到的结果都比以往任何一篇学术论文在文本分类方面都要好。各种不同类型。老实说，IMDb 是我花时间尝试优化模型的唯一一个，所以大多数情况下，我们只是用第一个出来的结果。所以如果我们真的花时间在上面，我认为结果会更好。这些比较的对象大多数在每个表格上都不同，因为它们是整体上定制的算法。所以这就是说一个简单的微调算法可以击败这些真正定制的算法。

消融研究

这是 Sebastian 做的消融研究。我非常希望如果要发表一篇论文，我们必须说明它为什么有效。所以 Sebastian 去尝试移除我提到的所有不同贡献。如果我们不使用逐渐冻结会怎样？如果我们不使用区分性学习率会怎样？如果我们使用余弦退火而不是区分性学习率会怎样？如果我们不使用维基百科进行任何预训练会怎样？如果我们不进行任何微调会怎样？对我来说真正有趣的是，如果我们只使用一百个训练样本（与 200、500 等相比），在 IMDb 上的验证错误率是多少。你可以看到，非常有趣的是，这种方法的完整版本在只有一百个训练样本时几乎与完整的 20000 个训练样本一样准确。而如果你从一百开始训练，几乎是随机的。这是我预料到的。我告诉 Sebastian 我真的认为这在没有太多数据时最有益。这就是 fastai 最感兴趣的地方——小数据范围，小计算范围等等。所以他进行了这些研究来检查。

运行消融研究的技巧

技巧＃1：VNC

第一个技巧是我知道你们都会觉得非常方便的。我知道当你在 Jupyter 笔记本中运行某些东西时，当你失去互联网连接的时间足够长，它会认为你已经离开，然后你的会话消失了，你必须从头开始。那么你该怎么办？有一个非常简单而酷炫的东西叫做 VNC，你可以在您的 AWS 实例或 PaperSpace 上安装它，或者其他地方：

• X Windows（xorg）

• 轻量级窗口管理器（lxde-core）

• VNC 服务器（tightvncserver）

• Firefox（firefox）

• 终端（lxterminal）

• 一些字体（xfonts-100dpi）

将这些行添加到您的./vnc/xstartup配置文件的末尾，然后运行这个命令（tightvncserver :13 -geometry 1200x900）：

现在正在运行一个服务器，您可以在您的计算机上运行 TightVNC Viewer 或任何 VNC 查看器，然后将其指向您的服务器。但具体来说，您要做的是使用 SSH 端口转发将：5913 转发到 localhost：5913：

然后连接到本地主机的端口 5013。它会将其发送到服务器上的端口 5913，这是 VNC 端口（因为你说了:13），它会显示一个 X Windows 桌面。然后你可以点击 Linux 的开始按钮，点击 Firefox，现在你有了 Firefox。你在 Firefox 中看到这里写着 localhost，因为这个 Firefox 是在我的 AWS 服务器上运行的。所以你现在运行 Firefox，启动你的东西，然后关闭你的 VNC 查看器，记住 Firefox 显示在这个虚拟 VNC 显示上，而不是在一个真实的显示器上，所以稍后那天，你再次登录 VNC 查看器，它会再次弹出。所以这就像一个持久的桌面，而且速度惊人快。它运行得非常好。有很多不同的 VNC 服务器和客户端，但这个对我来说效果很好。

技巧＃2：Google Fire[2:01:27]

if __name__ == '__main__': 
    fire.Fire(train_clas)

技巧＃3：IMDb 脚本[2:02:47]

技巧＃4：pip install -e[2:03:32]

技巧 #5: SentencePiece

如果你愿意，这是你可以尝试的东西。你不必进行标记化。你可以标记化所谓的子词单元，而不是标记化单词。例如，“unsupervised”可以被标记化为“un”和“supervised”。“Tokenizer”可以被标记化为[“token”, “izer”]。然后你可以做同样的事情。使用子词单元的语言模型，使用子词单元的分类器等。这样做效果如何？我开始尝试并且没有花太多时间，我得到的分类结果几乎和使用单词级标记化一样好 —— 不完全一样，但几乎一样好。我怀疑通过更仔细的思考和尝试，也许我可以得到同样好甚至更好的结果。但即使我不能，如果你创建一个子词单元维基文本模型，然后 IMDb 语言模型，然后分类器正向和反向，然后将其与正向和反向的单词级模型合并，你应该能够超越我们。所以这是一个你可能能够超越我们最先进结果的方法。

Sebastian 告诉我这个特定项目 —— 谷歌有一个名为 sentence peace 的项目，实际上使用神经网络来找出单词的最佳拆分方式，因此你最终会得到一个子词单元的词汇表。在我的尝试中，我发现创建大约 30,000 个子词单元的词汇表似乎是最佳的。如果你感兴趣，这是你可以尝试的东西。安装起来有点麻烦 —— 它是 C++，没有创建错误消息，但它会工作。有一个 Python 库可以用于此。如果有人尝试这个，我很乐意帮助他们让它工作。对于子词和单词级别分类的集成，几乎没有什么实验，我认为这应该是最佳的方法。

祝你有一个美好的一周！

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

原文：medium.com/@hiromi_suenaga/deep-learning-2-part-2-lesson-11-61477d24dc34

译者：飞龙

协议：CC BY-NC-SA 4.0

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

链接

论坛 / 视频

开始之前：

• 1cycle 策略 由 Sylvain Gugger 提出。基于 Leslie Smith 的新论文，该论文结合了之前的两篇关键论文（循环学习率和超级收敛），并通过一系列实验来展示如何实现超级收敛。超级收敛让您训练模型比之前的分阶段方法快五倍（比 CLR 更快，尽管不到五倍）。超级收敛让您可以通过 1 到 3 之间的极高学习率进行训练。超级收敛的有趣之处在于，您在相当大比例的 epochs 中以非常高的学习率进行训练，而在此期间，损失并没有真正得到很大的改善。但诀窍在于它在空间中进行了大量搜索，以找到真正通用的区域。Sylvain 在 fastai 中实现了这一点，通过补充缺失的部分，然后确认他确实在 CIFAR10 上实现了超级收敛。目前称为use_clr_beta，但将来会更名。他还在 fastai 库中添加了循环动量。

• 如何使用序列到序列模型创建神奇的数据产品 由 Hamel Husain 撰写。他在博客中介绍了训练一个模型来总结 GitHub 问题。这是基于他的博客创建的 Kubeflow 团队的演示。

神经机器翻译 [5:36]

神经机器翻译的四个重大优势[8:36]

BiLSTMs（+Attn）不仅适用于神经机器翻译

我们将使用带有注意力的双向 GRU（基本上与 LSTM 相同）-正如您在上面看到的，这些一般想法也可以用于许多其他事情。

让我们来看代码[9:47]

1. 数据

像往常一样，我们需要(x, y)对。在这种情况下，x：法语句子，y：英语句子，您将与之比较您的预测。我们需要许多这些法语句子及其相应的英语句子的元组-这被称为“平行语料库”，比语言模型的语料库更难找到。对于语言模型，我们只需要某种语言的文本。对于任何生活语言，互联网上至少会有几千兆字节的文本供您获取。对于翻译，有一些非常好的欧洲语言的平行语料库可用。欧洲议会有每种欧洲语言的每个句子。任何提交给联合国的东西都会被翻译成许多语言。对于法语到英语，我们有一个特别好的东西，那就是几乎任何半官方的加拿大网站都会有法语版本和英语版本[12:13]。

翻译文件

from fastai.text import *

从www.statmt.org/wmt15/translation-task.html获取的法语/英语平行文本。这是由克里斯·卡利森-伯奇（Chris Callison-Burch）创建的，他爬取了数百万个网页，然后使用一组简单的启发式规则将法语 URL 转换为英语 URL（即用“fr”替换为“en”和其他大约 40 个手写规则），并假设这些文档是彼此的翻译。

PATH = Path('data/translate')
TMP_PATH = PATH/'tmp'
TMP_PATH.mkdir(exist_ok=True)
fname='giga-fren.release2.fixed'
en_fname = PATH/f'{fname}.en'
fr_fname = PATH/f'{fname}.fr'

对于边界框，所有有趣的东西都在损失函数中，但对于神经翻译，所有有趣的东西都将在架构中[13:01]。让我们快速浏览一下，杰里米希望你特别考虑的一件事是我们在语言建模与神经翻译之间所做任务及如何做任务的关系或相似之处。

第一步是做与语言模型中相同的事情，即通过 RNN 传递一个句子[13:35]。

现在在分类模型中，我们有一个解码器，它接收 RNN 输出并提取三个内容：在所有时间步上的maxpool和meanpool，以及在最后一个时间步上的 RNN 的值，将所有这些堆叠在一起并通过一个线性层[14:24]。大多数人不这样做，只使用最后一个时间步，所以我们今天将要讨论的所有内容都使用最后一个时间步。

我们首先通过 RNN 将输入句子传递，然后得到一些“隐藏状态”（即代表编码了句子的 RNN 的输出的向量）。

编码器≈骨干[15:18]

序列输出[17:47]

快速回顾第 6 课 [18:20]

re_eq = re.compile('^(Wh[^?.!]+\?)')
re_fq = re.compile('^([^?.!]+\?)')
lines = (
    (re_eq.search(eq), re_fq.search(fq)) 
    for eq, fq in zip(
        open(en_fname, encoding='utf-8'), 
        open(fr_fname, encoding='utf-8')
    )
)
qs = [(e.group(), f.group()) for e,f in lines if e and f]

pickle.dump(qs, (PATH/'fr-en-qs.pkl').open('wb'))
qs = pickle.load((PATH/'fr-en-qs.pkl').open('rb'))

qs[:5], len(qs)
'''
([('What is light ?', 'Qu’est-ce que la lumière?'),
  ('Who are we?', 'Où sommes-nous?'),
  ('Where did we come from?', "D'où venons-nous?"),
  ('What would we do without it?', 'Que ferions-nous sans elle ?'),
  ('What is the absolute location (latitude and longitude) of Badger, Newfoundland and Labrador?',
   'Quelle sont les coordonnées (latitude et longitude) de Badger, à Terre-Neuve-etLabrador?')],
 52331)
'''

en_qs,fr_qs = zip(*qs)

en_tok = Tokenizer.proc_all_mp(partition_by_cores(en_qs))
fr_tok = Tokenizer.proc_all_mp(partition_by_cores(fr_qs), 'fr')

en_tok[0], fr_tok0

np.percentile([len(o) for o in en_tok], 90), 
np.percentile([len(o) for o in fr_tok], 90)
'''
(23.0, 28.0)
'''
keep = np.array([len(o)<30 for o in en_tok])
en_tok = np.array(en_tok)[keep]
fr_tok = np.array(fr_tok)[keep]
pickle.dump(en_tok, (PATH/'en_tok.pkl').open('wb'))
pickle.dump(fr_tok, (PATH/'fr_tok.pkl').open('wb'))
en_tok = pickle.load((PATH/'en_tok.pkl').open('rb'))
fr_tok = pickle.load((PATH/'fr_tok.pkl').open('rb'))

def toks2ids(tok,pre):
    freq = Counter(p for o in tok for p in o)
    itos = [o for o,c in freq.most_common(40000)]
    itos.insert(0, '_bos_')
    itos.insert(1, '_pad_')
    itos.insert(2, '_eos_')
    itos.insert(3, '_unk')
    stoi = collections.defaultdict(
        lambda: 3, 
        {v:k for k,v in enumerate(itos)}
    )
    ids = np.array([([stoi[o] for o in p] + [2]) for p in tok])
    np.save(TMP_PATH/f'{pre}_ids.npy', ids)
    pickle.dump(itos, open(TMP_PATH/f'{pre}_itos.pkl', 'wb'))
    return ids,itos,stoi

en_ids,en_itos,en_stoi = toks2ids(en_tok,'en')
fr_ids,fr_itos,fr_stoi = toks2ids(fr_tok,'fr')

def load_ids(pre):
    ids = np.load(TMP_PATH/f'{pre}_ids.npy')
    itos = pickle.load(open(TMP_PATH/f'{pre}_itos.pkl', 'rb'))
    stoi = collections.defaultdict(
        lambda: 3, 
        {v:k for k,v in enumerate(itos)}
    )
    return ids,itos,stoien_ids,en_itos,en_stoi = load_ids('en')
fr_ids,fr_itos,fr_stoi = (
    load_ids('fr')[fr_itos[o] for o in fr_ids[0]], 
    len(en_itos), 
    len(fr_itos)
)
'''
(['qu’', 'est', '-ce', 'que', 'la', 'lumière', '?', '_eos_'], 17573, 24793)
'''

词向量[32:53]

# !pip install git+https://github.com/facebookresearch/fastText.git
import fastText as ft

en_vecs = ft.load_model(str((PATH/'wiki.en.bin')))
fr_vecs = ft.load_model(str((PATH/'wiki.fr.bin')))

def get_vecs(lang, ft_vecs):
    vecd = {
        w:ft_vecs.get_word_vector(w) 
        for w in ft_vecs.get_words()
    }
    pickle.dump(vecd, open(PATH/f'wiki.{lang}.pkl','wb'))
    return vecden_vecd = get_vecs('en', en_vecs)
fr_vecd = get_vecs('fr', fr_vecs)
en_vecd = pickle.load(open(PATH/'wiki.en.pkl','rb'))
fr_vecd = pickle.load(open(PATH/'wiki.fr.pkl','rb'))
ft_words = ft_vecs.get_words(include_freq=True)
ft_word_dict = {k:v for k,v in zip(*ft_words)}
ft_words = sorted(
    ft_word_dict.keys(), 
    key=lambda x: ft_word_dict[x]
)

dim_en_vec = len(en_vecd[','])
dim_fr_vec = len(fr_vecd[','])
dim_en_vec,dim_fr_vec
'''
(300, 300)
'''

en_vecs = np.stack(list(en_vecd.values()))
en_vecs.mean(),en_vecs.std()
'''
(0.0075652334, 0.29283327)
'''

模型数据[36:48]

enlen_90 = int(np.percentile([len(o) for o in en_ids], 99))
frlen_90 = int(np.percentile([len(o) for o in fr_ids], 97))
enlen_90,frlen_90
'''
(29, 33)
'''

en_ids_tr = np.array([o[:enlen_90] for o in en_ids])
fr_ids_tr = np.array([o[:frlen_90] for o in fr_ids])
class Seq2SeqDataset(Dataset):
    def __init__(self, x, y): 
        self.x,self.y = x,y
    def __getitem__(self, idx): 
        return A(self.x[idx], self.y[idx])
    def __len__(self): 
        return len(self.x)

训练集和验证集[39:03]

np.random.seed(42)
trn_keep = np.random.rand(len(en_ids_tr))>0.1
en_trn,fr_trn = en_ids_tr[trn_keep],fr_ids_tr[trn_keep]
en_val,fr_val = en_ids_tr[~trn_keep],fr_ids_tr[~trn_keep]
len(en_trn),len(en_val)
'''
(45219, 5041)
'''

trn_ds = Seq2SeqDataset(fr_trn,en_trn)
val_ds = Seq2SeqDataset(fr_val,en_val)

bs=125
trn_samp = SortishSampler(
    en_trn, 
    key=lambda x: len(en_trn[x]), 
    bs=bs
)
val_samp = SortSampler(en_val, key=lambda x: len(en_val[x]))
trn_dl = DataLoader(
    trn_ds, bs, 
    transpose=True, 
    transpose_y=True, 
    num_workers=1, 
    pad_idx=1, 
    pre_pad=False, 
    sampler=trn_samp
)
val_dl = DataLoader(
    val_ds, int(bs*1.6), 
    transpose=True, 
    transpose_y=True, 
    num_workers=1, 
    pad_idx=1,
    pre_pad=False, 
    sampler=val_samp
)
md = ModelData(PATH, trn_dl, val_dl)

架构[46:59]

• 这个架构将接受我们的标记序列。

• 它将把它们传递给一个编码器（又名骨干）。

• 这将输出最终的隐藏状态，对于每个句子，它只是一个单一的向量。

这一切都不会是新的[47:41]。这一切都将使用我们已经学过的非常直接简单的技术。

• 然后我们将把它传递到另一个 RNN 中，这是一个解码器。这将有一些新的东西，因为我们需要一个可以逐个单词地进行处理的东西。它会一直进行下去，直到它认为已经完成了句子。它不知道句子将有多长。它会一直进行下去，直到它认为已经完成了句子，然后停止并返回一个句子。

def create_emb(vecs, itos, em_sz):
    emb = nn.Embedding(len(itos), em_sz, padding_idx=1)
    wgts = emb.weight.data
    miss = []
    for i,w in enumerate(itos):
        try: 
            wgts[i] = torch.from_numpy(vecs[w]*3)
        except: 
            miss.append(w)
    print(len(miss),miss[5:10])
    return emb
nh,nl = 256,2

让我们从编码器开始[48:15]。在这里的变量命名方面，编码器和解码器具有相同的属性。编码器版本有enc，解码器版本有dec。

• emb_enc：编码器的嵌入

• gru：RNN。GRU 和 LSTM 几乎是相同的东西。

我们需要创建一个嵌入层，因为要记住 - 我们传递的是单词在词汇表中的索引。我们想要获取它们的 fast.text 嵌入。随着时间的推移，我们可能还想微调以端到端地训练该嵌入。

create_emb[49:37]：现在重要的是您知道如何设置嵌入的行和列，因此行数必须等于您的词汇量大小 - 因此每个词汇都有一个词向量。嵌入的大小由 fast.text 确定，fast.text 嵌入的大小为 300。因此我们也必须使用大小 300，否则我们无法使用它们的嵌入开始。

nn.Embedding最初会给我们一组随机的嵌入[50:12]。所以我们将遍历每一个，如果在 fast.text 中找到它，我们将用 fast.text 嵌入替换它。再次提醒您应该已经知道的是（emb.weight.data）：

• 一个可学习的 PyTorch 模块具有weight属性。

• weight属性是一个具有data属性的Variable。

• data属性是一个张量

现在我们有了权重张量，我们可以遍历我们的词汇表，查找我们预训练向量中的单词，如果找到，我们将用该预训练向量替换随机权重[52:35]。随机权重的标准差为 1。我们的预训练向量的标准差约为 0.3。所以，这是 Jeremy 在原型设计时做的一种巧妙的事情，他只是将其乘以 3。当您看到这个视频时，我们可能已经能够将所有这些序列到序列的内容放入 fastai 库中，您在那里不会找到这样的可怕的黑客行为（希望如此）。但在原型设计时可以尝试各种方法。有些东西可能不在 fast.text 中，这种情况下，我们将继续跟踪[53:22]。打印语句是为了让我们看到发生了什么（即为什么我们会丢失东西？）。记住我们大约有 30,000 个，所以我们不会丢失太多。

3097 ['l’', "d'", 't_up', 'd’', "qu'"]
1285 ["'s", '’s', "n't", 'n’t', ':']

Jeremy 已经开始做一些关于将大词汇量处理整合到 fastai 中的工作 - 还没有完成，但希望到达这里时，这种工作将是可能的[56:50]。

class Seq2SeqRNN(nn.Module):
    def __init__(self, vecs_enc, itos_enc, em_sz_enc, vecs_dec, 
                 itos_dec, em_sz_dec, nh, out_sl, nl=2):
        super().__init__()
        self.nl,self.nh,self.out_sl = nl,nh,out_sl
        self.emb_enc = create_emb(vecs_enc, itos_enc, em_sz_enc)
        self.emb_enc_drop = nn.Dropout(0.15)
        self.gru_enc = nn.GRU(
            em_sz_enc, nh, 
            num_layers=nl, 
            dropout=0.25
        )
        self.out_enc = nn.Linear(nh, em_sz_dec, bias=False)

        self.emb_dec = create_emb(vecs_dec, itos_dec, em_sz_dec)
        self.gru_dec = nn.GRU(
            em_sz_dec, 
            em_sz_dec, 
            num_layers=nl, 
            dropout=0.1
        )
        self.out_drop = nn.Dropout(0.35)
        self.out = nn.Linear(em_sz_dec, len(itos_dec))
        self.out.weight.data = self.emb_dec.weight.data

    def forward(self, inp):
        sl,bs = inp.size()
        h = self.initHidden(bs)
        emb = self.emb_enc_drop(self.emb_enc(inp))
        enc_out, h = self.gru_enc(emb, h)
        h = self.out_enc(h)

        dec_inp = V(torch.zeros(bs).long())
        res = []
        for i in range(self.out_sl):
            emb = self.emb_dec(dec_inp).unsqueeze(0)
            outp, h = self.gru_dec(emb, h)
            outp = self.out(self.out_drop(outp[0]))
            res.append(outp)
            dec_inp = V(outp.data.max(1)[1])
            if (dec_inp==1).all(): 
                break
        return torch.stack(res)

    def initHidden(self, bs): 
        return V(torch.zeros(self.nl, bs, self.nh))

要知道的关键是编码器接收我们的输入并输出一个隐藏向量，希望它能学会包含关于句子内容以及如何设置的所有信息[58:49]。如果它做不到，我们就不能将其输入解码器，并希望它将句子翻译成另一种语言。这就是我们希望它学会的。我们不会采取任何特殊措施来让它学会这样做 - 我们只会做三件事（数据、架构、损失函数），然后抱着幸运的心态。

解码器[59:58]：我们现在如何处理新的部分？新部分的基本思想是相同的。我们将做完全相同的事情，但我们将编写自己的 for 循环。这个 for 循环将完全执行 PyTorch 中编码器内部的 for 循环，但我们将手动执行。for 循环有多大？它是一个输出序列长度（out_sl），这是传递给构造函数的一个参数，它等于最长英语句子的长度。因为我们正在翻译成英语，所以在这个语料库中至少不可能比这更长。如果我们将其用于某个更长的不同语料库，这将失败 —— 当然你可以传入不同的参数。因此，基本思想是相同的[1:01:06]。

• 我们将通过嵌入层。

• 我们将通过 RNN、dropout 和线性层。

• 然后，我们将输出附加到一个列表中，该列表将堆叠成一个单个张量并返回。

通常，递归神经网络一次处理整个序列，但我们有一个 for 循环来分别处理序列的每个部分[1:01:37]。因此，我们必须在开头添加一个主要单位轴（.unsqueeze(0)）来表示这是一个长度为一的序列。我们实际上并没有充分利用递归网络 —— 我们可以很容易地用线性层重写这个。

要注意的一件事是dec_inp[1:02:34]：嵌入的输入是什么？答案是前一个我们翻译的单词。基本思想是，如果你试图翻译新句子的第四个单词，但你不知道刚说的第三个单词是什么，那将非常困难。因此，我们将在每个时间步骤中提供这个信息。在开始时，前一个单词是什么？没有。具体来说，我们将从一个流的开始标记（_bos_）开始，该标记为零。

outp[1:05:24]：它是一个张量，其长度等于我们英语词汇中的单词数，其中包含每个单词是该单词的概率。

outp.data.max：它在其张量中查找具有最高概率的单词。PyTorch 中的max返回两个值：第一个是最大概率，第二个是该最大概率在数组中的索引。因此，我们想要第二个项目，即具有最大值的单词索引。

dec_inp：它包含单词在词汇表中的索引。如果是 1（即填充），那么表示我们已经完成了 —— 我们已经以一堆填充结束了。如果不是 1，让我们回去继续。

每次，我们将输出（不是单词，而是概率）附加到列表[1:06:48]中，然后将其堆叠成一个张量，然后我们可以继续将其馈送到损失函数中。

损失函数[1:07:13]

def seq2seq_loss(input, target):
    sl,bs = target.size()
    sl_in,bs_in,nc = input.size()
    if sl>sl_in: input = F.pad(input, (0,0,0,0,0,sl-sl_in))
    input = input[:sl]
    return F.cross_entropy(input.view(-1,nc), target.view(-1))

opt_fn = partial(optim.Adam, betas=(0.8, 0.99))

rnn = Seq2SeqRNN(
    fr_vecd, fr_itos, 
    dim_fr_vec, 
    en_vecd, en_itos, 
    dim_en_vec, 
    nh, enlen_90
)
learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)
learn.crit = seq2seq_loss
'''
3097 ['l’', "d'", 't_up', 'd’', "qu'"]
1285 ["'s", '’s', "n't", 'n’t', ':']
'''

learn.lr_find()
learn.sched.plot()

lr=3e-3
learn.fit(lr, 1, cycle_len=12, use_clr=(20,10))
'''
epoch      trn_loss   val_loss                              
    0      5.48978    5.462648  
    1      4.616437   4.770539                              
    2      4.345884   4.37726                               
    3      3.857125   4.136014                              
    4      3.612306   3.941867                              
    5      3.375064   3.839872                              
    6      3.383987   3.708972                              
    7      3.224772   3.664173                              
    8      3.238523   3.604765                              
    9      2.962041   3.587814                              
    10     2.96163    3.574888                              
    11     2.866477   3.581224
[3.5812237]
'''
learn.save('initial')
learn.load('initial')

测试

记住，学习器的模型属性是一个标准的 PyTorch 模型，所以我们可以传递一些 x，我们可以从验证集中获取，或者您可以使用 learn.predict_array 或其他方法来获取一些预测。然后我们通过 .max()[1] 将这些预测转换为单词，以获取概率最高的单词的索引。然后我们可以通过一些示例，打印出法语、正确的英语和预测的英语，对于那些不是填充的内容。

x,y = next(iter(val_dl))
probs = learn.model(V(x))
preds = to_np(probs.max(2)[1])

for i in range(180,190):
    print(' '.join([fr_itos[o] for o in x[:,i] if o != 1]))
    print(' '.join([en_itos[o] for o in y[:,i] if o != 1]))
    print(' '.join([en_itos[o] for o in preds[:,i] if o!=1]))
    print()
'''
quels facteurs pourraient influer sur le choix de leur emplacement ? _eos_
what factors influencetheir location ? _eos_
what factors might might influence on the their ? ? _eos_

qu’ est -ce qui ne peut pas changer ? _eos_
what can not change ? _eos_
what not change change ? _eos_

que faites - vous ? _eos_
what do you do ? _eos_
what do you do ? _eos_

qui réglemente les pylônes d' antennes ? _eos_
who regulates antenna towers ? _eos_
who regulates the doors doors ? _eos_

où sont - ils situés ? _eos_
where are they located ? _eos_
where are the located ? _eos_

quelles sont leurs compétences ? _eos_
what are their qualifications ? _eos_
what are their skills ? _eos_

qui est victime de harcèlement sexuel ? _eos_
who experiences sexual harassment ? _eos_
who is victim sexual sexual ? ? _eos_

quelles sont les personnes qui visitent les communautés autochtones ? _eos_
who visits indigenous communities ? _eos_
who are people people aboriginal aboriginal ? _eos_

pourquoi ces trois points en particulier ? _eos_
why these specific three ? _eos_
why are these two different ? ? _eos_

pourquoi ou pourquoi pas ? _eos_
why or why not ? _eos_
why or why not _eos_
'''

令人惊讶的是，这种可能是最简单的从头开始编写的 PyTorch 模块，仅有五万个句子，有时在验证集上能够给出完全正确的答案。有时正确答案略有不同措辞，有时句子真的不通顺，甚至有太多的问号。所以我们在正确的轨道上。我们认为您会同意，即使是可能是最简单的 seq-to-seq 模型，经过很少的迭代训练，除了使用词嵌入之外没有任何预训练，效果也出奇的好。我们以后会改进这一点，但这里的信息是，即使您认为序列到序列模型比您认为的更简单，即使使用比您认为的更少的数据进行学习，也可能会出奇地有效，在某些情况下，这可能已经足够满足您的需求。

问题：规范标点符号（例如 ’ vs. '）会有帮助吗？这种特定情况的答案可能是肯定的——弯引号和直引号之间的区别实际上是语义上的。但是你必须非常小心，因为可能会发现使用漂亮的弯引号的人更喜欢使用更正式的语言，他们的写作方式也不同。因此，如果你要进行某种类似标点符号规范化的预处理，你应该绝对检查带有和不带有这种预处理的结果，因为几乎总是这种预处理会使事情变得更糟，即使你确信它不会。

问题：除了 dropout 和权重衰减，有哪些正则化这些 seq2seq 模型的方法？让我在这一周内考虑一下。我们一直依赖的 AWD-LSTM 有许多不同种类的 dropout，还有一种基于激活和变化的正则化。Jeremy 还没有看到有人将这么多工作投入到正则化序列到序列模型中，有一个巨大的机会让某人像 AWD-LSTM 一样对 seq-to-seq 进行正则化，这可能就像从 AWD-LSTM 中窃取所有想法并直接在 seq-to-seq 中使用它们一样容易尝试。最近几周 Stephen Merity 添加了一篇有趣的论文，他使用了一个想法，即获取所有这些不同的 AWD-LSTM 超参数并训练一堆不同的模型，然后使用随机森林找出最重要的特征，然后找出如何设置它们。你完全可以使用这种方法来找出对序列到序列正则化方法哪种是最好的，并优化它们，这将是令人惊讶的。但目前，我们不知道除了那篇关于常规语言模型的论文之外，是否还有其他关于序列到序列正则化的想法。

技巧

技巧#1：使用双向

对于分类，Jeremy 建议使用的双向方法是获取所有的标记序列，旋转它们，训练一个新的语言模型，然后训练一个新的分类器。他还提到，如果你在名称中用bwd替换fwd，你将得到他为你创建的预训练的后向模型。获取一组预测，然后像普通集成一样对预测进行平均。这就是我们在这种分类中进行双向的方式。可能有一些方法可以端到端地完成，但 Jeremy 还没有完全弄清楚，而且它们还没有在 fastai 中。所以如果你弄清楚了，那是一个有趣的研究方向。但因为我们不是在处理大量文档，需要将其分成单独的部分，然后对它们进行汇总，所以在这种情况下我们可以很容易地进行双向。只需将bidirectional=True添加到我们的编码器中就可以了。人们倾向于不对解码器进行双向处理，部分原因是因为这被认为是作弊，但也许在某些情况下它可能有效，尽管在解码器中可能需要更多的集成方法，因为这不太明显。但对于编码器来说很简单——bidirectional=True，现在我们有了一个沿着相反方向的第二个 RNN。第二个 RNN 按相反顺序访问每个标记，因此当我们到达最终隐藏状态时，它是第一个（即最左边）标记。但隐藏状态的大小是相同的，因此最终的结果是我们得到了一个长度为 2 的额外轴的张量。根据你使用的库，通常这将与层数相结合，所以如果你有 2 层和双向——那个张量维度现在是长度 4。对于 PyTorch，取决于你查看的过程的哪一部分，你是否会得到每一层和/或每个双向位的单独结果。你必须查阅文档，它会告诉你适用于层数的输入输出张量大小以及是否有bidirectional=True。

在这种特殊情况下，你将看到必须进行的所有更改。例如，当我们添加了bidirectional=True时，Linear层现在需要隐藏数量乘以 2（即nh*2）来反映我们隐藏状态中有第二个方向的事实。在initHidden中现在是self.nl*2。

class Seq2SeqRNN_Bidir(nn.Module):
    def __init__(
        self, vecs_enc, itos_enc, em_sz_enc, vecs_dec, 
        itos_dec, em_sz_dec, nh, out_sl, nl=2
    ):
        super().__init__()
        self.emb_enc = create_emb(vecs_enc, itos_enc, em_sz_enc)
        self.nl,self.nh,self.out_sl = nl,nh,out_sl
        self.gru_enc = nn.GRU(
            em_sz_enc, nh, 
            num_layers=nl,
            dropout=0.25, 
            bidirectional=True
        )
        self.out_enc = nn.Linear(nh*2, em_sz_dec, bias=False)
        self.drop_enc = nn.Dropout(0.05)
        self.emb_dec = create_emb(vecs_dec, itos_dec, em_sz_dec)
        self.gru_dec = nn.GRU(
            em_sz_dec, 
            em_sz_dec, 
            num_layers=nl,
            dropout=0.1
        )
        self.emb_enc_drop = nn.Dropout(0.15)
        self.out_drop = nn.Dropout(0.35)
        self.out = nn.Linear(em_sz_dec, len(itos_dec))
        self.out.weight.data = self.emb_dec.weight.data

    def forward(self, inp):
        sl,bs = inp.size()
        h = self.initHidden(bs)
        emb = self.emb_enc_drop(self.emb_enc(inp))
        enc_out, h = self.gru_enc(emb, h)
        h = h.view(2,2,bs,-1) \ 
            .permute(0,2,1,3)
            .contiguous() \
            .view(2,bs,-1)
        h = self.out_enc(self.drop_enc(h)) 
        dec_inp = V(torch.zeros(bs).long())
        res = []
        for i in range(self.out_sl):
            emb = self.emb_dec(dec_inp).unsqueeze(0)
            outp, h = self.gru_dec(emb, h)
            outp = self.out(self.out_drop(outp[0]))
            res.append(outp)
            dec_inp = V(outp.data.max(1)[1])
            if (dec_inp==1).all(): 
                break
        return torch.stack(res)

    def initHidden(self, bs): 
        return V(torch.zeros(self.nl*2, bs, self.nh))

为什么将解码器设置为双向被认为是作弊？这不仅仅是作弊，而且我们有这种循环进行，所以不仅仅是有两个张量那么简单。那么如何将这两个单独的循环转换为最终结果呢？在休息期间讨论过后，Jeremy 已经从“每个人都知道这不起作用”变成“也许它可能起作用”，但需要更多的思考。在这一周期间，他可能会意识到这是一个愚蠢的想法，但我们会考虑一下。

为什么需要为循环设置一个范围？因为当我们开始训练时，一切都是随机的，所以if (dec_inp==1).all(): break可能永远不会成立。后来，它最终几乎总是会中断，但基本上我们会永远进行下去。在设计架构时，非常重要的一点是要记住，当你开始时，模型对任何事情一无所知。所以你要确保如果它要做一些事情，至少它是模糊合理的。

我们使用单向获得了 3.58 的交叉熵损失。使用双向后，我们降到了 3.51，所以稍微有所改善。这不会真正减慢速度太多。双向意味着需要进行更多的顺序处理，但通常是一个很好的胜利。在 Google 翻译模型中，8 层中只有第一层是双向的，因为它允许它更多地并行进行，所以如果你创建了非常深的模型，你可能需要考虑哪些是双向的，否则我们会有性能问题。

rnn = Seq2SeqRNN_Bidir(
    fr_vecd, fr_itos,
    dim_fr_vec, 
    en_vecd, en_itos, 
    dim_en_vec, 
    nh, enlen_90
)
learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)
learn.crit = seq2seq_losslearn.fit(lr, 1, cycle_len=12, use_clr=(20,10))
'''
epoch      trn_loss   val_loss                              
    0      4.896942   4.761351  
    1      4.323335   4.260878                              
    2      3.962747   4.06161                               
    3      3.596254   3.940087                              
    4      3.432788   3.944787                              
    5      3.310895   3.686629                              
    6      3.454976   3.638168                              
    7      3.093827   3.588456                              
    8      3.257495   3.610536                              
    9      3.033345   3.540344                              
    10     2.967694   3.516766                              
    11     2.718945   3.513977
[3.5139771]
'''

技巧#2 教师强制

现在让我们谈谈教师强制。当模型开始学习时，它对一无所知。所以当模型开始学习时，它不会在第一步就吐出“Er”，它会吐出一些随机无意义的单词，因为它对德语、英语或语言的概念一无所知。它会将其作为输入馈送到下一个过程中，并且完全没有帮助。这意味着早期学习会非常困难，因为它将一个愚蠢的输入馈送到一个一无所知的模型中，但不知何故它会变得更好。所以最终它会到达那里，但肯定不像我们可以做的那样有帮助。那么，如果我们不是输入我刚才预测的东西，而是输入实际正确的单词，会怎样呢？我们在推理时无法这样做，因为根据定义，我们不知道正确的单词 - 必须将其翻译。我们不能要求正确的翻译来进行翻译。

设置的方式是我们有一个叫做pr_force的东西，它是强制的概率。如果某个随机数小于该概率，那么我们将用实际正确的东西替换我们的解码器输入。如果我们已经走得太远，如果它已经比目标序列长，我们就会停止，因为显然我们无法给出正确的东西。你可以看到 PyTorch 在这方面是多么美妙。去年课程的这个确切时刻，我们切换到 PyTorch 的关键原因是因为 Jeremy 尝试在 Keras 和 TensorFlow 中实现教师强制，结果比之前更疯狂。几周都没有进展，然后他在 Twitter 上看到 Andrej Karpathy 提到了一个叫做 PyTorch 的东西，很酷。他当天尝试了一下，第二天就有了教师强制。所有这些尝试调试的事情突然变得容易得多，这种动态的东西也变得容易得多。所以这是一个很好的例子，“嘿，我可以使用随机数和 if 语句”。

class Seq2SeqStepper(Stepper):
    def step(self, xs, y, epoch):
        self.m.pr_force = (10-epoch)*0.1 if epoch<10 else 0
        xtra = []
        output = self.m(*xs, y)
        if isinstance(output,tuple): 
            output,*xtra = output
        self.opt.zero_grad()
        loss = raw_loss = self.crit(output, y)
        if self.reg_fn: 
            loss = self.reg_fn(output, xtra, raw_loss)
        loss.backward()
        if self.clip:   # Gradient clipping
            nn.utils.clip_grad_norm(
                trainable_params_(self.m), 
                self.clip
            )
        self.opt.step()
        return raw_loss.data[0]

这里是基本思想[1:25:29]。在训练开始时，让pr_force非常高，以便几乎总是得到实际正确的前一个单词，因此它有一个有用的输入。然后随着我们训练的进一步，让pr_force逐渐减少，直到最后pr_force为零，它必须正确学习，这是可以的，因为现在它几乎总是输入合理的输入。

class Seq2SeqRNN_TeacherForcing(nn.Module):
    def __init__(
        self, vecs_enc, itos_enc, em_sz_enc, vecs_dec,
        itos_dec, em_sz_dec, nh, out_sl, nl=2
    ):
        super().__init__()
        self.emb_enc = create_emb(vecs_enc, itos_enc, em_sz_enc)
        self.nl,self.nh,self.out_sl = nl,nh,out_sl
        self.gru_enc = nn.GRU(
            em_sz_enc, nh, 
            num_layers=nl, 
            dropout=0.25
        )
        self.out_enc = nn.Linear(nh, em_sz_dec, bias=False)
        self.emb_dec = create_emb(vecs_dec, itos_dec, em_sz_dec)
        self.gru_dec = nn.GRU(
            em_sz_dec, 
            em_sz_dec, 
            num_layers=nl, 
            dropout=0.1
        )
        self.emb_enc_drop = nn.Dropout(0.15)
        self.out_drop = nn.Dropout(0.35)
        self.out = nn.Linear(em_sz_dec, len(itos_dec))
        self.out.weight.data = self.emb_dec.weight.data
        self.pr_force = 1.

    def forward(self, inp, y=None):
        sl,bs = inp.size()
        h = self.initHidden(bs)
        emb = self.emb_enc_drop(self.emb_enc(inp))
        enc_out, h = self.gru_enc(emb, h)
        h = self.out_enc(h) dec_inp = V(torch.zeros(bs).long())
        res = []
        for i in range(self.out_sl):
            emb = self.emb_dec(dec_inp).unsqueeze(0)
            outp, h = self.gru_dec(emb, h)
            outp = self.out(self.out_drop(outp[0]))
            res.append(outp)
            dec_inp = V(outp.data.max(1)[1])
            if (dec_inp==1).all(): break
            if (y is not None) and (random.random()<self.pr_force):
                if i>=len(y): 
                    break
                dec_inp = y[i]
        return torch.stack(res)

    def initHidden(self, bs): 
        return V(torch.zeros(self.nl, bs, self.nh))

pr_force: “probability of forcing”. High in the beginning zero by the end.

现在让我们写一些东西，使得在训练循环中逐渐减少pr_force[1:26:01]。我们如何做到这一点？一种方法是编写我们自己的训练循环，但我们不要这样做，因为我们已经有一个训练循环，它有进度条，使用指数加权平均值来平滑损失，跟踪指标，并做了一堆事情。它们还跟踪在 epoch 开始时调用 RNN 的重置，以确保隐藏状态设置为零。我们发现的趋势是，当我们开始编写一些新东西并需要替换代码的某些部分时，我们会添加一些小钩子，以便我们可以使用该钩子使事情变得更容易。在这种特殊情况下，Jeremy 一直在使用的一个钩子是称为 stepper 的钩子。如果你查看源代码，model.py 是我们的 fit 函数所在的地方，这是最低级的东西，不需要学习者或任何其他东西，只需要一个标准的 PyTorch 模型和一个模型数据对象。你只需要知道多少个 epochs，一个标准的 PyTorch 优化器和一个标准的 PyTorch 损失函数。我们在课堂上几乎从未使用过，我们通常调用learn.fit，但learn.fit调用这个。

我们有时查看源代码[1:27:49]。我们看到它如何通过每个 epoch 循环，然后循环遍历批处理中的每个内容并调用stepper.step。stepper.step是负责的事情：

• 调用模型

• 获取损失

• 找到损失函数

• 调用优化器

所以默认情况下，stepper.step使用一个称为Stepper的特定类，基本上调用模型，将梯度置零，调用损失函数，调用backward，如果需要进行梯度裁剪，然后调用优化器。这些是我们在“从头开始的 PyTorch”中看到的基本步骤。好处是，我们可以用其他东西替换它，而不是替换训练循环。如果你继承自Stepper，然后编写你自己版本的step，你可以只需复制并粘贴 step 的内容并添加任何你喜欢的内容。或者如果这是你要在之前或之后做的事情，你甚至可以调用super.step。在这种情况下，Jeremy 相当怀疑他不必要地复杂[1:29:12] - 他可能本来可以做一些像这样的事情：

class Seq2SeqStepper(Stepper):
    def step(self, xs, y, epoch):
        self.m.pr_force = (10-epoch)*0.1 if epoch<10 else 0
        return super.step(xs, y, epoch)

但正如他所说的，当他在原型设计时，他并没有仔细考虑如何最小化他的代码 - 他复制并粘贴了step的内容，并在顶部添加了一行，用于将模块中的pr_force逐渐线性减少前 10 个 epochs，10 个 epochs 后，它为零。所以总体上是一个 hack，但足够好用来尝试一下。好处是除了添加这三行之外，其他一切都是一样的：

 if (y is not None) and (random.random()<self.pr_force):
    if i>=len(y): 
        break
    dec_inp = y[i]

唯一需要做的不同之处是当我们调用fit时，我们传入我们定制的 stepper 类。

rnn = Seq2SeqRNN_TeacherForcing(
    fr_vecd, fr_itos, 
    dim_fr_vec, 
    en_vecd, en_itos, 
    dim_en_vec, 
    nh, enlen_90
)
learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)
learn.crit = seq2seq_losslearn.fit(
    lr, 1, 
    cycle_len=12, 
    use_clr=(20,10), 
    stepper=Seq2SeqStepper
)
'''
epoch      trn_loss   val_loss                              
    0      4.460622   12.661013 
    1      3.468132   7.138729                              
    2      3.235244   6.202878                              
    3      3.101616   5.454283                              
    4      3.135989   4.823736                              
    5      2.980696   4.933402                              
    6      2.91562    4.287475                              
    7      3.032661   3.975346                              
    8      3.103834   3.790773                              
    9      3.121457   3.578682                              
    10     2.917534   3.532427                              
    11     3.326946   3.490643
[3.490643]
'''

现在我们的损失降至 3.49。我们需要确保至少进行 10 个 epochs，因为在那之前，通过使用强制教师，这是作弊的。

Trick #3 注意力模型[1:31:00]

让我们尝试实现注意力[1:35:47]:

def rand_t(*sz): 
    return torch.randn(sz)/math.sqrt(sz[0])
def rand_p(*sz): 
    return nn.Parameter(rand_t(*sz))
class Seq2SeqAttnRNN(nn.Module):
    def __init__(self, vecs_enc, itos_enc, em_sz_enc, vecs_dec, 
                 itos_dec, em_sz_dec, nh, out_sl, nl=2):
        super().__init__()
        self.emb_enc = create_emb(vecs_enc, itos_enc, em_sz_enc)
        self.nl,self.nh,self.out_sl = nl,nh,out_sl
        self.gru_enc = nn.GRU(
            em_sz_enc, nh, 
            num_layers=nl, 
            dropout=0.25
        )
        self.out_enc = nn.Linear(nh, em_sz_dec, bias=False)
        self.emb_dec = create_emb(vecs_dec, itos_dec, em_sz_dec)
        self.gru_dec = nn.GRU(
            em_sz_dec, 
            em_sz_dec, 
            num_layers=nl, 
            dropout=0.1
        )
        self.emb_enc_drop = nn.Dropout(0.15)
        self.out_drop = nn.Dropout(0.35)
        self.out = nn.Linear(em_sz_dec*2, len(itos_dec))
        self.out.weight.data = self.emb_dec.weight.data self.W1 = rand_p(nh, em_sz_dec)
        self.l2 = nn.Linear(em_sz_dec, em_sz_dec)
        self.l3 = nn.Linear(em_sz_dec+nh, em_sz_dec)
        self.V = rand_p(em_sz_dec) 
    def forward(self, inp, y=None, ret_attn=False):
        sl,bs = inp.size()
        h = self.initHidden(bs)
        emb = self.emb_enc_drop(self.emb_enc(inp))
        enc_out, h = self.gru_enc(emb, h)
        h = self.out_enc(h) dec_inp = V(torch.zeros(bs).long())
        res,attns = [],[]
        w1e = enc_out @ self.W1
        for i in range(self.out_sl):
            w2h = self.l2(h[-1])
            u = F.tanh(w1e + w2h)
            a = F.softmax(u @ self.V, 0)
            attns.append(a)
            Xa = (a.unsqueeze(2) * enc_out).sum(0)
            emb = self.emb_dec(dec_inp)
            wgt_enc = self.l3(torch.cat([emb, Xa], 1))

            outp, h = self.gru_dec(wgt_enc.unsqueeze(0), h)
            outp = self.out(self.out_drop(outp[0]))
            res.append(outp)
            dec_inp = V(outp.data.max(1)[1])
            if (dec_inp==1).all(): 
                break
            if (y is not None) and (random.random()<self.pr_force):
                if i>=len(y): 
                    break
                dec_inp = y[i] res = torch.stack(res)
        if ret_attn: 
            res = res,torch.stack(attns)
        return res 
    def initHidden(self, bs): 
        return V(torch.zeros(self.nl, bs, self.nh))

有了注意力，大部分代码都是相同的。唯一的主要区别是这一行：Xa = (a.unsqueeze(2) * enc_out).sum(0)。我们将进行加权平均，我们将如何进行加权平均是我们创建一个小型神经网络，我们将在这里看到：

w2h = self.l2(h[-1])
u = F.tanh(w1e + w2h)
a = F.softmax(u @ self.V, 0)

我们使用 softmax，因为 softmax 的好处是我们希望确保我们使用的所有权重加起来等于 1，而且我们也希望其中一个权重可能比其他权重更高[1:36:38]。Softmax 给了我们这样的保证，它们加起来等于 1，因为它里面有e^，它倾向于鼓励其中一个权重比其他权重更高。

让我们看看这是如何工作的[1:37:09]。我们将取最后一层的隐藏状态，然后将其放入一个线性层中。然后我们将其放入一个非线性激活函数，然后进行矩阵相乘。所以如果你考虑一下——一个线性层，非线性激活函数，矩阵相乘——这就是一个神经网络。这是一个具有一个隐藏层的神经网络。将其放入 softmax，然后我们可以使用它来加权我们的编码器输出。现在，我们不再只是取最后一个编码器输出，而是有了所有编码器输出的张量，我们只需用我们创建的这个神经网络来加权。

在 Python 中，A @ B是矩阵乘积，A * B是逐元素乘积

论文[1:38:18]

rnn = Seq2SeqAttnRNN(fr_vecd, fr_itos, dim_fr_vec, en_vecd, en_itos, dim_en_vec, nh, enlen_90)
learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)
learn.crit = seq2seq_loss
lr=2e-3
learn.fit(
    lr, 1, 
    cycle_len=15, 
    use_clr=(20,10), 
    stepper=Seq2SeqStepper
)
'''
epoch      trn_loss   val_loss                              
    0      3.882168   11.125291 
    1      3.599992   6.667136                              
    2      3.236066   5.552943                              
    3      3.050283   4.919096                              
    4      2.99024    4.500383                              
    5      3.07999    4.000295                              
    6      2.891087   4.024115                              
    7      2.854725   3.673913                              
    8      2.979285   3.590668                              
    9      3.109851   3.459867                              
    10     2.92878    3.517598                              
    11     2.778292   3.390253                              
    12     2.795427   3.388423                              
    13     2.809757   3.353334                              
    14     2.6723     3.368584
[3.3685837]
'''

learn.save('attn')

测试[1:45:37]

x,y = next(iter(val_dl))
probs,attns = learn.model(V(x),ret_attn=True)
preds = to_np(probs.max(2)[1])
for i in range(180,190):
    print(' '.join([fr_itos[o] for o in x[:,i] if o != 1]))
    print(' '.join([en_itos[o] for o in y[:,i] if o != 1]))
    print(' '.join([en_itos[o] for o in preds[:,i] if o!=1]))
    print()
'''
quels facteurs pourraient influer sur le choix de leur emplacement ? _eos_
what factors influencetheir location ? _eos_
what factors might influence the their their their ? _eos_**qu’ est -ce qui ne peut pas changer ? _eos_
what can not change ? _eos_
what can not change change ? _eos_**que faites - vous ? _eos_
what do you do ? _eos_
what do you do ? _eos_**qui réglemente les pylônes d' antennes ? _eos_
who regulates antenna towers ? _eos_
who regulates the lights ? ? _eos_**où sont - ils situés ? _eos_
where are they located ? _eos_
where are they located ? _eos_**quelles sont leurs compétences ? _eos_
what are their qualifications ? _eos_
what are their skills ? _eos_**qui est victime de harcèlement sexuel ? _eos_
who experiences sexual harassment ? _eos_
who is victim sexual sexual ? _eos_**quelles sont les personnes qui visitent les communautés autochtones ? _eos_
who visits indigenous communities ? _eos_
who is people people aboriginal people ? _eos_**pourquoi ces trois points en particulier ? _eos_
why these specific three ? _eos_
why are these three three ? ? _eos_**pourquoi ou pourquoi pas ? _eos_
why or why not ? _eos_
why or why not ? _eos_
'''

可视化[1:47:12]

probs,attns = learn.model(V(x),ret_attn=True)

attn = to_np(attns[...,180])
fig, axes = plt.subplots(3, 3, figsize=(15, 10))
for i,ax in enumerate(axes.flat):
    ax.plot(attn[i])

Devise [1:55:23]

from fastai.conv_learner import *
torch.backends.cudnn.benchmark=True

import fastText as ft
PATH = Path('data/imagenet/')
TMP_PATH = PATH/'tmp'
TRANS_PATH = Path('data/translate/')
PATH_TRN = PATH/'train'

ft_vecs = ft.load_model(str((TRANS_PATH/'wiki.en.bin')))
np.corrcoef(
    ft_vecs.get_word_vector('jeremy'), 
    ft_vecs.get_word_vector('Jeremy'))
'''
array([[1\.     , 0.60866],
       [0.60866, 1\.     ]])
'''

np.corrcoef(
    ft_vecs.get_word_vector('banana'), 
    ft_vecs.get_word_vector('Jeremy'))
'''
array([[1\.     , 0.14482],
       [0.14482, 1\.     ]])
'''

将 ImageNet 类别映射到单词向量

现在让我们获取所有 ImageNet 类别，因为我们实际上想知道哪一个是柯基，哪一个是大型喷气机。

ft_words = ft_vecs.get_words(include_freq=True)
ft_word_dict = {k:v for k,v in zip(*ft_words)}
ft_words = sorted(ft_word_dict.keys(), key=lambda x: ft_word_dict[x])
len(ft_words)
'''
2519370
'''
from fastai.io import get_data

我们在 files.fast.ai 上有一个所有这些的列表，我们可以获取它们。

CLASSES_FN = 'imagenet_class_index.json'
get_data(
    f'http://files.fast.ai/models/{CLASSES_FN}', 
    TMP_PATH/CLASSES_FN
)

让我们还获取 Jeremy 提供的所有英语名词的列表：

WORDS_FN = 'classids.txt'
get_data(f'http://files.fast.ai/data/{WORDS_FN}', PATH/WORDS_FN)

所以我们有每个千个 ImageNet 类别的名称，以及根据 WordNet 列出的所有英语名词，这是一个用于表示哪些词是什么的流行工具。我们现在可以加载 ImageNet 类别列表，将其转换为字典，因此classids_1k包含了比赛数据集中的 1000 个图像的类别 ID。

class_dict = json.load((TMP_PATH/CLASSES_FN).open())
classids_1k = dict(class_dict.values())
nclass = len(class_dict); nclass*1000*

这里有一个例子。一个“tench”显然是一种鱼。

class_dict['0']
'''
['n01440764', 'tench']
'''

让我们为所有这些 WordNet 名词做同样的事情。结果发现 ImageNet 正在使用 WordNet 类名，这样在两者之间进行映射就变得简单了。

classid_lines = (PATH/WORDS_FN).open().readlines()
classid_lines[:5]
'''
['n00001740 entity\n',
 'n00001930 physical_entity\n',
 'n00002137 abstraction\n',
 'n00002452 thing\n',
 'n00002684 object\n']
'''
classids = dict(l.strip().split() for l in classid_lines)
len(classids),len(classids_1k)
'''
(82115, 1000)
'''

这是我们的两个世界 — 我们有 ImageNet 的一千个和 WordNet 中的 82,000 个。

lc_vec_d = {
    w.lower(): ft_vecs.get_word_vector(w) 
    for w in ft_words[-1000000:]
}

我们想要将这两者联系起来，这只是简单地创建一些字典来基于 Synset ID 或 WordNet ID 进行映射。

syn_wv = [
    (k, lc_vec_d[v.lower()]) 
    for k,v in classids.items()
    if v.lower() in lc_vec_d
]
syn_wv_1k = [
    (k, lc_vec_d[v.lower()]) 
    for k,v in classids_1k.items()
    if v.lower() in lc_vec_d
]
syn2wv = dict(syn_wv)
len(syn2wv)
'''
49469
'''

现在我们需要做的是获取 WordNet 中的 82,000 个名词，并尝试在快速文本中查找它们。我们已经在快速文本中查找到了 49,469 个名词。我们现在有一个字典，从 synset ID（即 WordNet 称之为的 ID）到单词向量。我们还为 1k 个 ImageNet 类别做了同样的事情。

pickle.dump(syn2wv, (TMP_PATH/'syn2wv.pkl').open('wb'))
pickle.dump(syn_wv_1k, (TMP_PATH/'syn_wv_1k.pkl').open('wb'))
syn2wv = pickle.load((TMP_PATH/'syn2wv.pkl').open('rb'))
syn_wv_1k = pickle.load((TMP_PATH/'syn_wv_1k.pkl').open('rb'))

现在我们获取了所有的 ImageNet，你现在可以从 Kaggle 下载。如果你看一下 Kaggle 的 ImageNet 本地化比赛，其中包含了所有的 ImageNet 分类。

images = []
img_vecs = []
for d in (PATH/'train').iterdir():
    if d.name not in syn2wv: 
        continue
    vec = syn2wv[d.name]
    for f in d.iterdir():
        images.append(str(f.relative_to(PATH)))
        img_vecs.append(vec)
n_val=0
for d in (PATH/'valid').iterdir():
    if d.name not in syn2wv: 
        continue
    vec = syn2wv[d.name]
    for f in d.iterdir():
        images.append(str(f.relative_to(PATH)))
        img_vecs.append(vec)
        n_val += 1
n_val
'''
28650
'''

其中有 28,650 个项目的验证集。对于 ImageNet 中的每个图像，我们可以使用 synset 到单词向量（syn2wv）获取其快速文本词向量，并将其放入图像向量数组（img_vecs），将所有这些堆叠到一个矩阵中并保存下来。

img_vecs = np.stack(img_vecs)
img_vecs.shape

现在我们为每个 ImageNet 图像都有一个与之相关联的快速文本词向量。通过查找 synset ID → WordNet → 快速文本 → 单词向量。

pickle.dump(images, (TMP_PATH/'images.pkl').open('wb'))
pickle.dump(img_vecs, (TMP_PATH/'img_vecs.pkl').open('wb'))
images = pickle.load((TMP_PATH/'images.pkl').open('rb'))
img_vecs = pickle.load((TMP_PATH/'img_vecs.pkl').open('rb'))
arch = resnet50n = len(images); n
'''
766876
'''
val_idxs = list(range(n-28650, n))

这里有一个很酷的技巧。我们现在可以创建一个模型数据对象，它专门是一个图像分类器数据对象，我们有一个叫做from_names_and_array的东西，我不确定我们以前是否使用过，但我们可以传递一个文件名列表（ImageNet 中的所有文件名）和一个我们的因变量数组（所有快速文本词向量）。然后我们传入验证索引，这种情况下只是所有最后的 ID — 我们需要确保它们与 ImageNet 使用的相同，否则我们会作弊。然后我们传入continuous=True，这意味着这个图像分类器数据现在是一个图像回归数据，连续等于 True 意味着不要对我的输出进行独热编码，而是将它们视为连续值。现在我们有一个模型数据对象，其中包含所有文件名，对于每个文件名，都有一个表示该单词向量的连续数组。所以我们有了数据，现在我们需要一个架构和损失函数。

tfms = tfms_from_model(arch, 224, transforms_side_on, max_zoom=1.1)
md = ImageClassifierData.from_names_and_array(
    PATH, images, img_vecs, 
    val_idxs=val_idxs, 
    classes=None, 
    tfms=tfms,
    continuous=True, 
    bs=256
)
x,y = next(iter(md.val_dl))

让我们创建一个架构。我们下周会对此进行修订，但我们可以使用到目前为止学到的技巧，实际上非常简单。Fastai 有一个ConvnetBuilder，当你说ConvLerner.pretrained时就会调用它，并指定：

• f: 架构（我们将使用 ResNet50）

• c: 你想要多少类（在这种情况下，它实际上不是类别，而是你想要的输出数量，即快速文本词向量的长度，即 300）。

• is_multi: 这不是多分类，因为根本不是分类。

• is_reg: 是的，这是一个回归。

• xtra_fc: 你想要什么全连接层。我们将添加一个长度为 1024 的全连接隐藏层。为什么是 1024？我认为 ResNet50 的最后一层是 1024，我们需要的最终输出是 300。显然，我们需要倒数第二层比 300 长。否则信息不足，所以我们选择了稍大一点的值。也许不同的数字会更好，但这对 Jeremy 有效。

• ps: 你想要多少 dropout。Jeremy 发现默认的 dropout，他一直欠拟合，所以他将 dropout 从 0.5 降低到 0.2。

所以这是一个卷积神经网络，没有任何 softmax 之类的东西，因为它是回归，最后只是一个线性层，这就是我们的模型。我们可以从该模型创建一个 ConvLearner，并为其提供一个优化函数。现在我们只需要一个损失函数。

models = ConvnetBuilder(
    arch, md.c, 
    is_multi=False, 
    is_reg=True, 
    xtra_fc=[1024], 
    ps=[0.2,0.2]
)
learn = ConvLearner(md, models, precompute=True)
learn.opt_fn = partial(optim.Adam, betas=(0.9,0.99))

损失函数：回归的默认损失函数是 L1 损失（绝对差异）- 这并不坏。但不幸的是，在真正高维空间中（任何稍微了解一点机器学习的人可能都知道），一切都在外面（在这种情况下，是 300 维）。当一切都在外面时，距离并不毫无意义，但有点尴尬。事物往往要么靠在一起，要么远离，在这些真正高维空间中，一切都在边缘，这并不意味着太多。然而，有意义的是，如果一件事在这边的边缘，另一件事在那边的边缘，我们可以形成这些向量之间的角度，这个角度是有意义的。这就是为什么在寻找高维空间中事物之间的接近或远离时，我们使用余弦相似度。如果你以前没有见过余弦相似度，它基本上与欧几里德距离相同，但被归一化为单位范数（即除以长度）。因此，我们不关心向量的长度，我们只关心它的角度。有很多东西你可以在几个小时内轻松学会，但如果你以前没有见过，它可能有点神秘。现在，只需知道损失函数和高维空间中，你在尝试找到相似性时，你关心角度，而不关心距离。如果你没有使用以下自定义损失函数，它仍然可以工作，但效果会差一点。现在我们有了数据、架构和损失函数，因此，我们完成了。我们可以继续拟合。

def cos_loss(inp,targ):
    return 1 - F.cosine_similarity(inp,targ).mean()
learn.crit = cos_losslearn.lr_find(start_lr=1e-4, end_lr=1e15)
learn.sched.plot()
lr = 1e-2
wd = 1e-7

我们正在训练所有的 ImageNet，这将需要很长时间。所以precompute=True是你的朋友。还记得precompute=True吗？那是我们很久以前学到的东西，它会缓存最终卷积层的输出，然后只训练完全连接的部分。即使使用precompute=True，在所有的 ImageNet 上训练一个时代大约需要 3 分钟。所以这大约是一个小时的训练时间，但很酷的是，使用 fastai，我们可以在一个小时左右的时间内在所有的 ImageNet 上训练一个新的自定义头部 40 个时代。

learn.precompute=True
learn.fit(lr, 1, cycle_len=20, wds=wd, use_clr=(20,10))
'''
epoch      trn_loss   val_loss                                  
    0      0.104692   0.125685  
    1      0.112455   0.129307                                 
    2      0.110631   0.126568                                 
    3      0.108629   0.127338                                 
    4      0.110791   0.125033                                 
    5      0.108859   0.125186                                 
    6      0.106582   0.123875                                 
    7      0.103227   0.123945                                 
    8      0.10396    0.12304                                  
    9      0.105898   0.124894                                 
    10     0.10498    0.122582                                 
    11     0.104983   0.122906                                 
    12     0.102317   0.121171                                  
    13     0.10017    0.121816                                  
    14     0.099454   0.119647                                  
    15     0.100425   0.120914                                  
    16     0.097226   0.119724                                  
    17     0.094666   0.118746                                  
    18     0.094137   0.118744                                  
    19     0.090076   0.117908
[0.11790786389489033]
'''
learn.bn_freeze(True)
learn.fit(lr, 1, cycle_len=20, wds=wd, use_clr=(20,10))
'''
epoch      trn_loss   val_loss                                  
    0      0.104692   0.125685  
    1      0.112455   0.129307                                 
    2      0.110631   0.126568                                 
    3      0.108629   0.127338                                 
    4      0.110791   0.125033                                 
    5      0.108859   0.125186                                 
    6      0.106582   0.123875                                 
    7      0.103227   0.123945                                 
    8      0.10396    0.12304                                  
    9      0.105898   0.124894                                 
    10     0.10498    0.122582                                 
    11     0.104983   0.122906                                 
    12     0.102317   0.121171                                  
    13     0.10017    0.121816                                  
    14     0.099454   0.119647                                  
    15     0.100425   0.120914                                  
    16     0.097226   0.119724                                  
    17     0.094666   0.118746                                  
    18     0.094137   0.118744                                  
    19     0.090076   0.117908
[0.11790786389489033]
'''
lrs = np.array([lr/1000,lr/100,lr])
learn.precompute=False
learn.freeze_to(1)
learn.save('pre0')
learn.load('pre0')

图像搜索

搜索 imagenet 类

在所有这些之后，我们现在可以说让我们获取 1000 个 ImageNet 类，让我们在整个验证集上进行预测，并查看一些图片。

syns, wvs = list(zip(*syn_wv_1k))
wvs = np.array(wvs)
%time pred_wv = learn.predict()
'''
CPU times: user 18.4 s, sys: 7.91 s, total: 26.3 s
Wall time: 7.17 s
'''
start=300
denorm = md.val_ds.denorm
def show_img(im, figsize=None, ax=None):
    if not ax: 
        ig,ax = plt.subplots(figsize=figsize)
    ax.imshow(im)
    ax.axis('off')
    return ax
def show_imgs(ims, cols, figsize=None):
    fig,axes = plt.subplots(len(ims)//cols, cols, figsize=figsize)
    for i,ax in enumerate(axes.flat): 
        show_img(ims[i], ax=ax)
    plt.tight_layout()

因为验证集是有序的，所有相同类型的东西都在同一个地方。

show_imgs(denorm(md.val_ds[start:start+25][0]), 5, (10,10))

最近邻搜索[2:10:56]：现在我们可以使用最近邻搜索。所谓最近邻搜索意味着这里有一个 300 维向量，这里有很多其他 300 维向量，它最接近哪个？通常这需要很长时间，因为你必须查看每个 300 维向量，计算其距离，找出它有多远。但是有一个几乎不为人知的神奇库叫做NMSLib，它可以做得非常快。你们中有些人可能尝试过其他最近邻库，我保证这比你们使用的更快 —— 我可以告诉你这一点，因为这是由专业人士进行基准测试的。在每个可能的维度上，这是迄今为止最快的。我们想要在角距离上创建一个索引，并且需要在我们所有的 ImageNet 词向量上执行。添加一个完整的批次，创建索引，现在我们可以一次查询一堆向量，获取最近的 10 个邻居。该库使用多线程，绝对棒。你可以从 pip 安装（pip install nmslib），它就能用了。

import nmslibdef create_index(a):
    index = nmslib.init(space='angulardist')
    index.addDataPointBatch(a)
    index.createIndex()
    return index
def get_knns(index, vecs):
    return zip(*index.knnQueryBatch(vecs, k=10, num_threads=4))
def get_knn(index, vec): 
    return index.knnQuery(vec, k=10)
nn_wvs = create_index(wvs)

它告诉你它们有多远以及它们的索引[2:12:13].

idxs,dists = get_knns(nn_wvs, pred_wv)

所以现在我们可以浏览并打印出前 3 个，结果是鸟实际上是一只鹭鸟。有趣的是第四个并没有说它是一只鹭鸟，Jeremy 查了一下。他对鸟类了解不多，但其他一切都是棕色带白色斑点，但第四个不是。所以我们不知道那是否真的是一只鹭鸟，或者是否被错误标记，但它看起来绝对不像其他鸟类。

[
    [classids[syns[id]] for id in ids[:3]] 
    for ids in idxs[start:start+10]
]
'''
[['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['spoonbill', 'bustard', 'oystercatcher'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill']]
'''

这并不是一件特别困难的事情，因为 ImageNet 只有一千个类别，而且并没有做任何新的事情。但是如果我们现在引入整个 WordNet，然后说它最接近那 45,000 个东西中的哪一个呢？

搜索所有 WordMet 名词类别

all_syns, all_wvs = list(zip(*syn2wv.items()))
all_wvs = np.array(all_wvs)
nn_allwvs = create_index(all_wvs)
idxs,dists = get_knns(nn_allwvs, pred_wv)
[
    [classids[all_syns[id]] for id in ids[:3]] 
    for ids in idxs[start:start+10]
]
'''
[['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['spoonbill', 'bustard', 'oystercatcher'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill'],
 ['limpkin', 'oystercatcher', 'spoonbill']]
'''

结果完全相同。现在正在搜索所有的 WordNet。

文本->图像搜索[2:13:16]

nn_predwv = create_index(pred_wv)
en_vecd = pickle.load(open(TRANS_PATH/'wiki.en.pkl','rb'))
vec = en_vecd['boat']
idxs,dists = get_knn(nn_predwv, vec)
show_imgs([
    open_image(PATH/md.val_ds.fnames[i]) 
    for i in idxs[:3]
], 3, figsize=(9,3));

vec = (en_vecd['engine'] + en_vecd['boat'])/2 
idxs,dists = get_knn(nn_predwv, vec)
show_imgs([
    open_image(PATH/md.val_ds.fnames[i]) 
    for i in idxs[:3]
], 3, figsize=(9,3));

vec = (en_vecd['sail'] + en_vecd['boat'])/2
idxs,dists = get_knn(nn_predwv, vec)
show_imgs([
    open_image(PATH/md.val_ds.fnames[i]) 
    for i in idxs[:3]
], 3, figsize=(9,3));

图像->图像[2:14:35]

fname = 'valid/n01440764/ILSVRC2012_val_00007197.JPEG'
img = open_image(PATH/fname)
show_img(img);

t_img = md.val_ds.transform(img)
pred = learn.predict_array(t_img[None])idxs,dists = get_knn(nn_predwv, pred)
show_imgs([
    open_image(PATH/md.val_ds.fnames[i]) 
    for i in idxs[1:4]
], 3, figsize=(9,3));