• 许多学生在上周的内容上遇到了困难，所以如果你觉得困难，没关系。Jeremy 之所以提前放上这些内容，是为了让我们有东西可以思考、考虑，并逐渐努力，所以到第 14 课时，你将有第二次机会。

• 要理解这些部分，您需要了解卷积层输出的形状、感受野和损失函数——这些都是您在深度学习研究中需要理解的东西。

• 一个关键的事情是，我们从简单的开始——一个单一对象分类器，一个没有分类器的单一对象边界框，然后是一个单一对象分类器和边界框。我们转向多个对象的部分实际上几乎与此相同，只是我们首先必须解决匹配问题。我们最终创建了比我们需要的地面真实边界框更多的激活，因此我们将每个地面真实对象与这些激活的子集进行匹配。一旦我们做到了这一点，我们对每个匹配对执行的损失函数几乎与这个损失函数相同（即单一对象分类器和边界框的损失函数）。

• 如果您感到困惑，请回到第 8 课，并确保您理解数据集、数据加载器，尤其是损失函数。

• 因此，一旦我们有了可以预测一个对象的类别和边界框的东西，我们通过创建更多的激活来转向多个对象[2:40]。然后我们必须处理匹配问题，处理完匹配问题后，我们将每个锚框稍微移动一下，围绕一下，使其尽量与特定的地面真实对象对齐。

• 我们讨论了如何利用网络的卷积特性，尝试使激活具有类似于我们正在预测的地面真实对象的感受野。Chloe 提供了以下出色的图片，逐行讨论了 SSD_MultiHead.forward 的功能：

由Chloe Sultan提供

Chloe 在这里所做的是特别关注每个路径中张量的维度，逐渐使用步幅 2 的卷积进行下采样，确保她理解为什么会出现这些网格大小，然后理解输出是如何从中产生的。

• 这就是你必须记住这个pbd.set_trace()的地方。我在课前刚进入SSD_MultiHead.forward，输入了pdb.set_trace()，然后运行了一个批次。然后我可以打印出所有这些的大小。我们会犯错误，这就是为什么我们有调试器并知道如何检查事物并逐步进行小的操作的原因。

• 我们接着讨论了增加每个卷积网格单元的锚框数量k[5:49]，我们可以通过不同的缩放比例、长宽比来实现，这给我们带来了大量的激活，从而预测边界框。

• 然后我们使用非极大值抑制将数量减少到一个较小的值。

• 非极大值抑制有点糟糕、丑陋、完全启发式，我们甚至没有讨论代码，因为它看起来很丑陋。最近有人提出了一篇论文，试图使用端到端的卷积网络来替换 NMS 部分（arxiv.org/abs/1705.02950）。

  

• 不够多的人在阅读论文！我们现在在课堂上所做的是实现论文，论文是真正的真相。我认为你从与人们交谈中知道，很多人不阅读论文的原因是因为很多人认为他们没有能力阅读论文。他们认为他们不是那种阅读论文的人，但你是。你在这里。我们上周开始看一篇论文，我们读到了用英语写的文字，我们大部分都理解了。如果你仔细看上面的图片，你会意识到SSD_MultiHead.forward并不是在做同样的事情。你可能会想知道这样是否更好。我的答案可能是。因为 SSD_MultiHead.forward 是我尝试的第一件事，只是为了让一些东西出现。在这个和 YOLO3 论文之间，可能有更好的方法。

• 特别要注意的一点是，他们使用了更小的 k，但他们有更多的网格集合 1x1、3x3、5x5、10x10、19x19、38x38——每类 8732 个。比我们拥有的要多得多，所以这将是一个有趣的实验。

• 我注意到的另一件事是，我们有 4x4、2x2、1x1，这意味着有很多重叠——每组都适合其他组。在这种情况下，你有 1、3、5，你没有那种重叠。所以这可能会使学习变得更容易。有很多有趣的东西可以玩。

  

• 我最推荐的可能是将代码和方程式放在一起。你可能是数学人或者代码人。将它们并排放置，你将学到一些另一方面的知识。

• 学习数学很难，因为符号可能看起来很难查找，但有一些好的资源，比如wikipedia。

• 另一件你应该尝试做的事情是重新创建你在论文中看到的东西。这里是来自焦点损失论文的最重要的图 1。

  

  

• 我上周发现了我的代码中一个小错误——我展平卷积激活的方式与我在损失函数中使用它们的方式不一致，修复这个问题使它变得更好了。

  

通常，当我们降采样时，我们会增加滤波器的数量，或者深度。当我们从 7x7 采样到 4x4 等时，为什么要将数量从 512 减少到 256 呢？为什么不在 SSD 头部减少维度？（与性能相关？）我们有许多输出路径，我们希望每个输出路径都是相同的，所以我们不希望每个输出路径具有不同数量的滤波器，这也是论文中所做的，所以我试图与之匹配。拥有这 256 个——这是一个不同的概念，因为我们不仅利用了最后一层，还利用了之前的层。如果我们使它们更一致，生活会更容易。

对于自然语言处理，我们过去依赖于一个叫做 torchtext 的库，但尽管它很好用，我后来发现它的限制太令人困扰，无法继续使用。正如你们很多人在论坛上抱怨的那样，它非常慢，部分原因是它不进行并行处理，部分原因是它不记得你上次做了什么，而是从头开始重新做。然后很难做一些相当简单的事情，比如很多人试图参加 Kaggle 上的有毒评论竞赛，这是一个多标签问题，试图用 torchtext 做到这一点，我最终搞定了，但花了我大约一周的时间，这有点荒谬。为了解决所有这些问题，我们创建了一个名为 fastai.text 的新库。Fastai.text 是 torchtext 和 fastai.nlp 的组合的替代品。所以不要再使用 fastai.nlp 了 - 那已经过时了。它更慢，更令人困惑，各方面都不如意，但有很多重叠。故意地，很多类和函数的名称都是相同的，但这是非 torchtext 版本。

笔记本

我们将再次使用 IMDb。对于那些忘记了的人，请返回查看 lesson 4。这是一个电影评论数据集，我们用它来找出我们是否会喜欢“Zombiegeddon”，我们认为可能是我喜欢的类型。

from fastai.text import *
import html

我们需要从这个网站下载 IMDB 大型电影评论：ai.stanford.edu/~amaas/data/sentiment/ 直接链接：链接

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

NLP 的基本路径是我们必须将句子转换为数字，有几种方法可以实现这一点。目前，有点故意地，fastai.text 并没有提供太多的辅助函数。它真的更多地设计为让你以一种相当灵活的方式处理事情。

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

正如你在这里看到的[21:59]，我写了一个名为 get_texts 的东西，它遍历了CLASSES中的每一个东西。IMDb 中有三个类别：负面、正面，然后还有另一个文件夹“unsupervised”，其中包含他们尚未标记的样本，所以我们暂时将其称为一个类别。所以我们只是遍历每一个类别，然后找到该文件夹中的每个文件，打开它，读取它，并将其放入数组的末尾。正如你所看到的，使用 pathlib，很容易获取并导入东西，然后标签就是到目前为止的任何类别。我们将为训练集和测试集都这样做。

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

训练集中有 75,000 个样本，测试集中有 25,000 个样本。训练集中的 50,000 个样本是无监督的，当我们进行分类时，实际上我们将无法使用它们。Jeremy 发现这比 torch.text 方法更容易，后者需要很多层和包装器，因为最终，读取文本文件并不那么困难。

col_names = ['labels','text']

一个总是好的想法是随机排序[23:19]。特别是当你有多个需要以相同方式排序的东西时，了解这个简单的随机排序技巧是很有用的。在这种情况下，你有标签和texts。np.random.permutation，如果你给它一个整数，它会给你一个从 0 到该数字之间的随机列表，但不包括该数字，顺序是随机的。

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

你可以将其作为索引器传递，以便得到一个按照那种随机顺序排序的列表。所以在这种情况下，它将以相同的随机方式对trn_texts和trn_labels进行排序。这是一个有用的小技巧。

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

现在我们有了排序好的文本和标签，我们可以从中创建一个数据框[24:07]。我们为什么要这样做呢？原因是因为在文本分类数据集中，开始出现了一种有点标准的方法，即将训练集作为一个 CSV 文件，其中标签在前，NLP 文档的文本在后。所以它基本上看起来像这样：

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

所以你有你的标签和文本，然后有一个名为 classes.txt 的文件，其中只列出了类别。我说“有点标准”，因为在最近的一篇学术论文中，Yann LeCun 和一组研究人员查看了相当多的数据集，并且他们对所有数据集都使用了这种格式。所以这就是我最近一篇论文开始使用的格式。你会发现，如果你将你的数据放入这种格式的笔记本中，整个笔记本每次都会运行[25:17]。所以，与其有一千种不同的格式，我只是说让我们选择一个标准格式，你的工作就是将你的数据放入那个格式，即 CSV 文件。CSV 文件默认没有标题。

你会注意到在开始时，我们有两条不同的路径[25:51]。一条是分类路径，另一条是语言模型路径。在自然语言处理中，你会一直看到 LM。LM 代表语言模型。分类路径将包含我们将用来创建情感分析模型的信息。语言模型路径将包含我们需要创建语言模型的信息。所以它们有一点不同。一个不同之处是，在分类路径中创建 train.csv 时，我们会删除所有标签为 2 的内容，因为标签为 2 是“无监督”的，我们不能使用它。

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

第二个不同之处是标签[26:51]。对于分类路径，标签是实际标签，但对于语言模型，没有标签，所以我们只使用一堆零，这样做会更容易一些，因为我们可以使用一致的数据框/CSV 格式。

现在语言模型，我们可以创建自己的验证集，所以你可能已经遇到了 sklearn.model_selection.train_test_split，这是一个非常简单的函数，根据你指定的比例随机将数据集分割成训练集和验证集。在这种情况下，我们将我们的分类训练和验证合并在一起，按 10%进行分割，现在我们有 90,000 个训练数据，10,000 个验证数据用于我们的语言模型。这样就为我们的语言模型和分类器以标准格式获取了数据。

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)

