深度学习 2：第 1 部分第 4 课

原文：medium.com/@hiromi_suenaga/deep-learning-2-part-1-lesson-4-2048a26d58aa

译者：飞龙

协议：CC BY-NC-SA 4.0

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

第 4 课

Dropout [04:59]

learn = ConvLearner.pretrained(arch, data, ps=0.5, precompute=True)

• precompute=True：预先计算出最后一个卷积层的激活。请记住，激活是根据一些权重/参数计算出来的数字，这些权重/参数构成了卷积核/滤波器，并且它们被应用于前一层的激活或输入。

learn 
'''
Sequential((0): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True)(1): Dropout(p=0.5)(2): Linear(in_features=1024, out_features=512)(3): ReLU()(4): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True)(5): Dropout(p=0.5)(6): Linear(in_features=512, out_features=120)(7): LogSoftmax()
)
'''

learn — 这将显示我们在末尾添加的层。这些是我们在precompute=True时训练的层

(0), (4): BatchNorm将在最后一课中讨论

(1), (5): Dropout

(2):Linear层简单地意味着矩阵相乘。这是一个具有 1024 行和 512 列的矩阵，因此它将接收 1024 个激活并输出 512 个激活。

(3):ReLU — 只是用零替换负数

(6): Linear — 第二个线性层，将前一个线性层的 512 个激活通过一个新的矩阵相乘 512 乘以 120，并输出 120 个激活

(7): Softmax — 返回总和为 1 的数字的激活函数，每个数字都在 0 到 1 之间：

出于微小的数值精度原因，事实证明取 softmax 的对数比直接取 softmax 要好[15:03]。这就是为什么当我们从模型中获取预测时，我们必须执行np.exp(log_preds)。

什么是Dropout和什么是p？[08:17]

Dropout(p=0.5)

learn = ConvLearner.pretrained(arch, data, ps=0.5, precompute=True)

[2\.      0.3521   0.55247  0.84189]

Sequential((0): BatchNorm1d(4096, eps=1e-05, momentum=0.1, affine=True)(1): Linear(in_features=4096, out_features=512)(2): ReLU()(3): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True)(4): Linear(in_features=512, out_features=120)(5): LogSoftmax()
)

learn = ConvLearner.pretrained(arch, data, ps=0., precompute=True, xtra_fc=[]
); learn 
'''
Sequential((0): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True)(1): Linear(in_features=1024, out_features=120)(2): LogSoftmax()
)
'''
learn = ConvLearner.pretrained(arch, data, ps=0., precompute=True, xtra_fc=[700, 300]
); learn
'''
Sequential((0): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True)(1): Linear(in_features=1024, out_features=**700**)(2): ReLU()(3): BatchNorm1d(700, eps=1e-05, momentum=0.1, affine=True)(4): Linear(in_features=700, out_features=**300**)(5): ReLU()(6): BatchNorm1d(300, eps=1e-05, momentum=0.1, affine=True)(7): Linear(in_features=300, out_features=120)(8): LogSoftmax()
)
'''

learn = ConvLearner.pretrained(arch, data, ps=[0., 0.2],precompute=True, xtra_fc=[512]
); learn
'''
Sequential((0): BatchNorm1d(4096, eps=1e-05, momentum=0.1, affine=True)(1): Linear(in_features=4096, out_features=512)(2): ReLU()(3): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True)(4): Dropout(p=0.2)(5): Linear(in_features=512, out_features=120)(6): LogSoftmax()
)
'''

结构化和时间序列数据

笔记本 / Kaggle

有两种类型的列：

• 分类——它有一定数量的“级别”，例如 StoreType、Assortment

• 连续型——它有一个数字，该数字的差异或比率具有某种含义，例如 CompetitionDistance

cat_vars = ['Store', 'DayOfWeek', 'Year', 'Month', 'Day','StateHoliday', 'CompetitionMonthsOpen', 'Promo2Weeks','StoreType', 'Assortment', 'PromoInterval', 'CompetitionOpenSinceYear', 'Promo2SinceYear', 'State','Week', 'Events', 'Promo_fw', 'Promo_bw', 'StateHoliday_fw', 'StateHoliday_bw', 'SchoolHoliday_fw', 'SchoolHoliday_bw']
contin_vars = ['CompetitionDistance', 'Max_TemperatureC', 'Mean_TemperatureC', 'Min_TemperatureC', 'Max_Humidity', 'Mean_Humidity', 'Min_Humidity', 'Max_Wind_SpeedKm_h', 'Mean_Wind_SpeedKm_h', 'CloudCover', 'trend', 'trend_DE', 'AfterStateHoliday', 'BeforeStateHoliday', 'Promo', 'SchoolHoliday']
n = len(joined); n

• 像Year，Month这样的数字，尽管我们可以将它们视为连续的，但我们不必这样做。如果我们决定将Year作为分类变量，我们告诉我们的神经网络，对于每个不同的Year“级别”（2000、2001、2002），你可以完全不同地对待它；而如果我们说它是连续的，它必须提出某种平滑函数来拟合它们。因此，通常实际上是连续的但没有许多不同级别的事物（例如Year，DayOfWeek），通常最好将它们视为分类变量。

• 选择分类变量还是连续变量是您要做的建模决策。总之，如果数据中是分类的，那么它必须是分类的。如果数据中是连续的，您可以选择在模型中将其视为连续或分类。

• 通常，浮点数很难转换为分类变量，因为有许多级别（我们称级别数为“基数”——例如，星期几变量的基数为 7）。

问题：您是否对连续变量进行分箱？Jeremy 不对变量进行分箱，但我们可以对最高温度等进行分组，例如 0-10，10-20，20-30，并将其视为分类变量。有趣的是，上周刚刚发表了一篇论文，其中一组研究人员发现有时分箱可能有所帮助。

问题：如果将年份用作类别，当模型遇到以前从未见过的年份时会发生什么？我们会解决这个问题，但简短的答案是它将被视为未知类别。Pandas 有一个特殊的未知类别，如果它看到以前未见过的类别，它将被视为未知。