接下来我们需要做的是标记化。标记化意味着在这个阶段，对于一个文档（比如一部电影评论），我们有一个很长的字符串，我们想将其转换为一个标记列表，类似于一个单词列表但不完全相同。例如，don’t我们希望它变成do和n’t，我们可能希望句号成为一个标记，等等。标记化是我们交给一个名为 spaCy 的绝妙库的事情 — 部分原因是因为它是由澳大利亚人编写的，部分原因是因为它擅长它所做的事情。我们在 spaCy 之上加了一些东西，但绝大部分工作都是由 spaCy 完成的。

chunksize=24000

在将其传递给 spaCy 之前，Jeremy 编写了这个简单的fixup函数，每次他查看不同的数据集（在构建过程中大约有十几个），每个数据集都有不同的奇怪之处需要替换。所以这是他迄今为止想出的所有内容，希望这也能帮助到你。所有实体都是 html 未转义的，还有更多我们替换的内容。看看在你输入的文本上运行这个函数的结果，并确保里面没有更多奇怪的标记。

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)

get_all函数调用get_texts，而get_texts将做一些事情[29:40]。其中之一是应用我们刚提到的fixup。

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

让我们仔细看一下，因为有一些有趣的事情要指出。我们将使用 pandas 打开我们的 train.csv 文件，但是我们传入了一个你可能以前没有见过的额外参数，叫做chunksize。当涉及存储和使用文本数据时，Python 和 pandas 都可能非常低效。所以你会发现，在 NLP 领域很少有人在处理大型语料库。Jeremy 认为部分原因是传统工具使得这一过程非常困难——你总是会耗尽内存。所以他今天向我们展示的这个过程，他已经成功地在超过十亿字的语料库上使用了这段代码。其中一个简单的技巧就是 pandas 中的chunksize。这意味着 pandas 不会返回一个数据框，而是返回一个我们可以迭代遍历数据框块的迭代器。这就是为什么我们不说tok_trn = get_text(df_trn)，而是调用get_all，它会遍历数据框，但实际上它正在遍历数据框的块，因此每个块基本上是代表数据子集的数据框。

问题：当我处理 NLP 数据时，很多时候我会遇到包含外文文本/字符的数据。是更好地丢弃它们还是保留它们？不，绝对要保留它们。整个过程都是 unicode 的，我实际上已经在中文文本上使用过这个过程。这个过程设计用于几乎任何东西。一般来说，大多数情况下，删除任何东西都不是一个好主意。老式的 NLP 方法倾向于执行所有这些词形还原和所有这些规范化步骤来摆脱东西，将所有东西转换为小写等等。但这是在丢弃你事先不知道是否有用的信息，所以不要丢弃信息。

因此，我们遍历每个块，每个块都是一个数据框，然后我们调用get_texts。get_texts将获取标签并将它们转换为整数，并且它将获取文本。有几点需要指出：

• 在包含文本之前，我们有一个“流的开始”（BOS）标记，我们在开始时定义了。这些特定的字母字符串并没有什么特别之处——它们只是我发现在正常文本中很少出现的。因此，每个文本都将以‘xbos’开头——为什么呢？因为对于你的模型来说，知道何时开始一个新文本通常是有用的。例如，如果是一个语言模型，我们将把所有文本连接在一起。因此，让它知道所有这些文章何时结束以及新文章何时开始是非常有帮助的，这样我可能应该忘记它们的一些上下文了。

• Ditto 经常出现的情况是文本有多个字段，比如标题和摘要，然后是主要文档。因此，同样地，我们在 CSV 中可以有多个字段。这个过程设计得非常灵活。在每个字段的开始，我们放置一个特殊的“字段开始于此”标记，后面跟着这个字段开始的编号，对于我们有多少个字段就有多少个。然后我们对其应用fixup。

• 然后最重要的是[33:54], 我们对其进行标记化 - 通过进行“process all multiprocessing” (proc_all_mp) 进行标记化。标记化往往会很慢，但现在我们的机器都有多个核心，AWS 上一些更好的机器可以有几十个核心。spaCy 不太适合多处理，但 Jeremy 最终找到了让它工作的方法。好消息是现在所有这些都包含在这一个函数中。所以你只需要传递给该函数一个要标记化的事物列表，该列表的每个部分将在不同的核心上进行标记化。还有一个名为partition_by_cores的函数，它接受一个列表并将其拆分为子列表。子列表的数量就是您计算机上的核心数量。在 Jeremy 的机器上，没有多处理，这需要大约一个半小时，而使用多处理，大约需要 2 分钟。所以这是一个非常方便的东西。随时查看并利用它来处理您自己的东西。记住，我们的笔记本电脑中都有多个核心，而且很少有 Python 中的东西能够利用它，除非您稍微努力使其工作。

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)

这是最终结果[35:42]。流的开始标记（xbos），第 1 个字段的开始标记（xfld 1），以及标记化的文本。您会看到标点现在是一个单独的标记。

**t_up**: t_up mgm - MGM 最初是大写的。但有趣的是，通常人们要么全部小写，要么保持大小写不变。现在如果保持大小写不变，那么“SCREW YOU”和“screw you”是两组完全不同的标记，必须从头开始学习。或者如果全部小写，那么根本没有区别。那么如何解决这个问题，以便既获得“我现在在大声喊叫”的语义影响，又不必学习大声喊叫版本与正常版本。所以想法是想出一个唯一的标记，表示下一个事物全是大写。然后我们将其小写，所以现在以前大写的部分被小写，然后我们可以学习全部大写的语义含义。

**tk_rep**: 同样，如果您连续有 29 个!，我们不会为 29 个感叹号学习一个单独的标记 - 而是为“下一个事物重复很多次”放入一个特殊的标记，然后放入数字 29 和一个感叹号（即tk_rep 29 !）。所以有一些类似的技巧。如果您对 NLP 感兴趣，请查看 Jeremy 添加的这些小技巧的标记器代码，因为其中一些很有趣。

' '.join(tok_trn[0])

用这种方式做事情的好处是我们现在可以只需np.save一下，稍后再加载回来[37:44]。我们不必像我们通常需要在 torchtext 或许多其他库中那样每次都重新计算所有这些东西。现在我们已经将其标记化，下一步需要做的是将其转换为数字，我们称之为数字化。我们数字化的方式非常简单。

• 我们制作一个按某种顺序出现的所有单词的列表

• 然后我们用该列表中的索引替换每个单词。

• 所有标记的列表，我们称之为词汇表。

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

这里是一些词汇的例子。Python 中的 Counter 类对此非常有用。它基本上为我们提供了一个独特项目和它们的计数的列表。这里是词汇中最常见的 25 个东西。一般来说，我们不希望在我们的词汇表中有每个独特的标记。如果它不至少出现两次，那可能只是一个拼写错误或者一个我们无法学到任何东西的词，如果它不经常出现的话。此外，在这一部分我们将要学习的东西一旦词汇量超过 60,000 就会变得有些笨重。如果时间允许，我们可能会看一下 Jeremy 最近在处理更大词汇量方面所做的一些工作，否则这可能会在未来的课程中出现。但实际上，对于分类来说，超过 60,000 个词并没有什么帮助。

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

所以我们将把我们的词汇表限制在 60,000 个词，至少出现两次的东西。这里有一个简单的方法。使用.most_common，传入最大词汇大小。这将按频率排序，如果出现的频率低于最小频率，则根本不要理会。这给我们了itos - 这是 torchtext 使用的相同名称，意思是整数到字符串。这只是词汇表中独特标记的列表。我们将插入两个额外的标记 - 一个未知的词汇项（_unk_）和一个填充的词汇项（_pad_）。

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

然后我们可以创建一个字典，它是相反的（从字符串到整数）。这不会覆盖所有内容，因为我们故意将它截断到 60,000 个词。如果我们遇到字典中没有的东西，我们希望用零替换它，表示未知，所以我们可以使用带有 lambda 函数的 defaultdict，它总是返回零。

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

现在我们定义了我们的stoi字典，我们可以为每个句子的每个单词调用它。

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

这是我们的数字化版本：

当然，好处是我们也可以保存这一步。每次我们到达另一个步骤时，我们都可以保存它。与您用于图像的文件相比，这些文件并不是很大。文本通常很小。

非常重要的是也保存那个词汇表（itos）。数字列表没有意义，除非你知道每个数字指的是什么，这就是itos告诉你的。

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

现在我们的词汇量是 60,002，我们的训练语言模型中有 90,000 个文档。

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

这就是你要做的预处理。如果我们想的话，我们可以将更多的内容包装在实用函数中，但这一切都非常简单明了，一旦你将数据集转换为 CSV 格式，这段代码就可以适用于任何数据集。

这是我们如何做的。获取 wikitext 模型。如果你使用wget -r，它将递归地抓取整个目录，其中有一些东西。

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

我们需要确保我们的语言模型具有与 Jeremy 的 wikitext 相同的嵌入大小、隐藏数量和层数，否则你无法加载这些权重。

em_sz,nh,nl = 400,1150,3

这是我们的预训练路径和我们的预训练语言模型路径。

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

让我们继续从前向 wikitext103 模型中torch.load这些权重。我们通常不使用 torch.load，但这是 PyTorch 抓取文件的方式。它基本上给你一个包含层名称和这些权重的张量/数组的字典。

现在的问题是，wikitext 语言模型是建立在一个特定词汇表上的，这个词汇表与我们的不同。我们的#40 不同于 wikitext103 模型的#40。所以我们需要将一个映射到另一个。这非常简单，因为幸运的是 Jeremy 保存了 wikitext 词汇表的itos。

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)

这是 wikitext103 模型中每个单词的列表，我们可以使用相同的defaultdict技巧来反向映射。我们将使用-1 来表示它不在 wikitext 词典中。

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

现在我们可以说我们的新权重集只是一个由词汇大小乘以嵌入大小（即我们将创建一个嵌入矩阵）的一大堆零。然后我们遍历我们 IMDb 词汇表中的每一个单词。我们将在 wikitext103 词汇表的stoi2（字符串到整数）中查找它，并查看它是否是一个单词。如果那是一个单词，那么我们就不会得到-1。所以r将大于或等于零，那么在这种情况下，我们将把嵌入矩阵的那一行设置为存储在名为‘0.encoder.weight’的元素内的权重。你可以查看这个字典wgts，很明显每个名称对应什么。它看起来非常类似于你在设置模块时给它的名称，所以这里是编码器权重。

如果我们找不到它 [49:02], 我们将使用行均值——换句话说，这是 wikitext103 中所有嵌入权重的平均值。因此，我们将得到一个嵌入矩阵，其中包含我们的 IMDb 词汇表和 wikitext103 词汇表中的每个单词；我们将使用 wikitext103 嵌入矩阵权重；对于其他任何单词，我们将只使用 wikitext103 嵌入矩阵中的平均权重。

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

然后我们将用new_w替换编码器权重，变成一个张量[49:35]。我们没有谈论过权重绑定，但基本上解码器（将最终预测转换回单词的部分）使用完全相同的权重，所以我们也将它放在那里。然后有一个关于我们如何进行嵌入丢弃的奇怪事情，最终导致它们有一个完全独立的副本，原因并不重要。所以我们把权重放回它们需要去的地方。所以现在这是一组 torch 状态，我们可以加载进去。

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

让我们创建我们的语言模型。我们将使用的基本方法是将所有文档连接在一起，形成一个长度为 24,998,320 的单词标记列表。这将是我们作为训练集传入的内容。所以对于语言模型：

• 我们将所有文档连接在一起。

• 我们将不断尝试预测这些单词之后的下一个单词。

• 我们将设置一系列的丢弃。

• 一旦我们有了一个模型数据对象，我们就可以从中获取模型，这样就会给我们一个学习者。

• 然后像往常一样，我们可以调用learner.fit。我们在最后一层上进行一个周期，只是为了确认一下。它的设置是最后一层是嵌入单词，因为显然这是最可能出错的地方，因为很多这些嵌入权重甚至在词汇表中都不存在。所以我们将训练一个周期，只是针对嵌入权重。

• 然后我们将开始对完整模型进行几个周期的训练。看起来怎么样？在第 4 课中，我们在 14 个周期后的损失为 4.23。在这种情况下，我们在 1 个周期后的损失为 4.12。因此，通过在 wikitext103 上进行预训练，我们在 1 个周期后的损失比其他情况下语言模型的最佳损失更好。

问题：wikitext103 模型是什么？它再次是 AWD LSTM 吗[52:41]？是的，我们即将深入研究。我训练它的方式实际上与您在上面看到的代码行完全相同，但没有在 wikitext103 上进行预训练。

fastai 文档项目的目标是创建让读者说“哇，这是我读过的最棒的文档”并且我们有一些关于如何做到这一点的具体想法。这是一种自上而下、深思熟虑、充分利用媒体的方法，交互式实验代码优先，我们都很熟悉。如果您有兴趣参与，您可以在docs 目录中看到基本方法。在那里，除其他内容外，还有transforms-tmpl.adoc。adoc是AsciiDoc。AsciiDoc 类似于 markdown，但它更像是 markdown 需要成为创建实际书籍的工具。许多实际的书籍都是用 AsciiDoc 编写的，它和 markdown 一样易于使用，但你可以用它做更多很酷的事情。这里是更标准的 AsciiDoc 示例。您可以做一些像插入目录(:toc:)这样的事情。::表示在这里放一个定义列表。+表示这是前一个列表项的延续。所以有许多非常方便的功能，它就像是增强版的 markdown。因此，这个 asciidoc 会创建这个 HTML，没有添加自定义 CSS 或其他内容：

我们刚刚开始这个项目 4 个小时。所以你有一个带有超链接到特定部分的目录。我们有交叉引用，我们可以点击跳转到交叉引用。每种方法都附带其详细信息等等。为了使事情更加简单，他们创建了一个专门的模板用于参数、交叉引用、方法等。这个想法是，它几乎会像一本书一样。将会有表格、图片、视频片段和整个超链接。

你可能会想到文档字符串怎么办。但实际上，如果你查看 Python 标准库并查看re.compile()的文档字符串，例如，它只有一行。几乎每个 Python 的文档字符串都是一行。然后 Python 确实这样做——他们有一个包含文档的网站，上面写着“这就是正则表达式是什么，这就是你需要知道的关于它们的东西，如果你想要快速执行它们，你需要编译，这里有一些关于编译的信息”等等。这些信息不在文档字符串中，这也是我们将要做的——我们的文档字符串将是一行，除非有时候你需要两行。欢迎每个人帮助贡献文档。

这与 word2vec 有什么比较？这实际上是一个很好的事情，你可以在这一周花时间思考。我现在会给你总结，但这是一个非常重要的概念区别。主要的概念区别是“word2vec 是什么？”Word2vec 是一个单一的嵌入矩阵——每个单词都有一个向量，就是这样。换句话说，它是一个来自预训练模型的单一层——具体来说，该层是输入层。而且具体来说，那个预训练模型是一个线性模型，它是在一个叫做共现矩阵的东西上进行预训练的。所以我们没有特别的理由相信这个模型已经学到了关于英语语言的很多东西，或者它有任何特殊的能力，因为它只是一个单一的线性层，就是这样。那么这个 wikitext103 模型呢？它是一个语言模型，有一个 400 维的嵌入矩阵，3 个隐藏层，每层有 1,150 个激活，还有正则化和所有那些与输入输出矩阵相关的东西——基本上是一个最先进的 AWD LSTM。一个单一线性模型的单一层与一个三层循环神经网络之间的区别是什么？一切！它们具有非常不同的能力水平。所以当你尝试使用一个预训练语言模型与 word2vec 层时，你会发现在绝大多数任务中得到非常不同的结果。

如果 numpy 数组不适合内存怎么办？是否可以直接从大型 CSV 文件中编写 PyTorch 数据加载器？几乎肯定不会出现这种情况，所以我不会花时间在这上面。这些东西很小——它们只是整数。想想你需要多少整数才会耗尽内存？那是不会发生的。它们不必适合 GPU 内存，只需适合你的内存。我实际上做过另一个维基百科模型，我称之为 giga wiki，它包含了整个维基百科，甚至那个也很容易适合内存。我之所以不使用它，是因为事实证明它与 wikitext103 相比并没有真正帮助太多。我建立了一个比我在学术文献中找到的任何其他人都要大的模型，并且它适合单台机器的内存。

问题：对于嵌入权重进行平均化的背后思想是什么[1:01:24]？它们必须被设置为某个值。这些是之前没有出现过的单词，所以另一个选择是我们可以将它们设置为零。但这似乎是一个非常极端的做法。零是一个非常极端的数字。为什么要设置为零？我们可以将它设置为一些随机数，但如果是这样，那么这些随机数的均值和标准差是多少？它们应该是均匀的吗？如果我们只是平均化其他嵌入，那么我们就得到了一个合理缩放的东西。只是澄清一下，这就是我们如何初始化在训练语料库中没有出现过的单词。

这是我们之前见过的大量内容，但有些地方有所改变。实际上，与第 1 部分相比，这部分要容易得多，但我想深入一点了解语言模型加载器。

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

这是LanguageModelLoader，我真的希望到现在为止，你已经学会了在你的编辑器或 IDE 中如何跳转到符号[1:02:37]。我不希望你为了找出LanguageModelLoader的源代码而感到困扰。如果你的编辑器没有做到这一点，就不要再使用那个编辑器了。有很多好用的免费编辑器可以轻松实现这一点。

这就是LanguageModelLoader的源代码，有趣的是它并没有做任何特别复杂的事情。它并没有从任何地方派生。能够作为数据加载器的关键是它可以被迭代。

这是 fastai.model 中的fit函数[1:03:41]。这是最终所有东西都会经过的地方，它会遍历每个时代，从数据加载器创建一个迭代器，然后通过一个 for 循环进行遍历。所以任何你可以通过 for 循环遍历的东西都可以作为数据加载器。具体来说，它需要返回独立和依赖变量的元组，用于小批量。

所以任何具有__iter__方法的东西都可以作为迭代器[1:04:09]。yield是一个很棒的 Python 关键字，如果你还不了解的话，你可能应该学习一下。它基本上会输出一个东西，然后等待你请求另一个东西——通常在一个 for 循环中。在这种情况下，我们通过传入数字nums来初始化语言模型，这是我们所有文档连接在一起的数字化长列表。我们首先要做的是“批量化”它。这是上次很多人感到困惑的地方。如果我们的批量大小是 64，我们的列表中有 2500 万个数字。我们不是创建长度为 64 的项目——我们总共创建了 64 个项目。因此，每个项目的大小是t除以 64，即 390k。这就是我们在这里做的事情：

data = data.view(self.bs, -1).t().contiguous()

我们对它进行重塑，使得这个轴的长度为 64，-1表示其他所有内容（390k blob），然后我们对它进行转置。这意味着我们现在有 64 列，390k 行。然后每次迭代时，我们抓取一批序列长度为bptt（通过时间反向传播）大约等于 70 的数据。我们只抓取那么多行。所以从第i行到第i+70行，我们尝试预测下一个。请记住，我们试图预测我们当前位置的下一个位置。

所以我们有 64 列，每列是我们 2500 万个标记的 1/64，数以百万计的长，我们每次只抓取 70 个[1:06:29]。所以每次我们抓取每列时，它都会与前一列连接起来。这就是为什么我们会得到这种一致性。这个语言模型是有状态的，这一点非常重要。

语言模型中的几乎所有很酷的东西都是从 Stephen Merity 的 AWD-LSTM 中偷来的[1:06:59]，包括这里的这个小技巧：

如果我们每次都拿 70 个，然后回去做一个新的时代，我们每次都会拿到完全相同的批次 — 没有随机性。通常，我们每次做一个时代或每次拿一些数据时，我们都会随机洗牌我们的数据。但是对于语言模型来说，我们不能这样做，因为这个集合必须与之前的集合连接起来，因为它试图学习句子。如果你突然跳到别的地方，那作为一个句子就没有意义了。所以 Stephen 的想法是说“好吧，既然我们不能洗牌顺序，那么我们就随机改变序列长度”。基本上，95%的时间，我们会使用bptt（即 70），但 5%的时间，我们会使用一半。然后他说“你知道吗，我甚至不会把那作为序列长度，我会创建一个平均值为那个的正态分布随机数，标准差为 5，然后我会把那作为序列长度。” 所以序列长度大约是 70，这意味着每次我们经过时，我们得到的批次会稍微不同。所以我们有了那一点额外的随机性。Jeremy 问 Stephen Merity 他是从哪里得到这个想法的，他是自己想出来的吗？他说“我想我是自己想出来的，但似乎这么明显，以至于我觉得我可能没有想到” — 这对于 Jeremy 在深度学习中想出一个想法来说是真的。每次 Jeremy 想出一个想法时，它总是看起来如此明显，以至于你会假设别人已经想到了。但 Jeremy 认为 Stephen 是自己想出来的。