for v in cat_vars: joined[v] = joined[v].astype('category').cat.as_ordered()
for v in contin_vars:joined[v] = joined[v].astype('float32')
dep = 'Sales'
joined = joined[cat_vars+contin_vars+[dep, 'Date']].copy()

• 循环遍历cat_vars并将适用的数据框列转换为分类列。

• 循环遍历contin_vars并将它们设置为float32（32 位浮点数），因为这是 PyTorch 所期望的。

从一个小样本开始

idxs = get_cv_idxs(n, val_pct=150000/n) 
joined_samp = joined.iloc[idxs].set_index("Date") 
samp_size = len(joined_samp); samp_size

这是我们的数据样子。尽管我们将一些列设置为“category”（例如‘StoreType’，‘Year’），但 Pandas 在笔记本中仍然显示为字符串。

df, y, nas, mapper = proc_df(joined_samp, 'Sales', do_scale=True)
yl = np.log(y)

proc_df（处理数据框）——Fast.ai 中的一个函数，执行以下几项操作：

1. 将因变量提取出来，放入一个单独的变量中，并从原始数据框中删除它。换句话说，df没有Sales列，而y只包含Sales列。

2. do_scale：神经网络非常喜欢输入数据的均值大约为零，标准差大约为 1。因此，我们取出数据，减去均值，除以标准差以实现这一点。它返回一个特殊对象，用于跟踪用于归一化的均值和标准差，以便稍后对测试集执行相同操作（mapper）。

3. 它还处理缺失值——对于分类变量，它变为 ID：0，其他类别变为 1、2、3 等。对于连续变量，它用中位数替换缺失值，并创建一个新的布尔列，指示是否缺失。

处理后，例如 2014 年变成 2，因为分类变量已被替换为从零开始的连续整数。原因是，我们稍后要将它们放入矩阵中，我们不希望矩阵在可以只有两行时却有 2014 行。

现在我们有一个不包含因变量且所有内容都是数字的数据框。这就是我们需要进行深度学习的地方。查看机器学习课程以获取更多详细信息。机器学习课程中涵盖的另一件事是验证集。在这种情况下，我们需要预测接下来两周的销售额，因此我们应该创建一个验证集，即我们训练集的最后两周：

val_idx = np.flatnonzero((df.index<=datetime.datetime(2014,9,17)) &(df.index>=datetime.datetime(2014,8,1)))

• 如何（以及为什么）创建一个好的验证集

让我们直接进入深度学习行动[39:48]

def inv_y(a): return np.exp(a)
def exp_rmspe(y_pred, targ):targ = inv_y(targ)pct_var = (targ - inv_y(y_pred))/targreturn math.sqrt((pct_var**2).mean())
max_log_y = np.max(yl)
y_range = (0, max_log_y*1.2)

md = ColumnarModelData.from_data_frame(PATH, val_idx, df, yl.astype(np.float32), cat_flds=cat_vars, bs=128, test_df=df_test
)

m = md.get_learner(emb_szs, len(df.columns)-len(cat_vars),0.04, 1, [1000,500], [0.001,0.01], y_range=y_range
)

关键新概念：嵌入[45:39]

全连接神经网络的简单视图[49:13]：

分类变量[50:49]

cat_sz = [(c, len(joined_samp[c].cat.categories)+1) for c in cat_vars
]
cat_sz
'''
[('Store', 1116),('DayOfWeek', 8),('Year', 4),('Month', 13),('Day', 32),('StateHoliday', 3),('CompetitionMonthsOpen', 26),('Promo2Weeks', 27),('StoreType', 5),('Assortment', 4),('PromoInterval', 4),('CompetitionOpenSinceYear', 24),('Promo2SinceYear', 9),('State', 13),('Week', 53),('Events', 22),('Promo_fw', 7),('Promo_bw', 7),('StateHoliday_fw', 4),('StateHoliday_bw', 4),('SchoolHoliday_fw', 9),('SchoolHoliday_bw', 9)]
'''