LanguageModelLoader 是一个很好的东西，如果你想用数据加载器做一些不太常见的事情的话，可以看一下[1:08:55]。这是一个简单的角色模型，你可以用它来从头开始创建一个数据加载器 — 一个可以输出数据批次的东西。

我们的语言模型加载器接收了所有文档连接在一起以及批次大小和 bptt[1:09:14]。

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
)

一般来说，我们想要创建一个学习器，通常我们这样做是通过获取一个模型数据对象并调用某种方法，这个方法有各种各样的名字，但通常我们称这个方法为get_model。这个想法是模型数据对象有足够的信息来知道给你什么样的模型。所以我们必须创建那个模型数据对象，这意味着我们需要一个非常容易做的 LanguageModelData 类[1:09:51]。

这里有所有的部分。我们将创建一个自定义的学习器，一个自定义的模型数据类，和一个自定义的模型类。所以一个模型数据类，同样它不继承任何东西，所以你真的可以看到几乎没有什么要做的。你需要告诉它最重要的是你的训练集是什么（给它一个数据加载器），你的验证集是什么（给它一个数据加载器），还可以选择地，给它一个测试集（数据加载器），再加上其他需要知道的任何东西。它可能需要知道 bptt，它需要知道标记的数量（即词汇表大小），它需要知道填充索引是什么。这样它就可以保存临时文件和模型，模型数据一直需要知道路径。所以我们只是获取所有这些东西然后把它们倒出来。就是这样。这就是整个初始化器。那里根本没有逻辑。

然后所有的工作都发生在get_model内部。get_model 调用我们稍后将看到的东西，它只是获取一个普通的 PyTorch nn.Module 架构，并将其放在 GPU 上。注意：在 PyTorch 中，我们会说.cuda()，在 fastai 中最好说to_gpu()，原因是如果你没有 GPU，它会留在 CPU 上。它还提供了一个全局变量，你可以设置选择是否将其放在 GPU 上，所以这是一个更好的方法。我们将模型包装在LanguageModel中，而LanguageModel是BasicModel的子类，除了定义层组之外几乎什么都不做。记住当我们进行区分性学习率时，不同的层有不同的学习率或者我们冻结不同的数量时，我们不会为每一层提供不同的学习率，因为可能有一千层。我们为每个层组提供不同的学习率。所以当你创建一个自定义模型时，你只需要覆盖这一点，它返回所有层组的列表。在这种情况下，最后一个层组包含模型的最后部分和一个 dropout 位。其余部分（*这里表示拆分）所以这将是每个 RNN 层一个层。这就是全部。

最后将其转换为一个 learner。所以一个 learner，你只需传入模型，它就会变成一个 learner。在这种情况下，我们已经重写了 learner，唯一做的事情就是说我希望默认的损失函数是交叉熵。这整套自定义模型、自定义模型数据、自定义 learner 都适合在一个屏幕上。它们基本上看起来都是这样。

这段代码库中有趣的部分是get_language_model。因为这给了我们我们的 AWD LSTM。实际上它包含了一个重要的想法。一个大而极其简单的想法，其他人都认为这是非常明显的，Jeremy 与 NLP 社区中的每个人都认为这是疯狂的。也就是说，每个模型都可以被看作是一个骨干加一个头部，如果你预训练骨干并添加一个随机头部，你可以进行微调，这是一个好主意。

这两段代码，字面上紧挨在一起，这就是fastai.lm_rnn中的全部内容。

get_language_model：创建一个 RNN 编码器，然后创建一个顺序模型，将其放在顶部 - 一个线性解码器。

get_rnn_classifier：创建一个 RNN 编码器，然后创建一个顺序模型，将其放在顶部 - 一个池化线性分类器。

我们马上会看到这些差异是什么，但你已经得到了基本的想法。它们基本上在做同样的事情。它们有这个头部，然后在顶部添加一个简单的线性层。

问题：之前有一个问题，关于这是否适用于其他语言。是的，这整个过程适用于任何语言。你需要重新训练语言模型以适应那种语言的语料库吗？绝对需要！所以 wikitext103 预训练语言模型了解英语。你可以将其用作法语或德语模型的预训练起点，重新训练嵌入层可能会有所帮助。对于中文，可能效果不太好。但是鉴于语言模型可以从任何未标记的文档中训练，你永远不必这样做。因为世界上几乎每种语言都有大量文档 - 你可以获取报纸、网页、议会记录等。只要你有几千份展示该语言正常使用的文档，你就可以创建一个语言模型。我们的一位学生尝试了这种方法来处理泰语，他说他建立的第一个模型轻松击败了以前最先进的泰语分类器。对于那些国际同学，这是一个简单的方法，让你能够撰写一篇论文，要么创建你所在语言的第一个分类器，要么击败其他人的分类器。然后你可以告诉他们，你已经学习深度学习六个月了，惹恼你所在国家的所有学者。

这是我们的 RNN 编码器。它是一个标准的 nn.Module。看起来似乎有更多的东西在里面，但实际上我们只是创建一个嵌入层，为每个被要求的层创建一个 LSTM，就是这样。它里面的其他所有东西都是 dropout。基本上，AWS LSTM 论文中所有有趣的东西（几乎都是）都是你可以放置 dropout 的地方。然后前向传播基本上是相同的。调用嵌入层，添加一些 dropout，通过每一层，调用那个 RNN 层，将其附加到我们的输出列表中，添加 dropout，就这样。所以这很简单。

你应该阅读的论文是 AWD LSTM 论文，标题是Regularizing and Optimizing LSTM Language Models。它写得很好，非常易懂，并且完全在 fastai 中实现 - 所以你可以看到那篇论文的所有代码。实际上，很多代码都是在得到 Stephen 的许可后无耻地剽窃自他优秀的 GitHub 仓库 AWD LSTM。

这篇论文提到了其他论文。比如为什么编码器权重和解码器权重是相同的。这是因为有一种叫做“绑定权重”的东西。在get_language_model中，有一个叫做tie_weights的东西，默认为 true。如果为 true，那么我们实际上使用相同的权重矩阵用于编码器和解码器。它们指向同一块内存。为什么会这样？结果是什么？这是 Stephen 的论文中的一个引用，也是一篇写得很好的论文，你可以查阅并了解权重绑定。

我们基本上有一个标准的 RNN。唯一不标准的地方是它有更多类型的 dropout。在 RNN 的顶部顺序模型中，我们放置一个线性解码器，这实际上是代码屏幕的一半。它有一个单一的线性层，我们将权重初始化为某个范围，添加一些 dropout，就这样。所以它是一个带有 dropout 的线性层。

所以语言模型是：

• RNN → 一个带有 dropout 的线性层

所以我们把这个变成了一篇论文，当我说“我们”时，是和这个家伙 Sebastian Ruder 一起做的。现在你可能记得他的名字，因为在第 5 课时，我告诉过你我实际上和 Sebastian 分享了第 4 课，因为我认为他是一个很棒的研究者，我认为他可能会喜欢。我根本不认识他。令我惊讶的是，他实际上看了这个视频。他看了整个视频并说：

Sebastian：“这实际上相当棒！我们应该把这变成一篇论文。”

Jeremy：“我不写论文。我不关心论文，对论文不感兴趣——那听起来真的很无聊”

Sebastian：“好的，我替你写论文。”

Jeremy：“你现在真的不能写关于这个的论文，因为你必须做研究来将其与其他事物进行比较（称为消融研究），看看哪部分实际起作用。这里没有严谨性，我只是把我脑子里想到的一切都放进去，然后把它们全部放在一起，结果竟然奏效了”

Sebastian：“好的，如果我写所有的论文并做所有你的消融研究，那我们可以写论文吗？”

Jeremy：“嗯，这就像一个我还没有记录的整个库，我现在还不会记录，你也不知道它是如何工作的”

Sebastian：“好的，如果我写了论文，做了消融研究，从头开始弄清楚代码的工作原理而不打扰你，那我们可以写论文吗？”

Jeremy：“嗯……是的，如果你做了所有这些事情，那我们可以写论文。好吧！”

然后两天后，他回来说“好的，我已经起草了论文。” 所以，我分享这个故事是想说，如果你是爱尔兰的某个学生，想做好工作，不要让任何人阻止你。我至少没有鼓励他。但最后，他说“我想做这项工作，我认为会很好，我会弄清楚的”，他写了一篇很棒的论文。他做了消融研究，弄清楚了 fastai 的工作原理，现在我们计划一起写另一篇论文。你必须小心，因为有时我会收到陌生人的消息，说“我有很多好主意，我们可以喝咖啡吗？”——“我不想……我随时可以在办公室喝咖啡，谢谢”。但是，说“嘿，我采纳了你的想法，写了一篇论文，做了一堆实验，弄清楚了你的代码如何工作，并为其添加了文档——我们应该提交到会议上吗？”就很不一样了。你明白我的意思吗？没有什么能阻止你做出惊人的工作，如果你做出了有助于他人的惊人工作，比如这种情况，我很高兴我们有了一篇论文。我并不特别关心论文，但我认为这些想法现在有了这样严谨的研究很酷。

技巧＃2 是创建 Python 脚本，这就是我们最终做的事情。所以我最终为 Sebastian 创建了一个小 Python 脚本，告诉他这是你需要做的基本步骤，现在你需要为其他所有事情创建不同的版本。我建议他尝试使用一个叫做 Google Fire 的东西。Google Fire 的作用是，你创建一个带有大量参数的函数，这些都是 Sebastian 想要尝试的不同事情 - 不同的 dropout 数量，不同的学习率，我是否使用预训练，我是否使用 CLR，我是否使用区分性学习率等等。所以你创建一个函数，然后添加一些内容说：

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

你什么都不做 - 你不必添加任何元数据，任何文档字符串，什么都不用添加，然后你调用那个脚本，你现在自动拥有了一个命令行界面。这是在终端中运行许多不同变体的超级简单方法。如果你想要做很多变体，这种方法比使用笔记本更容易，因为你可以编写一个 bash 脚本来尝试所有这些变体并将它们全部输出。

你会在courses/dl2中找到一个名为imdb_scripts的文件夹，里面有 Sebastian 和我使用的所有脚本。因为我们需要对每个数据集进行标记化和数值化，然后为每个数据集训练一个语言模型和一个分类器。我们必须以各种不同的方式做所有这些事情来进行比较，所以我们为所有这些事情都准备了脚本。你可以查看并看到我们使用的所有脚本。

当你在做很多脚本时，你会在各个地方得到不同的代码。最终，你可能会感到沮丧，不想一遍又一遍地创建 fastai 库的符号链接。但你可能也不想 pip 安装它，因为那个版本往往有点旧，我们进展如此之快，你想使用 Git 中的当前版本。如果你从 fastai 仓库基础目录运行 pip install -e .，它会做一些相当巧妙的事情，基本上是在 site-packages 目录内创建一个到 fastai 库的符号链接（即你本地克隆的 Git 仓库）。你的 site-packages 目录是你的主 Python 库。所以如果你这样做，你就可以从任何地方访问 fastai，但每次你执行 git pull 时，你都会得到最新版本。这样做的一个缺点是它会安装 pip 中的任何更新版本的包，这可能会让 Conda 有点困惑，所以另一个选择是只需将 fastai 库符号链接到你的 site-packages 库。这同样有效。你可以从任何地方使用 fastai，当你想要在系统的不同目录中运行使用 fastai 的脚本时，这是非常方便的。

让我们构建一个序列到序列模型！我们将致力于机器翻译。机器翻译已经存在很长时间了，但我们将看一种称为神经翻译的方法，它使用神经网络进行翻译。神经机器翻译几年前出现，当时并不像使用经典特征工程和标准 NLP 方法（如词干处理、调整词频、n-gram 等）的统计机器翻译方法那么好。一年后，它比其他所有方法都要好。它基于一个叫做 BLEU 的指标——我们不会讨论这个指标，因为它不是一个很好的指标，也不是很有趣，但每个人都在使用它。

我们看到机器翻译开始沿着我们在 2012 年看到的计算机视觉对象分类的道路前进，后者刚刚超越了最先进技术，现在正在以很快的速度超越它。看这个视频的人不太可能会构建一个机器翻译模型，因为translate.google.com/效果相当不错。那么我们为什么要学习机器翻译呢？我们学习机器翻译的原因是，将一些输入（比如法语句子）转换为任意长度的其他输出（比如英语句子）的一般想法是一件非常有用的事情。例如，正如我们刚才看到的，Hamel 将 GitHub 问题转换为摘要。另一个例子是将视频转换为描述，或者基本上任何你需要输出任意长度输出的地方，通常是一个句子。也许是将 CT 扫描转换为放射学报告——这就是你可以使用序列到序列学习的地方。

• 端到端训练：不需要围绕启发式和繁琐的特征工程纠缠。

• 我们能够构建这些分布式表示，这些表示被单个网络中的许多概念共享。

• 我们能够在 RNN 中使用长期状态，因此它比 n-gram 类型的方法使用了更多的上下文。

• 最终，我们生成的文本也使用了 RNN，因此我们可以构建更加流畅的东西。

笔记本

我们将尝试按照标准的神经网络方法将法语翻译成英语：

1. 数据

2. 架构

3. 损失函数

Stephen 使用了“编码器”这个词，但我们倾向于使用“骨干”。就像当我们谈论向现有模型添加自定义头部时，例如现有的预训练 ImageNet 模型，我们说这是我们的骨干，然后我们在其上添加一些执行我们想要的任务的头部。在序列到序列学习中，他们使用“编码器”这个词，但基本上是一样的——它是神经网络架构的一部分，它接受输入并将其转换为我们可以在其上添加几层以获取某些内容的表示，就像我们为分类器所做的那样，我们在其上堆叠一个线性层以将其转换为情感。不过，这次我们要做的事情比创建情感要困难一点。我们不是将隐藏状态转换为积极或消极情感，而是要将其转换为一系列标记，这些标记是 Stephen 示例中的德语句子。

这听起来更像是语言模型而不是分类器，因为语言有多个标记（对于每个输入单词，都有一个输出单词）。但语言模型也更容易，因为语言模型输出中的标记数量与语言模型输入中的标记数量相同。不仅它们的长度相同，而且它们完全匹配（例如，单词一后面是单词二，单词二后面是单词三，依此类推）。对于翻译语言，你不一定知道单词“he”会被翻译为输出的第一个单词（不幸的是，在这种特殊情况下是这样的）。很多时候，主语宾语顺序会有所不同，或者会插入一些额外的单词，或者我们需要添加一些代词，性别化的文章等。我们将要处理的关键问题是，我们有一个任意长度的输出，其中输出中的标记与输入中的特定标记的顺序不对应。但总体思路是一样的。这里有一个 RNN 来编码输入，将其转换为一些隐藏状态，然后我们要学习的新内容是生成一个序列输出。

我们已经知道：

• 从序列到类别（IMDB 分类器）

• 从序列到等长序列（语言模型）

但我们还不知道如何做一个通用的序列到序列，所以这是今天的新内容。除非你真正理解第 6 课中 RNN 的工作原理，否则很少有人能理解这一点。

我们学到，RNN 在其核心是一个标准的全连接网络。下面是一个有 4 层的网络——接受一个输入并通过四层，但在第二层，它将第二个输入连接起来，第三层将第三个输入连接起来，但实际上我们在 Python 中只写了一个四层的神经网络。除了线性层和 ReLU 之外，我们没有使用其他东西。每次输入时我们使用相同的权重矩阵，每次从一个隐藏状态到下一个时我们也使用相同的矩阵——这就是为什么这些箭头是相同颜色的原因。

我们可以将上面的图重新绘制成下面的样子[19:29]。

我们不仅重新绘制了它，还将 PyTorch 中的四行线性代码替换为一个 for 循环。记住，我们有一个与下面完全相同的东西，但只有四行代码说self.l_in(input)，我们用一个 for 循环替换了它，因为这样重构很好。不改变任何数学、任何想法或任何输出的重构是一个 RNN。它将代码中的一堆单独的行转换为 Python 的 for 循环。

我们可以将输出放在循环内部而不是在循环外部[20:25]。如果这样做，我们现在将为每个输入生成一个单独的输出。上面的代码，隐藏状态每次都被替换，最终我们只输出最终的隐藏状态。但是如果我们有一个说hs.append(h)并在最后返回hs的东西，那就是下面的图片。

要记住的主要事情是当我们说隐藏状态时，我们指的是一个向量——技术上是每个小批量中的每个东西的向量，所以它是一个矩阵，但通常当 Jeremy 谈到这些事情时，他忽略了小批量部分，将其视为单个项目。

我们还学到可以将这些层堆叠在一起[21:41]。所以与其上面图中的左侧 RNN 输出，它们可以将输入传递到第二个 RNN 中。如果你此时在想“我想我理解了，但我不太确定”，那意味着你并没有理解。你真正理解的唯一方法是从头开始用 PyTorch 或 Numpy 编写这个。如果你做不到，那么你知道你并没有理解，你可以回去重新观看第 6 课，并查看笔记本，复制一些想法，直到你能够。重要的是你能够从头开始编写它——不到一屏的代码。所以你要确保你可以创建一个 2 层的 RNN。下面是展开它的样子。

为了得到（x，y）句子对，我们将从下载数据集开始[22:39]。训练一个翻译模型需要很长时间。谷歌的翻译模型有八层 RNN 堆叠在一起。八层和两层之间没有概念上的区别。如果你是谷歌，有更多的 GPU 或 TPU，那么你可以这样做。否则，在我们的情况下，我们构建的序列到序列模型很可能不需要那种计算水平。所以为了保持简单[23:22]，让我们做一个简化的事情，而不是学习如何翻译法语到英语的任何句子，让我们学习如何将法语问题翻译成英语问题——具体是以 what/where/which/when 开头的问题。这里有一个正则表达式，寻找以“wh”开头并以问号结尾的内容。

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

将其转储为一个 pickle，这样我们就不必再次执行它，现在我们有 52,000 个句子对，这里有一些示例：

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

这样做的一个好处是，关于什么/谁/在哪里类型的问题往往相当简短。但是，我们可以从零开始学习，没有对语言概念的先前理解，更不用说英语或法语，我们可以创建一个可以将一个语言翻译成另一种语言的东西，对于任何任意问题，只需要 50k 个句子，听起来像是一个难以置信的困难任务。因此，如果我们能取得任何进展，那将是令人印象深刻的。这是一个非常少的数据来进行一个非常复杂的练习。

qs包含法语和英语的元组。你可以使用这个方便的习语将它们分开成一个英语问题列表和一个法语问题列表。

en_qs,fr_qs = zip(*qs)

然后我们对英语问题进行标记化，对法语问题进行标记化。所以记住，这只是将它们分剒成单独的单词或类似单词的东西。默认情况下，我们这里有的标记器（记住这是一个包装在 spaCy 标记器周围的标记器，它是一个很棒的标记器）假设是英语。所以要求法语，你只需添加一个额外的参数’fr’。第一次这样做时，你会收到一个错误，说你没有安装 spaCy 法语模型，所以你可以运行python -m spacy download fr来获取法语模型。

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

在这里，你们中没有人会遇到 RAM 问题，因为这不是特别大的语料库，但是有些学生在这一周尝试训练新的语言模型时遇到了 RAM 问题。如果你遇到了，了解这些函数（proc_all_mp）实际在做什么是值得的。proc_all_mp正在跨多个进程处理每个句子：