emb_szs = [(c, min(50, (c+1)//2)) for _,c in cat_sz]
emb_szs
'''
[(1116, 50),(8, 4),(4, 2),(13, 7),(32, 16),(3, 2),(26, 13),(27, 14),(5, 3),(4, 2),(4, 2),(24, 12),(9, 5),(13, 7),(53, 27),(22, 11),(7, 4),(7, 4),(4, 2),(4, 2),(9, 5),(9, 5)]
'''

m = md.get_learner(emb_szs, len(df.columns)-len(cat_vars), 0.04, 1,[1000,500], [0.001,0.01], y_range=y_range
)

幕后的矩阵代数[01:04:47]

add_datepart(weather, "Date", drop=False)
add_datepart(googletrend, "Date", drop=False)
add_datepart(train, "Date", drop=False)
add_datepart(test, "Date", drop=False)

学习者[01:10:13]

m = md.get_learner(emb_szs, len(df.columns)-len(cat_vars), 0.04, 1,[1000,500], [0.001,0.01], y_range=y_range
)
lr = 1e-3

m.fit(lr, 3, metrics=[exp_rmspe])
'''
A Jupyter Widget
[ 0\.       0.02479  0.02205* *0.19309**]                          
[ 1\.       0.02044  0.01751* *0.18301**]                          
[ 2\.       0.01598  0.01571* *0.17248**]*

m.fit(lr, 1, metrics=[exp_rmspe], cycle_len=1)
'''
[ 0\.       0.00676  0.01041  0.09711]* 

learn = ConvLearner.pretrained(arch, data, ps=0., precompute=True)

m = md.get_learner(emb_szs, len(df.columns)-len(cat_vars), 0.04, 1,[1000,500], [0.001,0.01], y_range=y_range
)

md = ColumnarModelData.from_data_frame(PATH, val_idx, df, yl.astype(np.float32), cat_flds=cat_vars, bs=128, test_df=df_test
)

m = md.get_learner(emb_szs, len(df.columns)-len(cat_vars), 0.04, 1,[1000,500], [0.001,0.01], y_range=y_range
)

自然语言处理

深度学习中最具潜力的领域是自然语言处理，它比计算机视觉落后了两三年。软件状态和一些概念的成熟程度远不及计算机视觉。在自然语言处理中，你会发现有一些特定的问题可以解决，它们有特定的名称。在自然语言处理中有一种特定的问题叫做“语言建模”，它有一个非常具体的定义——构建一个模型，在给定一个句子的几个单词后，你能否预测下一个单词是什么。

语言建模

笔记本

这里我们有来自 arXiv（arXiv.org）的 18 个月的论文，这是一个例子：

' '.join(md.trn_ds[0].text[:150])
'''
'<cat> csni <summ> the exploitation of mm - wave bands is one of the key - enabler for 5 g mobile \n radio networks . however , the introduction of mm - wave technologies in cellular \n networks is not straightforward due to harsh propagation conditions that limit \n the mm - wave access availability . mm - wave technologies require high - gain antenna \n systems to compensate for high path loss and limited power . as a consequence , \n directional transmissions must be used for cell discovery and synchronization \n processes : this can lead to a non - negligible access delay caused by the \n exploration of the cell area with multiple transmissions along different \n directions . \n    the integration of mm - wave technologies and conventional wireless access \n networks with the objective of speeding up the cell search process requires new \n'
'''

• <cat> — 论文的类别。CSNI 是计算机科学和网络

• <summ> — 论文的摘要

这是训练语言模型的输出看起来像什么。我们进行了一些简单的测试，输入一些初始文本，看模型认为接下来应该是什么：

sample_model(m, "<CAT> csni <SUMM> algorithms that")
'''
...use the same network as a single node are not able to achieve the same performance as the traditional network - based routing algorithms . in this paper , we propose a novel routing scheme for routing protocols in wireless networks . the proposed scheme is based ...
'''

它通过阅读 arXiv 论文学到，写关于计算机网络的人会这样说话。记住，它最初完全不懂英语。它最初为英语中的每个单词都有一个随机的嵌入矩阵。通过阅读大量的 arXiv 论文，它学会了哪些单词跟随其他单词。

这里我们尝试指定一个类别为计算机视觉：

sample_model(m, "<CAT> cscv <SUMM> algorithms that")
'''
...use the same data to perform image classification are increasingly being used to improve the performance of image classification algorithms . in this paper , we propose a novel method for image classification using a deep convolutional neural network ( cnn ) . the proposed method is ...
'''

它不仅学会了写英语，而且在你说完“卷积神经网络”之后，你应该使用括号来指定一个缩写“(CNN)”。

sample_model(m,"<CAT> cscv <SUMM> algorithms. <TITLE> on ")
'''
...the performance of deep learning for image classification <eos>*sample_model(m,"<CAT> csni <SUMM> algorithms. <TITLE> on ")*...the performance of wireless networks <eos>*sample_model(m,"<CAT> cscv <SUMM> algorithms. <TITLE> towards ")*...a new approach to image classification <eos>*sample_model(m,"<CAT> csni <SUMM> algorithms. <TITLE> towards ")*...a new approach to the analysis of wireless networks <eos>
'''

语言模型可以非常深奥，因此我们将尝试构建它——不是因为我们真的在乎这个，而是因为我们试图创建一个用于执行其他任务的预训练模型。例如，给定一个 IMDB 电影评论，我们将确定它们是积极的还是消极的。这很像猫和狗——一个分类问题。因此，我们真的希望使用一个至少知道如何阅读英语的预训练网络。因此，我们将训练一个模型来预测句子的下一个单词（即语言模型），就像在计算机视觉中一样，在最后添加一些新层，并要求它预测某物是积极的还是消极的。

IMDB

笔记本

我们要做的是训练一个语言模型，使其成为分类模型的预训练模型。换句话说，我们试图利用我们在计算机视觉中学到的微调技巧来创建强大的分类模型。

问题：为什么直接做你想做的事情不起作用？事实证明它并不起作用。有几个原因。首先，我们知道微调预训练网络非常强大。因此，如果我们可以让它先学习一些相关任务，然后我们可以利用所有这些信息来尝试帮助它完成第二个任务。另一个原因是 IMDB 电影评论长达数千字。因此，在阅读数千字后，不了解英语结构或单词或标点符号的情况下，你只会得到一个 1 或 0（积极或消极）。试图学习整个英语结构，然后从一个数字中了解它如何表达积极和消极情绪，这是期望太高了。

问题：这与 Karpathy 的 Char-RNN 相似吗？这与 Char-RNN 有些相似，它可以根据前几个字母预测下一个字母。语言模型通常在单词级别上工作（但不一定），我们将在本课程中专注于单词级别的建模。

问题：这些生成的单词/句子在多大程度上是实际复制了在训练集中找到的内容？单词肯定是之前见过的单词，因为它不是字符级别的，所以它只能给我们之前见过的单词。句子，有严格的方法来做，但最简单的方法是看上面的例子，你会对此有所了解。最重要的是，当我们训练语言模型时，我们将有一个验证集，以便我们尝试预测以前从未见过的东西的下一个单词。有一些技巧可以使用语言模型来生成文本，比如 beam search。

文本分类的用例：

• 对于对冲基金，识别过去导致市场大幅下跌的文章或 Twitter 中的内容。

• 识别客户服务查询，这些查询往往与下个月取消合同的人相关联

• 将文档组织成是否属于法律发现的一部分。

from fastai.learner import *
import torchtext
from torchtext import vocab, data
from torchtext.datasets import language_modeling
from fastai.rnn_reg import *
from fastai.rnn_train import *
from fastai.nlp import *
from fastai.lm_rnn import *
import dill as pickle

• torchtext — PyTorch 的 NLP 库

数据

IMDB 大型电影评论数据集

PATH = 'data/aclImdb/'
TRN_PATH = 'train/all/'
VAL_PATH = 'test/all/'
TRN = f'{PATH}{TRN_PATH}'
VAL = f'{PATH}{VAL_PATH}'
%ls {PATH}
'''
imdbEr.txt  imdb.vocab  models/  README  test/  tmp/  train/
'''

在这种情况下，我们没有单独的测试和验证。就像在视觉中一样，训练目录中有一堆文件：

trn_files = !ls {TRN}
trn_files[:10]'''
['0_0.txt','0_3.txt','0_9.txt','10000_0.txt','10000_4.txt','10000_8.txt','1000_0.txt','10001_0.txt','10001_10.txt','10001_4.txt']
'''
review = !cat {TRN}{trn_files[6]}
review[0]
'''
"I have to say when a name like Zombiegeddon and an atom bomb on the front cover I was expecting a flat out chop-socky fung-ku, but what I got instead was a comedy. So, it wasn't quite was I was expecting, but I really liked it anyway! The best scene ever was the main cop dude pulling those kids over and pulling a Bad Lieutenant on them!! I was laughing my ass off. I mean, the cops were just so bad! And when I say bad, I mean The Shield Vic Macky bad. But unlike that show I was laughing when they shot people and smoked dope.<br /><br />Felissa Rose...man, oh man. What can you say about that hottie. She was great and put those other actresses to shame. She should work more often!!!!! I also really liked the fight scene outside of the building. That was done really well. Lots of fighting and people getting their heads banged up. FUN! Last, but not least Joe Estevez and William Smith were great as the...well, I wasn't sure what they were, but they seemed to be having fun and throwing out lines. I mean, some of it didn't make sense with the rest of the flick, but who cares when you're laughing so hard! All in all the film wasn't the greatest thing since sliced bread, but I wasn't expecting that. It was a Troma flick so I figured it would totally suck. It's nice when something surprises you but not totally sucking.<br /><br />Rent it if you want to get stoned on a Friday night and laugh with your buddies. Don't rent it if you are an uptight weenie or want a zombie movie with lots of flesh eating.<br /><br />P.S. Uwe Boil was a nice touch."
'''

现在我们将检查数据集中有多少单词：

!find {TRN} -name '*.txt' | xargs cat | wc -w
'''
17486581
'''
!find {VAL} -name '*.txt' | xargs cat | wc -w
'''
5686719
'''

在我们可以对文本进行任何操作之前，我们必须将其转换为标记列表。标记基本上就像一个单词。最终我们将把它们转换成一系列数字，但第一步是将其转换成一系列单词——这在 NLP 中称为“标记化”。一个好的标记器将很好地识别句子中的片段。每个分隔的标点符号将被分开，每个多部分单词的部分将被适当地分开。Spacy 做了很多 NLP 工作，Jeremy 知道它有最好的标记器。因此，Fast.ai 库被设计为与 Spacey 标记器以及 torchtext 一起很好地工作。

创建一个字段

字段是如何预处理一些文本的定义。

TEXT = data.Field(lower=True, tokenize=spacy_tok)

• lower=True — 将文本转换为小写

• tokenize=spacy_tok — 使用spacy_tok进行标记化

现在我们创建通常的 Fast.ai 模型数据对象：

bs=64; bptt=70
FILES = dict(train=TRN_PATH, validation=VAL_PATH, test=VAL_PATH)
md = LanguageModelData.from_text_files(PATH, TEXT, **FILES, bs=bs, bptt=bptt, min_freq=10
)

• PATH：通常是数据所在的位置，保存模型等

• TEXT：torchtext 的 Field 定义

• **FILES：我们拥有的所有文件的列表：训练、验证和测试（为了保持简单，我们没有单独的验证和测试集，所以两者都指向验证文件夹）

• bs：批量大小

• bptt：通过时间反向传播。这意味着我们一次将多长的句子放在 GPU 上

• min_freq=10：一会儿，我们将用整数（每个单词的唯一索引）替换单词。如果有任何出现次数少于 10 次的单词，就称之为未知。

构建了我们的ModelData对象之后，它会自动填充TEXT对象的一个非常重要的属性：TEXT.vocab。这是一个词汇表，它存储了文本中看到的哪些唯一单词（或标记），以及每个单词将被映射到一个唯一的整数 ID。

# 'itos': 'int-to-string' 
TEXT.vocab.itos[:12]
'''
['<unk>', '<pad>', 'the', ',', '.', 'and', 'a', 'of', 'to', 'is', 'it', 'in']
'''
# 'stoi': 'string to int'
TEXT.vocab.stoi['the']
'''
2
'''

itos按频率排序，除了前两个特殊的。使用vocab，torchtext 将为我们将单词转换为整数 ID：

md.trn_ds[0].text[:12]
'''
['i','have','always','loved','this','story','-','the','hopeful','theme',',','the']
'''
TEXT.numericalize([md.trn_ds[0].text[:12]])
'''
Variable containing:12352274801376172731976932
[torch.cuda.LongTensor of size 12x1 (GPU 0)]
'''

问题：通常会进行任何词干处理或词形还原吗？不是很常见。一般来说，我们只需要进行分词。为了尽可能通用，我们想知道接下来会发生什么，所以无论是将来时还是过去时，还是复数还是单数，我们并不真的知道哪些事情会有趣，哪些不会，所以似乎最好尽可能保持不变。

问题：处理自然语言时，上下文不重要吗？为什么我们要对单个词进行标记化和查看？[01:46:38] 不，我们不是在查看单个词 - 它们仍然是有序的。只是因为我们用数字 12 替换了 I，它们仍然是按照那个顺序的。处理自然语言的另一种方法叫做“词袋”，它们会丢弃顺序和上下文。在机器学习课程中，我们将学习如何使用词袋表示，但我认为它们已经不再有用或即将不再有用。我们开始学习如何正确使用深度学习来使用上下文。

批次大小和 BPTT [01:47:40]

next(iter(md.trn_dl))
'''
(Variable containing:12    567      3  ...    2118      4   239935      7     33  ...       6    148     55227    103    533  ...    4892     31     10...            ⋱           ...         19   8879     33  ...      41     24    733552   8250     57  ...     219     57   17775     19      2  ...    3099      8     48[torch.cuda.LongTensor of size 75x64 (GPU 0)], Variable containing:35733⋮   22388521587[torch.cuda.LongTensor of size 4800 (GPU 0)])
'''

创建一个模型 [01:55:46]

len(md.trn_dl), md.nt, len(md.trn_ds), len(md.trn_ds[0].text)
'''
(4602, 34945, 1, 20621966)
'''

em_sz = 200  # size of each embedding vector
nh = 500     # number of hidden activations per layer
nl = 3       # number of layers

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

learner = md.get_model(opt_fn, em_sz, nh, nl, dropouti=0.05,dropout=0.05, wdrop=0.1, dropoute=0.02, dropouth=0.05
)
learner.reg_fn = partial(seq2seq_reg, alpha=2, beta=1)
learner.clip=0.3

拟合

learner.fit(3e-3, 4, wds=1e-6, cycle_len=1, cycle_mult=2)
learner.save_encoder('adam1_enc')
learner.fit(3e-3, 4, wds=1e-6, cycle_len=10, cycle_save_name='adam3_10'
)
learner.save_encoder('adam3_10_enc')
learner.fit(3e-3, 1, wds=1e-6, cycle_len=20, cycle_save_name='adam3_20'
)
learner.load_cycle('adam3_20',0)

在情感分析部分，我们只需要语言模型的一半 - 编码器，所以我们保存了那部分。

learner.save_encoder('adam3_20_enc')
learner.load_encoder('adam3_20_enc')

语言建模的准确性通常使用指标困惑度来衡量，这只是我们使用的损失函数的exp()。

math.exp(4.165)
'''
64.3926824434624
'''
pickle.dump(TEXT, open(f'{PATH}models/TEXT.pkl','wb'))

测试

我们可以稍微玩弄一下我们的语言模型，以确保它运行正常。首先，让我们创建一小段文本来“引导”一组预测。我们将使用我们的 torchtext 字段对其进行数值化，以便将其馈送给我们的语言模型。

m=learner.model
ss=""". So, it wasn't quite was I was expecting, but I really liked it anyway! The best"""
s = [spacy_tok(ss)]
t=TEXT.numericalize(s)
' '.join(s[0])
'''
". So , it was n't quite was I was expecting , but I really liked it anyway ! The best"
'''

我们还没有添加使测试语言模型变得容易的方法，因此我们需要手动执行这些步骤。

# Set batch size to 1
m[0].bs=1
# Turn off dropout
m.eval()
# Reset hidden state
m.reset()
# Get predictions from model
res,*_ = m(t)
# Put the batch size back to what it was
m[0].bs=bs

让我们看看在我们短文本之后的下一个单词的前 10 个预测是什么：

nexts = torch.topk(res[-1], 10)[1]
[TEXT.vocab.itos[o] for o in to_np(nexts)]
'''
['film','movie','of','thing','part','<unk>','performance','scene',',','actor']
'''

…让我们看看我们的模型是否可以自己生成更多文本！

print(ss,"\n")
for i in range(50):n=res[-1].topk(2)[1]n = n[1] if n.data[0]==0 else n[0]print(TEXT.vocab.itos[n.data[0]], end=' ')res,*_ = m(n[0].unsqueeze(0))
print('...')
'''
. So, it wasn't quite was I was expecting, but I really liked it anyway! The best* *film ever ! <eos> i saw this movie at the toronto international film festival . i was very impressed . i was very impressed with the acting . i was very impressed with the acting . i was surprised to see that the actors were not in the movie . ...
'''

情感

所以我们之前已经预训练了一个语言模型，现在我们想要微调它以进行情感分类。

要使用预训练模型，我们将需要语言模型的保存的词汇表，因为我们需要确保相同的单词映射到相同的 ID。

TEXT = pickle.load(open(f'{PATH}models/TEXT.pkl','rb'))

sequential=False告诉 torchtext 文本字段应该被标记化（在这种情况下，我们只想存储“正面”或“负面”单个标签）。

IMDB_LABEL = data.Field(sequential=False)

这一次，我们需要将每个评论视为单独的而不是作为一个大段的文本，因为每个评论都有不同的情感附着。

splits是 torchtext 的一个方法，用于创建训练、测试和验证集。IMDB 数据集内置在 torchtext 中，因此我们可以利用它。查看lang_model-arxiv.ipynb，了解如何定义自己的 fastai/torchtext 数据集。

splits = torchtext.datasets.IMDB.splits(TEXT, IMDB_LABEL, 'data/')
t = splits[0].examples[0]
t.label, ' '.join(t.text[:16])
'''
('pos', 'ashanti is a very 70s sort of film ( 1979 , to be precise ) .')
'''

fastai 可以直接从 torchtext 的splits创建一个ModelData对象。

md2 = TextData.from_splits(PATH, splits, bs)

现在你可以继续调用get_model来获取我们的学习者。然后我们可以加载预训练的语言模型（load_encoder）。

m3 = md2.get_model(opt_fn, 1500, bptt, emb_sz=em_sz, n_hid=nh, n_layers=nl, dropout=0.1, dropouti=0.4,wdrop=0.5, dropoute=0.05, dropouth=0.3
)
m3.reg_fn = partial(seq2seq_reg, alpha=2, beta=1)
m3.load_encoder(f'adam3_20_enc')

因为我们正在微调一个预训练模型，我们将使用不同的学习率，并增加用于剪切的最大梯度，以使 SGDR 更好地工作。

m3.clip=25.
lrs=np.array([1e-4,1e-3,1e-2])
m3.freeze_to(-1)
m3.fit(lrs/2, 1, metrics=[accuracy])
m3.unfreeze()
m3.fit(lrs, 1, metrics=[accuracy], cycle_len=1)
'''
[ 0\.       0.45074  0.28424  0.88458]
[ 0\.       0.29202  0.19023  0.92768]
'''

我们确保除了最后一层外，所有层都被冻结。然后我们进行一些训练，解冻它，再进行一些训练。好处是一旦你有了一个预训练的语言模型，它实际上训练速度非常快。

m3.fit(lrs, 7, metrics=[accuracy], cycle_len=2, cycle_save_name='imdb2'
)
'''
[ 0\.       0.29053  0.18292  0.93241]                        
[ 1\.       0.24058  0.18233  0.93313]                        
[ 2\.       0.24244  0.17261  0.93714]                        
[ 3\.       0.21166  0.17143  0.93866]                        
[ 4\.       0.2062   0.17143  0.94042]                        
[ 5\.       0.18951  0.16591  0.94083]                        
[ 6\.       0.20527  0.16631  0.9393 ]                        
[ 7\.       0.17372  0.16162  0.94159]                        
[ 8\.       0.17434  0.17213  0.94063]                        
[ 9\.       0.16285  0.16073  0.94311]                        
[ 10\.        0.16327   0.17851   0.93998]                    
[ 11\.        0.15795   0.16042   0.94267]                    
[ 12\.        0.1602    0.16015   0.94199]                    
[ 13\.        0.15503   0.1624    0.94171]
'''
m3.load_cycle('imdb2', 4)
accuracy(*m3.predict_with_targs())
'''
0.94310897435897434
'''

Bradbury 等人最近发表的一篇论文，学习中的翻译：上下文化的词向量，对解决 IMDB 情感分析问题的最新学术研究进行了方便的总结。许多最新的算法都是针对这个特定问题进行调整的。

正如你所看到的，我们在情感分析方面取得了最新的技术成果，将错误率从 5.9%降低到 5.5%！你应该能够使用相同的基本步骤在其他 NLP 分类问题上获得同样世界级的结果。

有许多机会进一步改进这一点，尽管我们在本课程的第二部分之前不会能够做到这一点。

• 例如，我们可以开始训练查看许多医学期刊的语言模型，然后我们可以制作一个可下载的医学语言模型，然后任何人都可以用它来在医学文献的前列腺癌子集上进行微调。

• 我们还可以将其与预训练的词向量结合使用

• 我们本可以预先训练一个维基百科语料库语言模型，然后将其微调为一个 IMDB 语言模型，然后再将其微调为一个 IMDB 情感分析模型，我们会得到比这个更好的东西。

有一个名为 Sebastian Ruder 的非常出色的研究人员，他是唯一一个真正大量撰写关于 NLP 中预训练、微调和迁移学习的研究人员。Jeremy 问他为什么这种情况没有更多发生，他的观点是因为没有软件使其变得容易。希望 Fast.ai 会改变这一点。

协同过滤介绍 [02:11:38]

path='data/ml-latest-small/'
ratings = pd.read_csv(path+'ratings.csv')
ratings.head()

movies = pd.read_csv(path+'movies.csv')
movies.head()

g=ratings.groupby('userId')['rating'].count()
topUsers=g.sort_values(ascending=False)[:15]
g=ratings.groupby('movieId')['rating'].count()
topMovies=g.sort_values(ascending=False)[:15]
top_r = ratings.join(topUsers, rsuffix='_r', how='inner', on='userId'
)
top_r = top_r.join(topMovies, rsuffix='_r', how='inner', on='movieId'
)
pd.crosstab(top_r.userId, top_r.movieId, top_r.rating, aggfunc=np.sum
)

深度学习 2：第 1 部分第 5 课

原文：medium.com/@hiromi_suenaga/deep-learning-2-part-1-lesson-5-dd904506bee8

译者：飞龙

协议：CC BY-NC-SA 4.0

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

Lesson 5

I. 介绍

在结构化深度学习方面的出版物还不够，但在行业中肯定正在发生：

结构化深度学习 by Kerem Turgutlu

您可以使用这个工具从 Google 下载图片并解决自己的问题：

小图像数据集的乐趣（第 2 部分）by Nikhil B

关于如何训练神经网络的介绍（一篇很棒的技术文章）：

我们如何‘训练’神经网络？ by Vitaly Bushaev

学生们正在与 Jeremy 一起参加Kaggle 幼苗分类竞赛。

II. 协同过滤 — 使用 MovieLens 数据集

讨论的笔记本可以在这里（lesson5-movielens.ipynb）找到。

让我们看看数据。我们将使用userId（分类）、movieId（分类）和rating（依赖）进行建模。

ratings = pd.read_csv(path+'ratings.csv')
ratings.head()

为 Excel 创建子集

我们创建了最受欢迎的电影和最痴迷于电影的用户的交叉表，我们将把它复制到 Excel 中进行可视化。

g=ratings.groupby('userId')['rating'].count()
topUsers=g.sort_values(ascending=False)[:15]
g=ratings.groupby('movieId')['rating'].count()
topMovies=g.sort_values(ascending=False)[:15]
top_r = ratings.join(topUsers, rsuffix='_r', how='inner', on='userId')
top_r = top_r.join(topMovies, rsuffix='_r', how='inner', on='movieId')
pd.crosstab(top_r.userId, top_r.movieId, top_r.rating, aggfunc=np.sum)

这是包含上述信息的 Excel 文件。首先，我们将使用矩阵分解而不是构建神经网络。

• 蓝色单元格 — 实际评分

• 紫色单元格 — 我们的预测

• 红色单元格 — 我们的损失函数即均方根误差（RMSE）

• 绿色单元格 — 电影嵌入（随机初始化）

• 橙色单元格 — 用户嵌入（随机初始化）

每个预测是电影嵌入向量和用户嵌入向量的点积。在线性代数术语中，这相当于矩阵乘积，因为一个是行，一个是列。如果没有实际评分，我们将预测设为零（将其视为测试数据 — 而不是训练数据）。

然后我们使用梯度下降来最小化我们的损失。Microsoft Excel 中有一个“求解器”插件，可以通过更改选定的单元格来最小化一个变量（GRG Nonlinear是您要使用的方法）。

这可以称为“浅层学习”（与深度学习相对），因为没有非线性层或第二个线性层。那么我们刚刚直观地做了什么？每部电影的五个数字称为“嵌入”（潜在因素） - 第一个数字可能表示它有多少科幻和奇幻，第二个可能表示为电影使用了多少特效，第三个可能表示它有多少对话驱动，等等。同样，每个用户也有 5 个数字，例如，表示用户有多喜欢科幻奇幻、特效和对话驱动的电影。我们的预测是这些向量的叉积。由于我们没有每个用户对每部电影的评论，我们试图找出哪些电影与这部电影相似，以及其他用户如何评价这部电影（因此称为“协同”）。

对于新用户或新电影，我们该怎么办 - 我们需要重新训练模型吗？我们现在没有时间来讨论这个问题，但基本上您需要有一个新的用户模型或新的电影模型，最初会使用它，随着时间的推移，您将需要重新训练模型。

简单的 Python 版本[26:03]

这应该现在看起来很熟悉。我们通过选择随机 ID 集创建一个验证集。wd是 L2 正则化的权重衰减，n_factors是我们想要的嵌入矩阵有多大。

val_idxs = get_cv_idxs(len(ratings)) 
wd = 2e-4 
n_factors = 50

我们从 CSV 文件创建一个模型数据对象：

cf = CollabFilterDataset.from_csv(path, 'ratings.csv', 'userId', 'movieId', 'rating')

然后我们得到一个适合模型数据的学习器，并拟合模型：

learn = cf.get_learner(n_factors, val_idxs, 64, opt_fn=optim.Adam)
learn.fit(1e-2, 2, wds=wd, cycle_len=1, cycle_mult=2)

输出 MSE

由于输出是均方误差，您可以通过以下方式获得 RMSE：

math.sqrt(0.765)

输出约为 0.88，优于 0.91 的基准。

您可以以通常的方式获得预测：

preds = learn.predict()

您还可以使用 seaborn sns进行绘图（建立在 matplotlib 之上）：

y = learn.data.val_y
sns.jointplot(preds, y, kind='hex', stat_func=None)

使用 Python 进行点积

T是 Torch 中的张量

a = T([[1., 2], [3, 4]])
b = T([[2., 2], [10, 10]])

当我们在 numpy 或 PyTorch 中的张量之间有数学运算符时，它将假定它们具有相同的维度进行逐元素操作。下面是如何计算两个向量的点积的方法（例如(1, 2)⋅(2, 2) = 6 - 矩阵 a 和 b 的第一行）：

(a*b).sum(1)
'''
6
70
[torch.FloatTensor of size 2]
'''

构建我们的第一个自定义层（即 PyTorch 模块）[33:55]

我们通过创建一个扩展nn.Module并覆盖forward函数的 Python 类来实现这一点。

class DotProduct (nn.Module):def forward(self, u, m): return (u*m).sum(1)

现在我们可以调用它并获得预期结果（请注意，我们不需要说model.forward(a, b)来调用forward函数 - 这是 PyTorch 的魔法。）[40:14]：

model = DotProduct()
model(a,b)
'''
6
70
[torch.FloatTensor of size 2]
'''

构建更复杂的模块[41:31]

这个实现对DotProduct类有两个添加：

• 两个nn.Embedding矩阵

• 在上面的嵌入矩阵中查找我们的用户和电影

用户 ID 可能不是连续的，这使得难以用作嵌入矩阵的索引。因此，我们将从零开始创建连续的索引，并用 Panda 的apply函数和匿名函数lambda替换ratings.userId列，并对ratings.movieId执行相同操作。

u_uniq = ratings.userId.unique() 
user2idx = {o:i for i,o in enumerate(u_uniq)} 
ratings.userId = ratings.userId.apply(lambda x: user2idx[x]) 
m_uniq = ratings.movieId.unique() 
movie2idx = {o:i for i,o in enumerate(m_uniq)} 
ratings.movieId = ratings.movieId.apply(lambda x: movie2idx[x]) 
n_users=int(ratings.userId.nunique()) 
n_movies=int(ratings.movieId.nunique())

提示：{o:i for i,o in enumerate(u_uniq)}是一行方便的代码，可以保存在您的工具包中！

class EmbeddingDot(nn.Module):def __init__(self, n_users, n_movies):super().__init__()self.u = nn.Embedding(n_users, n_factors)self.m = nn.Embedding(n_movies, n_factors)self.u.weight.data.uniform_(0,0.05)self.m.weight.data.uniform_(0,0.05)def forward(self, cats, conts):users,movies = cats[:,0],cats[:,1]u,m = self.u(users),self.m(movies)return (u*m).sum(1)

请注意，__init__是一个构造函数，现在需要它，因为我们的类需要跟踪“状态”（有多少电影，有多少用户，有多少因素等）。我们将权重初始化为 0 到 0.05 之间的随机数，您可以在这里找到有关权重初始化的标准算法“Kaiming Initialization”的更多信息（PyTorch 具有 He 初始化实用程序函数，但我们正在尝试从头开始做事）[46:58]。

Embedding不是张量，而是变量。变量执行与张量完全相同的操作，但它还执行自动微分。要从变量中提取张量，请调用data属性。所有张量函数都有一个带有下划线的变体（例如uniform_），将在原地执行操作。

x = ratings.drop(['rating', 'timestamp'],axis=1)
y = ratings['rating'].astype(np.float32)
data = ColumnarModelData.from_data_frame(path, val_idxs, x, y, ['userId', 'movieId'], 64)

我们正在重用来自 Rossmann 笔记本的ColumnarModelData（来自 fast.ai 库），这就是为什么在EmbeddingDot类的def forward(self, cats, conts)函数中有分类和连续变量的原因[50:20]。由于在这种情况下我们没有连续变量，我们将忽略conts，并使用cats的第一列和第二列作为users和movies。请注意，它们是用户和电影的小批量。重要的是不要手动循环遍历小批量，因为这样不会获得 GPU 加速，而是一次处理整个小批量，就像您在上面forward函数的第 3 和第 4 行中看到的那样[51:00–52:05]。

wd=1e-5
model = EmbeddingDot(n_users, n_movies).cuda()
opt = optim.SGD(model.parameters(), 1e-1, weight_decay=wd, momentum=0.9)

optim是 PyTorch 中提供优化器的东西。model.parameters()是从nn.Modules继承的一个函数，它给出所有需要更新/学习的权重。

fit(model, data, 3, opt, F.mse_loss)

这个函数来自 fast.ai 库[54:40]，与我们一直在使用的learner.fit()相比，更接近常规的 PyTorch 方法。它不会为您提供“随机梯度下降重启”或“不同学习率”等功能。

让我们改进我们的模型

偏差 - 调整到普遍受欢迎的电影或普遍热情的用户。

min_rating,max_rating = ratings.rating.min(),ratings.rating.max()
min_rating,max_rating
def get_emb(ni,nf):e = nn.Embedding(ni, nf)e.weight.data.uniform_(-0.01,0.01)return e
class EmbeddingDotBias(nn.Module):def __init__(self, n_users, n_movies):super().__init__()(self.u, self.m, self.ub, self.mb) = [get_emb(*o) for o in [(n_users, n_factors), (n_movies, n_factors), (n_users,1), (n_movies,1)]]def forward(self, cats, conts):users,movies = cats[:,0],cats[:,1]um = (self.u(users)* self.m(movies)).sum(1)res = um + self.ub(users).squeeze() + self.mb(movies).squeeze()res = F.sigmoid(res) * (max_rating-min_rating) + min_ratingreturn res

squeeze是 PyTorch 版本的广播[1:04:11]，有关更多信息，请参阅机器学习课程或numpy 文档。

我们可以压缩评分，使其在 1 和 5 之间吗？可以！通过将预测通过 sigmoid 函数，将得到 1 和 0 之间的数字。因此，在我们的情况下，我们可以将其乘以 4 并加 1 - 这将得到 1 和 5 之间的数字。

F是 PyTorch 功能（torch.nn.functional），包含所有张量的函数，并在大多数情况下导入为F。

wd=2e-4
model = EmbeddingDotBias(cf.n_users, cf.n_items).cuda()
opt = optim.SGD(model.parameters(), 1e-1, weight_decay=wd, momentum=0.9)
fit(model, data, 3, opt, F.mse_loss)
'''
[ 0\.       0.85056  0.83742]                                     
[ 1\.       0.79628  0.81775]                                     
[ 2\.       0.8012   0.80994]
'''

让我们看看我们在简单的 Python 版本中使用的 fast.ai 代码[1:13:44]。在column_data.py文件中，CollabFilterDataSet.get_leaner调用get_model函数，该函数创建了EmbeddingDotBias类，与我们创建的内容相同。

神经网络版本[1:17:21]

class EmbeddingNet(nn.Module):def __init__(self, n_users, n_movies, nh=10, p1=0.5, p2=0.5):super().__init__()(self.u, self.m) = [get_emb(*o) for o in [(n_users, n_factors), (n_movies, n_factors)]]self.lin1 = nn.Linear(n_factors*2, nh)self.lin2 = nn.Linear(nh, 1)self.drop1 = nn.Dropout(p1)self.drop2 = nn.Dropout(p2)def forward(self, cats, conts):users,movies = cats[:,0],cats[:,1]x = self.drop1(torch.cat([self.u(users),self.m(movies)], dim=1))x = self.drop2(F.relu(self.lin1(x)))return F.sigmoid(self.lin2(x)) * (max_rating-min_rating+1) + min_rating-0.5

wd=1e-5
model = EmbeddingNet(n_users, n_movies).cuda()
opt = optim.Adam(model.parameters(), 1e-3, weight_decay=wd)
fit(model, data, 3, opt, F.mse_loss)
'''
A Jupyter Widget
[ 0\.       0.88043  0.82363]                                    
[ 1\.       0.8941   0.81264]                                    
[ 2\.       0.86179  0.80706]
'''

训练循环中发生了什么？[1:33:21]

opt = optim.SGD(model.parameters(), 1e-1, weight_decay=wd, momentum=0.9)

链式规则和反向传播

更快的方法是通过分析进行[1:45:27]。为此，我们需要一个链式规则：

链式规则概述

这是 Chris Olah 关于反向传播作为链式规则的一篇很棒的文章。

现在我们用实际导数替换有限差分WolframAlpha给我们提供了（请注意，有限差分输出与实际导数非常接近，是计算自己的导数的快速检查的好方法）：

• “在线”训练 - 小批量大小为 1

这就是你在 Excel 表格中使用 SGD 的方法。如果你将预测值更改为 CNN 电子表格的输出，我们可以使用 SGD 训练 CNN。

动量[1:53:47]

Adam[1:59:04]

avg_loss = avg_loss * avg_mom + loss * (1-avg_mom)

一些直觉

• 我们计算了梯度平方的指数加权移动平均值，对其取平方根，并将学习率除以它。

• 梯度的平方始终为正。

• 当梯度变化很大时，梯度的平方会很大。

• 当梯度恒定时，梯度的平方会很小。

• 如果梯度变化很大，我们希望小心谨慎，并通过一个大数来除以学习率（减慢速度）

• 如果梯度变化不大，我们将通过一个小数来除以学习率，从而迈出更大的一步

• 自适应学习率 ——跟踪梯度平方的平均值，并使用它来调整学习率。因此只有一个学习率，但如果梯度恒定，则每个参数在每个时期都会跳得更远；否则跳得更小。

• 有两种动量 —— 一个用于梯度，另一个用于梯度的平方（在 PyTorch 中，它被称为 beta，是两个数字的元组）

AdamW[2:11:18]