上面的函数找出你有多少个 CPU，将其除以二（因为通常情况下，由于超线程，它们实际上并不都是并行工作的），然后并行运行这个proc_all函数。这将为你的每个 CPU 生成一个完全独立的 Python 进程。如果你有很多核心，那就是很多 Python 进程——每个人都将加载所有这些数据，这可能会使用完所有你的 RAM。所以你可以用proc_all替换它，而不是用proc_all_mp来使用更少的 RAM。或者你可以只使用更少的核心。目前，我们正在调用partition_by_cores，它在列表上调用partition，并要求根据你有多少个 CPU 将其分剒成一些等长的部分。所以你可以将其替换为将列表分割成更小的部分，并在更少的部分上运行它。

在对英语和法语进行标记化后，你可以看到它是如何分割的。

en_tok[0], fr_tok0

你可以看到法语的标记化看起来非常不同，因为法语喜欢他们的撇号和连字符。因此，如果您尝试为法语句子使用英语标记器，您将得到一个相当糟糕的结果。您不需要了解大量的自然语言处理（NLP）理念来使用深度学习进行自然语言处理，但只需要一些基本的东西，比如使用正确的标记器对于您的语言是重要的。本周我们研究小组中的一些学生一直在尝试为中文实例构建语言模型，当然中文并没有真正的标记化概念，所以我们开始研究sentence piece，它将事物分割成任意的子词单元，所以当 Jeremy 说标记化时，如果您使用的是没有空格的语言，您应该考虑使用 sentence piece 或其他类似的子词单元。希望在接下来的一两周内，我们将能够报告这些中文实验的一些早期结果。

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

所以在标记化之后，我们将其保存到磁盘。然后记住，在我们创建标记之后的下一步是将它们转换为数字。为此，我们有两个步骤——第一步是获取所有出现的单词的列表，然后我们将每个单词转换为索引。如果出现的单词超过 40,000 个，那么让我们在那里截断，以免变得太疯狂。我们插入一些额外的标记，用于流的开始（_bos_）、填充（_pad_）、流的结束（_eos_）和未知（_unk）。因此，如果我们尝试查找不在最常见的 40,000 个单词中的东西，那么我们使用deraultdict返回 3，即未知。

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

现在我们可以继续，通过将每个标记放入我们刚刚创建的字符串到整数字典（stoi）中，将每个标记转换为 ID，然后在最后添加数字 2，即流的结束。你在这里看到的代码是 Jeremy 在迭代和实验时编写的代码。因为他在迭代和实验时编写的代码中，99%都是完全错误的、愚蠢的或令人尴尬的，你看不到。但是在他编写代码时，没有必要重构它并使其变得美观，所以他希望你看到他所有的小技巧。与其为_eos_标记使用某个常量并使用它，当他在原型设计时，他只做简单的事情。并不是说他最终会得到错误的代码，但他试图在美丽的代码和可行的代码之间找到一些折中。

问题：刚听他提到我们将 CPU 数量除以 2，因为使用超线程时，我们不会通过使用所有超线程核心来加速。这是基于实际经验还是有一些潜在原因导致我们无法获得额外的加速？是的，这只是实际经验，并不是所有事情都像这样，但我确实注意到在标记化时，超线程似乎会使事情变慢一点。此外，如果我使用所有核心，通常我想同时做一些其他事情（比如运行一些交互式笔记本），我没有多余的空间来做那些事情。

现在对于我们的英语和法语，我们可以获取一个 ID 列表en_ids。当我们这样做时，当然，我们需要确保我们也存储了词汇。如果我们不知道数字 5 代表什么，那么拥有 ID 就没有意义，拥有数字 5 也没有意义。所以这就是我们的词汇en_itos和反向映射en_stoi，我们可以用它们来在将来转换更多的语料库。

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

为了确认它是否有效，我们可以通过每个 ID，将 int 转换为字符串，并将其输出 - 现在我们的句子已经回来了，末尾有一个流标记。我们的英语词汇量为 17,000，法语词汇量为 25,000，所以我们处理的词汇量既不太大也不太复杂。

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

在这一周的论坛上，我们花了很多时间讨论词向量是多么无聊，以及你应该停止对它们感到兴奋 - 现在我们要使用它们。为什么？我们一直在学习如何使用语言模型和预训练的正确模型，而不是预训练的线性单层，这就是词向量的内容，同样适用于序列到序列。但 Jeremy 和 Sebastian 正在开始研究这个问题。对于任何有兴趣创造一些真正新颖且高度可发表的结果的人来说，序列到序列与预训练语言模型的整个领域尚未被触及。Jeremy 相信这将和分类一样好。如果您在这方面有所作为，并且您已经有了一些看起来令人兴奋的东西，并且您希望得到帮助发表它，Jeremy 非常乐意帮助共同撰写论文。因此，当您有一些有趣的结果时，请随时联系。

在这个阶段，我们没有任何东西，所以我们将使用非常少的 fastai[34:14]。我们只有词向量 - 所以让我们至少使用体面的词向量。Word2vec 是非常古老的词向量。现在有更好的词向量，而 fast.text 是一个相当不错的词向量来源。有数百种语言可用，您的语言可能会被代表。

fasttext 词向量可从fasttext.cc/docs/en/english-vectors.html获取

fasttext Python 库在 PyPI 中不可用，但这里有一个方便的技巧[35:03]。如果有一个 GitHub 存储库，其中包含 setup.py 和 reqirements.txt，您只需在开头加上git+，然后将其放入pip install中，它就会起作用。几乎没有人似乎知道这一点，如果您去 fasttext 存储库，他们不会告诉您这一点 - 他们会告诉您必须下载它并cd进入它，等等，但您不必这样做。您只需运行以下命令：

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

要使用 fastText 库，您需要下载fasttext 词向量（下载“bin plus text”）。

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

以上是我们的英语和法语模型。有文本版本和二进制版本。二进制版本更快，所以我们将使用它。文本版本也有点 buggy。我们将把它转换为标准的 Python 字典，以使其更容易使用[35:55]。这只是通过字典理解遍历每个单词，并将其保存为 pickle 字典：

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

现在我们有了我们的 pickle 字典，我们可以继续查找一个单词，例如逗号[36:07]。这将返回一个向量。向量的长度是这组词向量的维度。在这种情况下，我们有 300 维的英语和法语词向量。

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

出于即将看到的原因，我们还想找出我们的向量的平均值和标准差。所以平均值约为零，标准差约为 0.3。

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

通常，语料库的序列长度具有相当长尾的分布，而最长的序列往往会压倒性地影响时间、内存使用等。因此，在这种情况下，我们将获取英语和法语的第 99 到 97 百分位数，并将它们截断到该数量。最初 Jeremy 使用的是 90 百分位数（因此变量名）：

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

我们快要完成了[37:24]。我们已经有了我们的标记化、数字化的英语和法语数据集。我们有一些词向量。现在我们需要为 PyTorch 准备好它。PyTorch 需要一个Dataset对象，希望到现在为止你可以说一个 Dataset 对象需要两个东西——一个长度(__len__)和一个索引器(__getitem__)。Jeremy 开始编写Seq2SeqDataset，结果只是一个通用的Dataset[37:52]。

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,ydef __getitem__(self, idx): return A(self.x[idx], self.y[idx])def __len__(self): return len(self.x)

• A：数组。它将遍历您传递的每个对象，如果它还不是一个 numpy 数组，它会将其转换为一个 numpy 数组，并返回一个元组，其中包含您传递的所有现在保证为 numpy 数组的对象[38:32]。

• V：变量

• T：张量

现在我们需要获取我们的英语和法语 ID，并获得一个训练集和一个验证集。互联网上许多代码令人失望的一点是它们没有遵循一些简单的最佳实践。例如，如果你去 PyTorch 网站，他们有一个关于序列到序列翻译的示例部分。他们的示例没有单独的验证集。Jeremy 尝试根据他们的设置进行训练，并使用验证集进行测试，结果发现它严重过拟合。因此，这不仅仅是一个理论问题——实际的 PyTorch 存储库有实际的官方序列到序列翻译示例，它没有检查过拟合，严重过拟合[39:41]。此外，它没有使用小批量，因此实际上没有充分利用 PyTorch 的任何效率。即使你在官方 PyTorch 存储库中找到代码，也不要认为它是好的。你会注意到的另一件事是，Jeremy 在互联网上找到的几乎每个 PyTorch 序列到序列模型都明显是从那个糟糕的 PyTorch 存储库中复制的，因为它们都有相同的变量名，有相同的问题，有相同的错误。

另一个例子是，Jeremy 找到的几乎每个 PyTorch 卷积神经网络都没有使用自适应池化层[40:27]。换句话说，最终层总是平均池化(7,7)。他们假设前一层是 7 乘 7，如果你使用任何其他大小的输入，你会得到一个异常，因此几乎每个使用 PyTorch 的人都认为 CNNs 有一个基本限制，即它们与输入大小相关联，这自从 VGG 以来就不再成立。因此，每当 Jeremy 拿到一个新模型并将其放入 fastai 存储库时，他都必须搜索“pool”并在开头添加“adaptive”，将 7 替换为 1，现在它适用于任何大小的对象。所以要小心。现在仍然是早期阶段，信不信由你，即使你们大多数人只在过去一年开始了深度学习之旅，你们对许多更重要的实际方面了解的要比大多数在官方存储库中发布和编写东西的人多得多。因此，当阅读其他人的代码时，你需要比你期望的更有一些自信。如果你发现自己在想“那看起来很奇怪”，那不一定是你。

如果你正在查看的存储库没有一个部分说这里是我们做的测试，我们得到了与应该实现的论文相同的结果，那几乎肯定意味着他们没有得到他们正在实现的论文相同的结果，甚至可能根本没有检查[42:13]。如果你运行它，肯定不会得到那些结果，因为第一次做对事情很难——Jeremy 需要尝试 12 次。如果他们没有测试过一次，几乎肯定不会起作用。

这是一个获取训练和验证集的简单方法[42:45]。获取一堆随机数 - 每行数据一个，然后看它们是否大于 0.1。这会给你一个布尔值列表。使用该布尔值列表索引到你的数组中以获取一个训练集，使用该布尔值列表的相反值索引到该数组中以获取你的验证集。

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

现在我们可以用我们的 X 和 Y（即法语和英语）创建我们的数据集[43:12]。如果你想将英语翻译成法语，只需交换这两个，就完成了。

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

现在我们需要创建 DataLoaders[43:22]。我们只需获取我们的数据加载器并传入我们的数据集和批量大小。我们实际上必须转置数组 - 我们不会详细讨论为什么，但如果你感兴趣，我们可以在这一周讨论，但想一想为什么我们可能需要转置它们的方向。由于我们已经完成了所有的预处理，没有必要启动多个工作人员来进行增强等工作，因为没有工作要做。因此，使 num_workers=1会节省一些时间。我们必须告诉它我们的填充索引是什么 - 这非常重要，因为将会发生的是，我们有不同长度的句子，fastai 将自动将它们粘在一起并填充较短的句子，使它们长度相等。记住张量必须是矩形的。

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)

特别是在解码器中，我们希望我们的填充在末尾，而不是在开头[44:29]：

• 分类器 → 在开头填充。因为我们希望最终的标记代表电影评论的最后一个单词。

• 解码器 → 在末尾填充。正如你将看到的，将填充放在末尾实际上会更好一些。

采样器 [44:54] 最后，由于我们输入的句子长度不同，它们都必须通过填充放在一个小批次中以使它们具有相同的大小，我们更希望小批次中的句子已经具有相似的大小。否则，它将与最长的句子一样长，这将浪费时间和内存。因此，我们将使用上次学到的采样器技巧，即对验证集，我们将要求它首先按长度排序。然后对于训练集，我们将随机排列事物的顺序，但大致使得长度相似的事物大致在同一位置。

模型数据 [45:40] 在这一点上，我们可以创建一个模型数据对象 - 记住，模型数据对象实际上只做一件事，那就是它说“我有一个训练集和一个验证集，还有一个可选的测试集”，然后把它们放入一个单一对象中。我们还有一个路径，这样它就有地方存储临时文件、模型等等。

在这个例子中，我们几乎没有使用 fastai。我们使用了与 PyTorch 兼容的数据集和数据加载器 - 在幕后实际上使用的是 fastai 版本，因为我们需要它来方便地进行自动填充，因此在 fastai 版本中有一些稍微快速和更方便的调整。我们还使用了 fastai 的采样器，但这里没有太多的事情发生。

损失函数是分类交叉熵损失。我们有一个概率列表，对应每个类别，其中类别是我们英语词汇中的所有单词，我们有一个目标，即正确的类别（即在此位置的正确单词）。有两个调整，这就是为什么我们需要编写自己的损失函数，但基本上可以看到它将是交叉熵损失。

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

调整[1:07:40]：

1. 如果生成的序列长度短于目标序列长度，我们需要添加一些填充。PyTorch 填充函数需要一个 6 元组来填充一个秩为 3 的张量（序列长度、批量大小、词汇表中的单词数）。每对表示在该维度之前和之后的填充。

F.cross_entropy 期望一个秩为 2 的张量，但我们有序列长度乘以批量大小，所以让我们展平它。这就是 view(-1, ...) 做的事情。

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

.cuda() 和 to_gpu() 之间的区别：如果没有 GPU，to_gpu 不会将其放入 GPU。您还可以将 fastai.core.USE_GPU 设置为 false，以强制它不使用 GPU，这对调试很方便。

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', ':']
'''

然后我们需要一些东西告诉它如何处理学习率组，所以有一个叫做 SingleModel 的东西，你可以传递给它，它将整个东西视为一个单一的学习率组。这是将 PyTorch 模块转换为 fastai 模型的最简单方法。

我们可以直接调用 Learner 将其转换为一个学习器，但如果我们调用 RNN_Learner，它会添加 save_encoder 和 load_encoder，有时会很方便。在这种情况下，我们确实可以说 Leaner，但 RNN_Learner 也可以。

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

下一个技巧是一个更大、更酷的技巧。它被称为“注意力”。注意力的基本思想是这样的——期望将整个句子总结为这个单一的隐藏向量是要求太多了。它必须知道说了什么，怎么说的，以及创建德语句子所需的一切。注意力的想法基本上是我们可能要求太多了。特别是因为我们可以使用这种形式的模型（下面），在这种模型中我们不仅输出循环的每一步，而不仅仅是在最后有一个隐藏状态，而是在每个单词之后都有一个隐藏状态。为什么不尝试利用这些信息呢？它已经存在，但到目前为止我们只是把它丢掉了。不仅如此，而且双向的，我们在每一步都有两个状态向量，我们可以利用。我们怎么做呢？

让我们假设我们现在正在翻译一个词“liebte”[1:32:34]。我们想要之前的 5 个隐藏状态中的哪一个？显然我们想要“love”，因为这是这个词。那么“zu”呢？我们可能需要“eat”、“to”和“loved”来确保我们已经得到了正确的时态，并知道我实际上需要动词的这部分等等。因此，根据我们正在翻译的部分，我们可能需要这些不同隐藏状态的一个或多个部分。实际上，我们可能需要对它们进行加权。换句话说，对于这五个隐藏状态，我们想要一个加权平均值[1:33:47]。我们希望它根据某种可以确定哪些句子部分现在最重要的东西进行加权。我们如何找出哪些句子部分现在很重要？我们创建一个神经网络，训练神经网络来找出。我们什么时候训练这个神经网络？端到端。所以现在让我们训练两个神经网络[1:34:18]。嗯，我们已经有了一堆——RNN 编码器，RNN 解码器，几个线性层，那就再加一个神经网络吧。这个神经网络将为每一个这些状态输出一个权重，我们将在每一步进行加权平均，这只是我们同时学习的另一组参数。这就是所谓的“注意力”。

这个想法是一旦学会了注意力，每个单词都会进行加权平均，你可以在 Chris Olah 和 Shan Carter 的这个精彩演示中看到[1:34:50]。查看这篇distill.pub 文章——这些都是交互式图表，向你展示了注意力是如何工作的，以及在训练翻译模型中实际的注意力是什么样子。

• 通过联合学习对齐和翻译进行神经机器翻译——这是一篇令人惊叹的论文，最初介绍了注意力的概念，以及一些真正改变了人们在这一领域工作方式的关键事项。他们说，注意力领域不仅用于文本，还用于从图片中读取文本或在计算机视觉中执行各种任务。

• 作为外语的语法——Geoffrey Hinton 参与的第二篇论文，使用了 RNN 与注意力的想法，试图用自动标记每个单词的 RNN 替换基于规则的语法。结果表明，它比任何基于规则的系统做得更好，这在今天看来是显而易见的，但在当时被认为是非常令人惊讶的。它们是关于注意力如何工作的摘要，非常清晰简洁。

问题：你能再解释一下注意力吗？[1:39:46] 当然！让我们回头看看我们最初的编码器。

RNN 输出两个东西：它在每个时间步骤之后输出一个状态列表（enc_out），并且还告诉您在最后一个时间步骤的状态（h），我们使用最后一个时间步骤的状态来创建我们的解码器的输入状态，这是下面的一个向量s：

但我们知道它在每个时间步骤都创建一个向量（橙色箭头），那么使用它们所有不是更好吗？但使用哪一个或哪些对于翻译我们正在翻译的单词最相关呢？所以能否按照当前适当的权重取每个时间步骤的隐藏状态的加权平均值会更好。例如，“liebte”肯定是时间步骤＃2，因为那是我正在翻译的单词。那么我们如何得到一个适合当前训练的单词的权重列表呢？答案是通过训练一个神经网络来找出权重列表。所以每当我们想要弄清楚如何训练一个小型神经网络来执行任何任务时，通常最简单的方法就是将其包含在你的模块中，并与其他所有内容一起训练。最简单的神经网络是包含两层和一个非线性激活函数的东西，所以self.l2是一个线性层。

实际上，我们甚至可以只是随机选择一个矩阵，如果我们不关心偏差[1:42:18]。self.W1是一个随机张量，包装在一个Parameter中。

Parameter：记住，Parameter与 PyTorch 的Variable是相同的，但它只是告诉 PyTorch“请学习这些权重”。[1:42:35]

因此，当我们开始我们的解码器时，让我们取解码器当前的隐藏状态，将其放入一个线性层（self.l2），因为我们用来决定接下来应该关注哪些单词的信息——我们唯一可以依赖的信息就是解码器当前的隐藏状态。所以让我们抓住它：

• 将其放入线性层（self.l2）

• 将其通过非线性激活函数（F.tanh）处理

• 通过一个非线性层（u @ self.V中没有偏差，所以只是矩阵相乘）

• 通过 softmax

就是这样——一个小型神经网络。它什么也不做。它只是一个神经网络，没有神经网络做任何事情，它们只是具有随机权重的线性层和非线性激活。但是如果我们给它一个任务，它就开始做一些事情。在这种情况下，我们给它的任务是不要只取最终状态，而是现在让我们使用所有编码器状态，并且让我们取出所有这些状态，并将它们乘以那个小型神经网络的输出。因此，考虑到这个小型神经网络中的东西是可学习的权重，希望它学会对这些编码器隐藏状态进行有用的加权。神经网络所做的一切就是我们给它一些随机权重作为起点和一个任务，并希望它学会完成这个任务。结果表明，它确实做到了。

这里的其他一切与以前完全相同。我们有教师强制，它不是双向的，所以我们可以看看情况如何。

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

教师强制为 3.49，现在几乎完全相同的东西，但我们有这个小型神经网络来找出给我们输入的权重，我们降到了 3.37。记住，这些损失是对数，所以e³.37是一个相当显著的变化。

learn.save('attn')

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

还不错。仍然不完美，但相当多的结果是正确的，考虑到我们要求它学习两种不同语言之间的语言概念，以及如何在两种语言之间进行翻译，以及语法和词汇，我们只有 50,000 个句子，很多词只出现一次，我会说这实际上是非常惊人的。

**问题：**为什么我们在注意力小网络中使用 tanh 而不是 ReLU？[1:46:23]我不太记得——我很久没有看过了。你完全可以尝试使用值并看看效果如何。显然，tanh 的关键区别在于它可以在每个方向上移动，并且在顶部和底部都受限。我知道在 RNNs、LSTMs 和 GRUs 内部的门中，tanh 通常效果更好，但是我已经大约一年没有看过这个具体问题了，所以我会在这周看一下。简短的答案是你应该尝试不同的激活函数，看看是否可以得到更好的结果。

来自第 7 课[44:06]：正如我们上周所看到的，tanh 强制值在-1 和 1 之间。由于我们一遍又一遍地乘以这个权重矩阵，我们担心 relu（因为它是无界的）可能会有更多的梯度爆炸问题。话虽如此，你可以指定 RNNCell 使用不同的非线性函数，其默认值为 tanh，并要求它使用 relu。

我们还可以通过将forward函数添加返回注意力参数来从模型中提取注意力。你可以在forward函数参数中放任何你想要的东西。所以我们添加了一个返回注意力参数，默认为 false，因为显然训练循环不知道这一点，但然后我们在这里添加了一些东西，如果返回注意力，那么也将注意力添加进去（if ret_attn: res = res,torch.stack(attns)）。注意力就是值a，只需将其放入列表中（attns.append(a)）。现在我们可以调用带有返回注意力等于 true 的模型，并获得概率和注意力[1:47:53]：

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

当你是 Chris Olah 和 Shan Carter 时，你做出的东西看起来像☟，当你是 Jeremy Howard 时，完全相同的信息看起来像☝︎。你可以看到在每个不同的时间步，我们有不同的注意力。

当你尝试构建这样的东西时，非常重要的一点是，你不知道它是否工作正常，因为如果它不工作（通常情况下，Jeremy 的前 12 次尝试都失败了），它们失败的意义在于它并没有真正学到任何有用的东西。因此，它对每件事都给予了同等的关注，它并没有变得更糟——只是并没有变得更好。直到你真正找到一种方法来以一种你事先知道它应该是什么样子的方式来可视化这个东西，你才真正知道它是否有效。因此，非常重要的一点是，你要尝试找到一种方法来检查你的中间步骤和输出。

问题：注意力神经网络的损失函数是什么？没有，注意力神经网络没有损失函数。它是端到端训练的。它只是坐在我们的解码器循环中。解码器循环的损失函数是相同的损失函数，因为结果包含的东西完全相同——单词的概率。为什么这个小型神经网络在学习？因为为了使输出变得更好，如果它使加权平均的权重变得更好，那将是很好的。因此，创建我们的输出的一部分是请尽量找到一组好的权重，如果它不能找到一组好的权重，那么损失函数就不会从那一部分改善。因此，端到端学习意味着你将一切都放入一个损失函数中，所有不同参数的梯度都指向一个方向，即“嘿，你知道如果你在那里放更多的权重，那会更好。”多亏了链式法则的魔力，它知道要在那里放更多的权重，稍微改变矩阵乘法中的参数等。这就是端到端学习的魔力。这是一个非常容易理解的问题，但你必须意识到这段代码中没有任何特定的东西表明这些特定的部分是单独的小型神经网络，就像 GRU 不是一个单独的小型神经网络，或者线性层不是一个单独的小型函数一样。所有这些最终都被推送到一个输出中，这个输出是一堆概率，最终进入一个返回单个数字的损失函数，这个数字表示这是一个好的翻译还是不是一个好的翻译。多亏了链式法则的魔力，我们然后向所有参数反向传播一点更新，使它们变得更好一点。这是一个很大、很奇怪、很反直觉的想法，如果它有点令人费解，那完全没关系。这是一个让我们回到第一课“我们是如何让它找到狗和猫的？”的地方——我们没有。我们所做的只是说“这是我们的数据，这是我们的架构，这是我们的损失函数。请反向传播到权重，使它们变得更好，当你让它们变得更好一段时间后，它将开始从狗中找到猫。”在这种情况下（即翻译），我们没有使用别人的卷积网络架构。我们说“这是一个我们希望在这个问题上特别擅长的自定义架构。”即使没有这个自定义架构，也还可以。但我们制作的方式更有意义，或者我们认为它应该做得更好。但在任何时候，我们都没有做任何不同的事情，只是说“这是数据，这是架构，这是损失函数——请找到参数”它做到了，因为这就是神经网络所做的事情。

所以这就是序列到序列学习。

• 如果你想将图像编码到某种 CNN 骨干中，然后将其传递到一个类似带有注意力的 RNN 的解码器中，然后将你的 y 值设为每个图像的实际正确字幕，你最终会得到一个图像字幕生成器。

• 如果你用视频和字幕做同样的事情，你最终会得到一个视频字幕生成器。

• 如果你用 3D CT 扫描和放射学报告做同样的事情，你最终会得到一个放射学报告生成器。

• 如果你用 Github 问题和人们选择的摘要做同样的事情，你会得到一个 Github 问题摘要生成器。

Seq-to-seq 是神奇的，但它们起作用。我觉得人们还没有开始深入研究如何在自己的领域中使用 seq-to-seq 模型。作为一个不太用 Github 的人，我从来没有想到“从某个问题开始并自动生成摘要会很酷”。但现在，当然，下次我进入 Github 时，我想看到一个为我写的摘要。我不想写自己的提交消息。当我完成对很多行添加注释后，为什么我要自己写代码审查的摘要呢 — 它也应该为我做这件事。现在我在想 Github 太落后了，它本来可以做这些事情。那么在你的行业中有什么事情呢？你可以从一个序列开始并生成一些东西。我无法想象。再次强调，这是一个相当新的领域，用于它的工具并不容易使用 — 它们甚至还没有内置到 fastai 中。希望很快会有。我认为没有人知道机会在哪里。

笔记本 / 论文

我们将要做一些事情，第一次将我们专注的两个小世界——文本和图像[1:55:49]结合起来。这个想法是由一位名叫 Andrea Frome 的杰出深度学习从业者和研究人员提出的。当时 Andrea 在谷歌工作，她疯狂的想法是单词可以有一个分布式表示，一个空间，特别是在那个时候只是单词向量。图像也可以在一个空间中表示。最后，如果我们有一个全连接层，它们最终会成为一个向量表示。我们能够合并这两者吗？我们能否以某种方式鼓励图像最终得到的向量空间与单词所在的向量空间相同？如果我们能做到这一点，那意味着什么？我们可以用它做什么？那么我们可以用它做什么，涵盖了诸如“如果我错了怎么办，如果我预测这张图片是一只猎犬，而我预测是大型喷气机，Yannet 的模型预测是柯基。正常的损失函数表示 Yannet 和 Jeremy 的模型一样好（即它们都是错误的）。但如果我们能以某种方式说，你知道柯基更接近猎犬而不是大型喷气机。所以 Yannet 的模型比 Jeremy 的更好。我们应该能够做到这一点，因为在单词向量空间中，猎犬和柯基是非常接近的，但大型喷气机不是那么接近。所以这将给我们一个很好的情况，希望我们的推理如果错误的话会以更合理的方式出错。这也将使我们能够搜索不在 ImageNet Synset ID（即 ImageNet 中的一个类别）中的事物。为什么我们必须训练一个全新的模型来找到狗和猫，当我们已经有找到柯基和虎斑猫的东西。为什么我们不能只是说找到狗？如果我们在单词向量空间中训练过它，我们完全可以，因为它们是单词向量，我们可以找到具有正确图像向量的东西等等。我们将在一会儿看一些我们可以用它做的很酷的事情，但首先让我们训练一个模型，这个模型不是学习一个类别（独热编码 ID），其中每个类别与其他每个类别的距离都是相等的，而是训练一个模型，我们正在寻找一个依赖变量，这是一个单词向量。那么什么单词向量？显然是你想要的单词的单词向量。所以如果是柯基，让我们训练它创建一个柯基单词向量，如果是大型喷气机，让我们训练它与一个依赖变量说这是大型喷气机的单词向量。

from fastai.conv_learner import *
torch.backends.cudnn.benchmark=Trueimport fastText as ft
PATH = Path('data/imagenet/')
TMP_PATH = PATH/'tmp'
TRANS_PATH = Path('data/translate/')
PATH_TRN = PATH/'train'

这实在太容易了。让我们再次获取 fast text 单词向量，加载它们进来（这次我们只需要英语）。

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

例如，“jeremy”和“Jeremy”的相关系数为 0.6。

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

Jeremy 一点也不喜欢香蕉，“香蕉”和“Jeremy”相关系数为 0.14。所以你期望相关的词是相关的，而应该尽可能远离彼此的词，不幸的是，它们仍然略微相关，但不那么明显。

现在让我们做一些有点不同的事情 —— 就是取出我们所有的预测（pred_wv），基本上取出我们整个验证图像集的预测，并创建一个图像表示的 KNN 索引，因为记住，它正在预测那些应该是词向量的东西。现在让我们获取“船”的快速文本向量，船不是 ImageNet 的概念 —— 然而我们现在可以找到所有在我们预测的词向量（即我们的验证集）中最接近“船”这个词的图像，即使它并没有被训练过。

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

如果我们现在取引擎的向量和船的向量并取它们的平均值，如果我们现在在最近的邻居中寻找那个[2:14:04]呢？

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

这些是带引擎的船。我的意思是，是的，中间那个实际上是一艘带引擎的船 —— 它碰巧也有翅膀。顺便说一句，帆不是 ImageNet 的东西，船也不是。这是两个不是 ImageNet 的东西的平均值，然而除了一个例外，它给我们找到了两艘帆船。

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

好的，让我们做一些疯狂的事情。让我们在验证集中打开一张图像。让我们对该图像调用predict_array以获取其类似词向量的东西，并让我们在所有其他图像上进行最近邻搜索。

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

这里是所有其他任何东西的图像。所以你可以看到，这很疯狂 —— 我们在一个小时内对所有 ImageNet 进行了训练，使用了一个基本上只需要两行代码的自定义头部，这些搜索运行在 300 毫秒内。

Jeremy 去年也教过这个基本概念，但是当时是在 Keras 中，代码很长，一切都很复杂。当时 Jeremy 说他无法想象你可以用这个做什么。他认为没有人真正深入思考过这个问题，但他觉得这很迷人。所以回去读 DeVICE 论文，因为 Andrea 有很多其他想法，现在做起来很容易，希望人们现在会深入研究这个问题。Jeremy 觉得这太疯狂和令人惊讶了。

好的，下周见！