记录学习《手动学习深度学习》这本书的笔记（十一）

接下来学习第15章：自然语言处理：应用.

最近正好也在做NLP相关的实验，正好学习一下。顺便一提我们做的实验是机器人对话方面的，需要用到文本对。

第十五章：自然语言处理：应用

NLP的下游任务侧重于如何用深度语言表征学习来解决自然语言处理问题，上游预训练已经在上一章给出，本章探讨的是两种流行且具有代表性的下游自然语言处理任务：情感分析 和自然语言推断 ，分别分析单个文本 和文本对直接的关系。

具体来说如图所示，我们将在这一章设计不同的深度学习架构实现两种应用，比如对于情感分类使用卷积神经网络和循环神经网络架构，对于自然语言推断使用多层感知机和注意力机制架构。

最后，本章还会介绍如何为更多更广泛的NLP任务对预训练BERT进行微调。（上一章说过对不同任务预训练BERT模型只需要最小的调整，但其实还要对很多下游参数微调）

15.1 情感分析及数据集

情感分析任务我们选取斯坦福大学大型电影评论数据集，它由训练集和测试集组成，其中"消极"和"积极"标签数量相同。

#@save
d2l.DATA_HUB['aclImdb'] = (
    'http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz',
    '01ada507287d82875905620988597833ad4e0903')

data_dir = d2l.download_extract('aclImdb', 'aclImdb')

读取训练集和测试集，每一条数据都由内容和标签组成，标签1表示积极，0表示消极。

#@save
def read_imdb(data_dir, is_train):
    """读取IMDb评论数据集文本序列和标签"""
    data, labels = [], []
    for label in ('pos', 'neg'):
        folder_name = os.path.join(data_dir, 'train' if is_train else 'test',
                                   label)
        for file in os.listdir(folder_name):
            with open(os.path.join(folder_name, file), 'rb') as f:
                review = f.read().decode('utf-8').replace('\n', '')
                data.append(review)
                labels.append(1 if label == 'pos' else 0)
    return data, labels

train_data = read_imdb(data_dir, is_train=True)
print('训练集数目：', len(train_data[0]))
for x, y in zip(train_data[0][:3], train_data[1][:3]):
    print('标签：', y, 'review:', x[0:60])

（这里只读取了训练集，之后再读取测试集。）

接着将每个词作为一个词元并过滤掉出现次数小于5的词元，构建词典：

train_tokens = d2l.tokenize(train_data[0], token='word')
vocab = d2l.Vocab(train_tokens, min_freq=5, reserved_tokens=['<pad>'])

为了确定最大长度，我们查看评论长度直方图：

d2l.set_figsize()
d2l.plt.xlabel('# tokens per review')
d2l.plt.ylabel('count')
d2l.plt.hist([len(line) for line in train_tokens], bins=range(0, 1000, 50));

于是设置从500截断。将最大长度和填充长度设为500，并将单词转化为词典中的索引，将句子列表转化为张量：

num_steps = 500  # 序列长度
train_features = torch.tensor([d2l.truncate_pad(
    vocab[line], num_steps, vocab['<pad>']) for line in train_tokens])
print(train_features.shape)

这样就得到了所有评论的张量。

接着就可以创建迭代器了，每次迭代中有一小批量样本：

train_iter = d2l.load_array((train_features,
    torch.tensor(train_data[1])), 64)

for X, y in train_iter:
    print('X:', X.shape, ', y:', y.shape)
    break
print('小批量数目：', len(train_iter))

最后整合代码，将所有代码封装起来，代表着从下载数据集到将其变成可以用于训练的小批量的全过程：

#@save
def load_data_imdb(batch_size, num_steps=500):
    """返回数据迭代器和IMDb评论数据集的词表"""
    data_dir = d2l.download_extract('aclImdb', 'aclImdb')
    train_data = read_imdb(data_dir, True)
    test_data = read_imdb(data_dir, False)
    train_tokens = d2l.tokenize(train_data[0], token='word')
    test_tokens = d2l.tokenize(test_data[0], token='word')
    vocab = d2l.Vocab(train_tokens, min_freq=5)
    train_features = torch.tensor([d2l.truncate_pad(
        vocab[line], num_steps, vocab['<pad>']) for line in train_tokens])
    test_features = torch.tensor([d2l.truncate_pad(
        vocab[line], num_steps, vocab['<pad>']) for line in test_tokens])
    train_iter = d2l.load_array((train_features, torch.tensor(train_data[1])),
                                batch_size)
    test_iter = d2l.load_array((test_features, torch.tensor(test_data[1])),
                               batch_size,
                               is_train=False)
    return train_iter, test_iter, vocab

只需要输入批量大小，就可以返回大型电影评论数据集可用于训练的训练迭代器、测试迭迭代器和词表。

15.2 情感分析：使用循环神经网络

本节构建一个基于循环神经网络的情感分类模型。

想法是构建一个双向循环神经网络用于获得文本序列表示，接着通过线性层转化为情感分析输出。

模型代码并不难，使用编码器-解码器架构，编码器通过双向LSTM实现，解码器通过简单的线性层实现，输入双向LSTM的第一个和最后一个隐状态，输出两个类别。

class BiRNN(nn.Module):
    def __init__(self, vocab_size, embed_size, num_hiddens,
                 num_layers, **kwargs):
        super(BiRNN, self).__init__(**kwargs)
        self.embedding = nn.Embedding(vocab_size, embed_size)
        # 将bidirectional设置为True以获取双向循环神经网络
        self.encoder = nn.LSTM(embed_size, num_hiddens, num_layers=num_layers,
                                bidirectional=True)
        self.decoder = nn.Linear(4 * num_hiddens, 2)

    def forward(self, inputs):
        # inputs的形状是（批量大小，时间步数）
        # 因为长短期记忆网络要求其输入的第一个维度是时间维，
        # 所以在获得词元表示之前，输入会被转置。
        # 输出形状为（时间步数，批量大小，词向量维度）
        embeddings = self.embedding(inputs.T)
        self.encoder.flatten_parameters()
        # 返回上一个隐藏层在不同时间步的隐状态，
        # outputs的形状是（时间步数，批量大小，2*隐藏单元数）
        outputs, _ = self.encoder(embeddings)
        # 连结初始和最终时间步的隐状态，作为全连接层的输入，
        # 其形状为（批量大小，4*隐藏单元数）
        encoding = torch.cat((outputs[0], outputs[-1]), dim=1)
        outs = self.decoder(encoding)
        return outs

需要注意，双向LSTM的输出output是将双向隐状态拼接在一起，前num_hiddens是前向，后num_hiddens是反向。

原本每个时间步都会输出双向隐状态，这里只需要取第一个时间步和最后一个时间步。

embed_size, num_hiddens, num_layers = 100, 100, 2
devices = d2l.try_all_gpus()
net = BiRNN(len(vocab), embed_size, num_hiddens, num_layers)

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
    if type(m) == nn.LSTM:
        for param in m._flat_weights_names:
            if "weight" in param:
                nn.init.xavier_uniform_(m._parameters[param])
net.apply(init_weights);

初始化权重，偏置一般不需要初始化，默认全为0。

加载预训练（GloVe嵌入），设置为嵌入层的权重，并且训练时不需要计算梯度：

glove_embedding = d2l.TokenEmbedding('glove.6b.100d')
embeds = glove_embedding[vocab.idx_to_token]
net.embedding.weight.data.copy_(embeds)
net.embedding.weight.requires_grad = False

训练模型：

lr, num_epochs = 0.01, 5
trainer = torch.optim.Adam(net.parameters(), lr=lr)
loss = nn.CrossEntropyLoss(reduction="none")
d2l.train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
    devices)

定义预测函数，将输入句子切分为词元，转换为id张量输入到模型中，选取输出中两个数最大的那个作为预测标签：

#@save
def predict_sentiment(net, vocab, sequence):
    """预测文本序列的情感"""
    sequence = torch.tensor(vocab[sequence.split()], device=d2l.try_gpu())
    label = torch.argmax(net(sequence.reshape(1, -1)), dim=1)
    return 'positive' if label == 1 else 'negative'

一个简单的示例：

predict_sentiment(net, vocab, 'this movie is so great')
predict_sentiment(net, vocab, 'this movie is so bad')

15.3 情感分析：使用卷积神经网络

本节构建一个基于卷积神经网络的情感分类模型。

因为语言是一维的，所以这里使用的一维卷积和之前介绍的二维卷积有些区别，不过实际上也只是二维卷积的特例。

卷积窗口只在左右滑动，和二维卷积一样，卷积窗口每个位置和卷积核对应元素相乘，最后相加，每次将卷积窗口右移一位，得到的结果排成一行。

写一个一维卷积：

def corr1d(X, K):
    w = K.shape[0]
    Y = np.zeros((X.shape[0] - w + 1))
    for i in range(Y.shape[0]):
        Y[i] = (X[i: i + w] * K).sum()
    return Y

再写一个多通道一维卷积：

def corr1d_multi_in(X, K):
    # 首先，遍历'X'和'K'的第0维（通道维）。然后，把它们加在一起
    return sum(corr1d(x, k) for x, k in zip(X, K))

多通道一维卷积有多个X和K，对于每个通道，计算它X和K的卷积，最后再将每个通道计算的卷积结果相加。

这看起来很熟悉，其实就相当于卷积核高度等于输入张量高度的二维卷积。

至于汇聚层，在textCNN中，一般使用最大时间汇聚层（类似一维全局汇聚层），也就是每个通道取这个通道最大的值。注意，最大时间汇聚层允许不同通道上使用不同数量的时间步。

还要思考输入的用d维向量表示的 n 个词元，其中 d 和 n 分别作为什么，通常向量维度 d 视作通道数，词元数目 n 作为输入张量的宽度。

实现步骤：

1. 定义多个卷积核，分别输入输入张量，用于提取不同特征，卷积核长度可以不同，捕获不同数目的相邻词元的局部特征。
2. 所有输出通道连接最大时间汇聚层，然后将所有通道的标量结果连接成向量。
3. 使用全连接层将连接后的向量转化为输出类别，可以使用暂退法减少过拟合。

使用图和例子直观描述：

接下来就可以定义textCNN模型，这里注意和前面使用循环神经网络进行情感分析不同，这里嵌入层定义了两个，一个是原本的GloVe预训练（这里无需训练），一个是可训练嵌入层。

class TextCNN(nn.Module):
    def __init__(self, vocab_size, embed_size, kernel_sizes, num_channels,
                 **kwargs):
        super(TextCNN, self).__init__(**kwargs)
        self.embedding = nn.Embedding(vocab_size, embed_size)
        # 这个嵌入层不需要训练
        self.constant_embedding = nn.Embedding(vocab_size, embed_size)
        self.dropout = nn.Dropout(0.5)
        self.decoder = nn.Linear(sum(num_channels), 2)
        # 最大时间汇聚层没有参数，因此可以共享此实例
        self.pool = nn.AdaptiveAvgPool1d(1)
        self.relu = nn.ReLU()
        # 创建多个一维卷积层
        self.convs = nn.ModuleList()
        for c, k in zip(num_channels, kernel_sizes):
            self.convs.append(nn.Conv1d(2 * embed_size, c, k))

    def forward(self, inputs):
        # 沿着向量维度将两个嵌入层连结起来，
        # 每个嵌入层的输出形状都是（批量大小，词元数量，词元向量维度）连结起来
        embeddings = torch.cat((
            self.embedding(inputs), self.constant_embedding(inputs)), dim=2)
        # 根据一维卷积层的输入格式，重新排列张量，以便通道作为第2维
        embeddings = embeddings.permute(0, 2, 1)
        # 每个一维卷积层在最大时间汇聚层合并后，获得的张量形状是（批量大小，通道数，1）
        # 删除最后一个维度并沿通道维度连结
        encoding = torch.cat([
            torch.squeeze(self.relu(self.pool(conv(embeddings))), dim=-1)
            for conv in self.convs], dim=1)
        outputs = self.decoder(self.dropout(encoding))
        return outputs

两个嵌入层的维度合并，之后将合并后的维度作为通道数，对其进行不同的卷积操作、池化操作、激活函数操作，最后将所有卷积块的结果合并，最后用全连接层输出结果。

依旧是创建实例、初始化参数：

embed_size, kernel_sizes, nums_channels = 100, [3, 4, 5], [100, 100, 100]
devices = d2l.try_all_gpus()
net = TextCNN(len(vocab), embed_size, kernel_sizes, nums_channels)

def init_weights(m):
    if type(m) in (nn.Linear, nn.Conv1d):
        nn.init.xavier_uniform_(m.weight)

net.apply(init_weights);

加载GloVe嵌入层、训练：

glove_embedding = d2l.TokenEmbedding('glove.6b.100d')
embeds = glove_embedding[vocab.idx_to_token]
net.embedding.weight.data.copy_(embeds)
net.constant_embedding.weight.data.copy_(embeds)
net.constant_embedding.weight.requires_grad = False

然后就是训练，和前面差不多：

lr, num_epochs = 0.001, 5
trainer = torch.optim.Adam(net.parameters(), lr=lr)
loss = nn.CrossEntropyLoss(reduction="none")
d2l.train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs, devices)

15.4 自然语言推断与数据集

先介绍一下自然语言推断任务。

它又被称为识别文本蕴含任务，一对文本（假设和前提）间可能有如下关系：

• 蕴含：假设可以从前提中推断出来。
• 矛盾：假设的否定可以从前提中推断出来。
• 中性：其他所有情况。

自然语言推断就是判断文本对属于哪种情况。

自然语言推断一直是理解自然语言的中心话题，为了研究这个问题，首先肯定是要一个合适的数据集。

这里选用斯坦福自然语言推断数据集，它由很多带标签的英文句子对组成。

#@save
d2l.DATA_HUB['SNLI'] = (
    'https://nlp.stanford.edu/projects/snli/snli_1.0.zip',
    '9fcde07509c7e87ec61c640c1b2753d9041758e4')

data_dir = d2l.download_extract('SNLI')

和之前一样，读取数据集（数据集原本的标签非常多，这里只需要之前提到的三种）：

#@save
def read_snli(data_dir, is_train):
    """将SNLI数据集解析为前提、假设和标签"""
    def extract_text(s):
        # 删除我们不会使用的信息
        s = re.sub('\\(', '', s)
        s = re.sub('\\)', '', s)
        # 用一个空格替换两个或多个连续的空格
        s = re.sub('\\s{2,}', ' ', s)
        return s.strip()
    label_set = {'entailment': 0, 'contradiction': 1, 'neutral': 2}
    file_name = os.path.join(data_dir, 'snli_1.0_train.txt'
                             if is_train else 'snli_1.0_test.txt')
    with open(file_name, 'r') as f:
        rows = [row.split('\t') for row in f.readlines()[1:]]
    premises = [extract_text(row[1]) for row in rows if row[0] in label_set]
    hypotheses = [extract_text(row[2]) for row in rows if row[0] \
                in label_set]
    labels = [label_set[row[0]] for row in rows if row[0] in label_set]
    return premises, hypotheses, labels

最终返回的列表分别是前提、假设、标签。

调用这个函数分别导入训练集和测试集：

train_data = read_snli(data_dir, is_train=True)
test_data = read_snli(data_dir, is_train=False)

接着定义加载数据集的类，包括构建词表（如果没有的话）、将词元转化为索引、填充或切断文本使其都为指定长度：

#@save
class SNLIDataset(torch.utils.data.Dataset):
    """用于加载SNLI数据集的自定义数据集"""
    def __init__(self, dataset, num_steps, vocab=None):
        self.num_steps = num_steps
        all_premise_tokens = d2l.tokenize(dataset[0])
        all_hypothesis_tokens = d2l.tokenize(dataset[1])
        if vocab is None:
            self.vocab = d2l.Vocab(all_premise_tokens + \
                all_hypothesis_tokens, min_freq=5, reserved_tokens=['<pad>'])
        else:
            self.vocab = vocab
        self.premises = self._pad(all_premise_tokens)
        self.hypotheses = self._pad(all_hypothesis_tokens)
        self.labels = torch.tensor(dataset[2])
        print('read ' + str(len(self.premises)) + ' examples')

    def _pad(self, lines):
        return torch.tensor([d2l.truncate_pad(
            self.vocab[line], self.num_steps, self.vocab['<pad>'])
                         for line in lines])

    def __getitem__(self, idx):
        return (self.premises[idx], self.hypotheses[idx]), self.labels[idx]

    def __len__(self):
        return len(self.premises)

最后整合所有代码，构建一个从下载数据集到最后返回数据迭代器和词典的函数：

#@save
def load_data_snli(batch_size, num_steps=50):
    """下载SNLI数据集并返回数据迭代器和词表"""
    num_workers = d2l.get_dataloader_workers()
    data_dir = d2l.download_extract('SNLI')
    train_data = read_snli(data_dir, True)
    test_data = read_snli(data_dir, False)
    train_set = SNLIDataset(train_data, num_steps)
    test_set = SNLIDataset(test_data, num_steps, train_set.vocab)
    train_iter = torch.utils.data.DataLoader(train_set, batch_size,
                                             shuffle=True,
                                             num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(test_set, batch_size,
                                            shuffle=False,
                                            num_workers=num_workers)
    return train_iter, test_iter, train_set.vocab

这里与前面情感分析的数据迭代器不同，使用了pytorch自带的迭代器函数。

并且iter内部有两个维度，多了一个代表假设和前提的维度。

train_iter, test_iter, vocab = load_data_snli(128, 50)
for X, Y in train_iter:
    print(X[0].shape)
    print(X[1].shape)
    print(Y.shape)
    break

15.5 自然语言推断：使用注意力

有人提出用注意力机制解决自然语言推断问题，称为"可分解注意力模型"。这种模型没有循环层或卷积层，只使用注意力机制和多层感知机，以较少的参数实现了很好的效果。

因为要查询两个文本序列之间的对应关系，所以这里实现的注意力机制和之前的注意力机制有些区别，在之前的章节，注意力的 qkv 都是从同一个序列中提取，这里为了捕获文本对之间的关系，可以从两个序列中分别提取 qkv ，用一个序列的 q 查询另一个序列的 kv 。

关键步骤：注意 、比较 、聚合。

1. 注意

第一步是将两个文本对齐，这种对齐是使用加权平均的"软"对齐，将关联较大的词给予较大的权重。

比如上图的对齐是"硬"对齐，将 I 和 I 对齐，sleep 和 tired 对齐。

详细解释软对齐：假设两个文本 ， ，一个小写字母代表一个词元向量，注意力权重 则为： ，理想是关联越强的俩词元权重越大。

其中 是多层感知机，由下面的mlp函数定义：

def mlp(num_inputs, num_hiddens, flatten):
    net = []
    net.append(nn.Dropout(0.2))
    net.append(nn.Linear(num_inputs, num_hiddens))
    net.append(nn.ReLU())
    if flatten:
        net.append(nn.Flatten(start_dim=1))
    net.append(nn.Dropout(0.2))
    net.append(nn.Linear(num_hiddens, num_hiddens))
    net.append(nn.ReLU())
    if flatten:
        net.append(nn.Flatten(start_dim=1))
    return nn.Sequential(*net)

并且，只需要分别计算每一个 和 ，不是直接计算 这种分解方式使得对长度分别为 m 和 n 的文本对只需要计算 m+n 次而不是 mn 次。

对注意力权重进行规范化，计算所有词元的加权平均值：

比如对于前提中词元 在假设中的查询： 相当于加权（注意力权重）求和。

同样， 代表假设中词元 在前提中的查询。

下面定义一个Attention类计算两个查询：

class Attend(nn.Module):
    def __init__(self, num_inputs, num_hiddens, **kwargs):
        super(Attend, self).__init__(**kwargs)
        self.f = mlp(num_inputs, num_hiddens, flatten=False)

    def forward(self, A, B):
        # A/B的形状：（批量大小，序列A/B的词元数，embed_size）
        # f_A/f_B的形状：（批量大小，序列A/B的词元数，num_hiddens）
        f_A = self.f(A)
        f_B = self.f(B)
        # e的形状：（批量大小，序列A的词元数，序列B的词元数）
        e = torch.bmm(f_A, f_B.permute(0, 2, 1))
        # beta的形状：（批量大小，序列A的词元数，embed_size），
        # 意味着序列B被软对齐到序列A的每个词元(beta的第1个维度)
        beta = torch.bmm(F.softmax(e, dim=-1), B)
        # beta的形状：（批量大小，序列B的词元数，embed_size），
        # 意味着序列A被软对齐到序列B的每个词元(alpha的第1个维度)
        alpha = torch.bmm(F.softmax(e.permute(0, 2, 1), dim=-1), A)
        return beta, alpha

这个阶段和传统注意力机制非常像，觉得有点难理解的话可以将注意力权重中 看作查询 Q ， 看作键 K ， 中 看作值 V ，这个 相当于将假设 B 中所有词元与前提 A 中的词元 求注意力，返回的结果是 B 中所有词元的加权求和， 的值与假设中与 关系最紧密的那个词元 最接近。

和 形状相同。

2. 比较

第二步，将两个文本序列进行比较。

上一步我们将两个文本中的词元对齐，这一步我们将对齐的词元进行比较。

意思是需要将对齐的词元进行连接（运算符 ），之后被送入多层感知机中。

其中 和 是之前的查询，相当于查询连接对应词元。

其实还是有点难懂，书里是这么解释的： 是假设假设中所有词元都与前提中的词元 对齐，再与词元 作比较； 同理，假设前提中所有词元都与假设中的词元 对齐，再与词元 作比较。

定义Compare类计算比较：

class Compare(nn.Module):
    def __init__(self, num_inputs, num_hiddens, **kwargs):
        super(Compare, self).__init__(**kwargs)
        self.g = mlp(num_inputs, num_hiddens, flatten=False)

    def forward(self, A, B, beta, alpha):
        V_A = self.g(torch.cat([A, beta], dim=2))
        V_B = self.g(torch.cat([B, alpha], dim=2))
        return V_A, V_B

3. 聚合

第三步，聚合两组比较向量。

上一步我们得到两组比较向量，分别代表前提 A 和假设 B 。

在这一步，首先对两组比较向量求和：

接着将两个求和结果拼接并放入多层感知机中，获得最后的分类结果：

下面实现聚合Aggregate的类：

class Aggregate(nn.Module):
    def __init__(self, num_inputs, num_hiddens, num_outputs, **kwargs):
        super(Aggregate, self).__init__(**kwargs)
        self.h = mlp(num_inputs, num_hiddens, flatten=True)
        self.linear = nn.Linear(num_hiddens, num_outputs)

    def forward(self, V_A, V_B):
        # 对两组比较向量分别求和
        V_A = V_A.sum(dim=1)
        V_B = V_B.sum(dim=1)
        # 将两个求和结果的连结送到多层感知机中
        Y_hat = self.linear(self.h(torch.cat([V_A, V_B], dim=1)))
        return Y_hat

---

最后整合三个步骤的代码，变成一个大类：

class DecomposableAttention(nn.Module):
    def __init__(self, vocab, embed_size, num_hiddens, num_inputs_attend=100,
                 num_inputs_compare=200, num_inputs_agg=400, **kwargs):
        super(DecomposableAttention, self).__init__(**kwargs)
        self.embedding = nn.Embedding(len(vocab), embed_size)
        self.attend = Attend(num_inputs_attend, num_hiddens)
        self.compare = Compare(num_inputs_compare, num_hiddens)
        # 有3种可能的输出：蕴涵、矛盾和中性
        self.aggregate = Aggregate(num_inputs_agg, num_hiddens, num_outputs=3)

    def forward(self, X):
        premises, hypotheses = X
        A = self.embedding(premises)
        B = self.embedding(hypotheses)
        beta, alpha = self.attend(A, B)
        V_A, V_B = self.compare(A, B, beta, alpha)
        Y_hat = self.aggregate(V_A, V_B)
        return Y_hat

其中num_inputs_attend=100,num_inputs_compare=200, num_inputs_agg=400其实是因为embed_size=100。

---

接着就可以开始构建模型实例并训练了。

下载数据集：

batch_size, num_steps = 256, 50
train_iter, test_iter, vocab = d2l.load_data_snli(batch_size, num_steps)

创建模型实例，将预训练好的GloVe模型直接用于模型嵌入层：

embed_size, num_hiddens, devices = 100, 200, d2l.try_all_gpus()
net = DecomposableAttention(vocab, embed_size, num_hiddens)
glove_embedding = d2l.TokenEmbedding('glove.6b.100d')
embeds = glove_embedding[vocab.idx_to_token]
net.embedding.weight.data.copy_(embeds);

训练：

lr, num_epochs = 0.001, 4
trainer = torch.optim.Adam(net.parameters(), lr=lr)
loss = nn.CrossEntropyLoss(reduction="none")
d2l.train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
    devices)

定义预测函数：

#@save
def predict_snli(net, vocab, premise, hypothesis):
    """预测前提和假设之间的逻辑关系"""
    net.eval()
    premise = torch.tensor(vocab[premise], device=d2l.try_gpu())
    hypothesis = torch.tensor(vocab[hypothesis], device=d2l.try_gpu())
    label = torch.argmax(net([premise.reshape((1, -1)),
                           hypothesis.reshape((1, -1))]), dim=1)
    return 'entailment' if label == 0 else 'contradiction' if label == 1 \
            else 'neutral'

使用例子（这里书里的premise和hypothesis都需要传入单独的词汇，我觉得可以使用premise = torch.tensor(vocab[premise.split()], device=d2l.try_gpu())，将传入的句子分割）：

predict_snli(net, vocab, ['he', 'is', 'good', '.'], ['he', 'is', 'bad', '.'])

15.6 针对序列级和词元级应用微调BERT

这一节学习如何微调BERT将其用在各种自然语言处理任务上，将其用于不同下游任务。

下面举了四种任务的例子，主要学习根据任务微调模型的思想。

任务又分为序列级（前两个）和词元级（后两个），序列级是对整个文本序列做出判断，词元级则是针对每个词元进行判断，总之看了就懂了。

1. 单文本分类

将单个文本进行输入，输出分类结果。

比如判断句子语法合不合理，在之前说过用<cls>、<sep>分别作为句子开头和结尾以及俩文本间隔的标记，这里也可以。

这里对BERT模型的微调是，将<cls>的词元表示设定为表示整个文本的序列信息，最后只用这个标记的词表式放入分类模型，对整个文本序列进行分类。

（<cls>：终是我一个人承担了所有............）

2. 文本对分类或回归

对文本对进行分类，如之前学到的自然语言推断，这里使用连续值输出代替之前的离散输出，输出两个句子的关联程度。

和单文本分类类似，将两个文本合在一起（用<sep>隔开），用第一个文本开头的<cls>表示两个序列的文本信息。

如果是回归任务的话，下游稠密层就应该进行细微的更改，比如输出连续标签值、使用均方误差。

3. 文本标注

将一个文本中每个词元进行词性标注，注意需要对每一个词元。

词元级任务需要对每个词元输出，微调BERT是个很好的选择。思路是将每个词元的词表式放入稠密层，分类，输出各自标签。

其实和前两个序列级的任务还是有点像的，只不过这里需要将每个词元表示放入稠密层进行输出。

4. 问答

输入段落文本和问题文本，输出段落中能找到的问题的答案。

听着可能很神奇，我看到这个任务时的思路是和前一个任务类似，每个词元输出标签，最后选取标签为正的词元输出，但实际上并不是。

书里使用的方法是对每个词元进行两次判断，一次判断开始字符，一次判断结尾字符，最后输出中间的词元段。

这样的话相当于回归任务，第一次判断起始词元，求出每个词元是开始词元的概率；第二次判断终止词元，求出每个词元是结束词元的概率。最后得出最大的 ( )。

---

这样四种任务就介绍完了。

注意，在下游任务的监督学习期间，预训练BERT模型的参数只需要微调，而下游的全连接层那些额外层是从零开始训练的。

15.7 自然语言推断：微调BERT

这一节我们将利用15.6节学习的新知识对15.5的任务中BERT模型进行微调，为了简便，采用15.6中简单的多层感知机模型。

要进行微调，首先需要一个已经预训练好的BERT，这里加载现有BERT模型：

d2l.DATA_HUB['bert.base'] = (d2l.DATA_URL + 'bert.base.torch.zip',
                             '225d66f04cae318b841a13d32af3acc165f253ac')
d2l.DATA_HUB['bert.small'] = (d2l.DATA_URL + 'bert.small.torch.zip',
                              'c72329e68a732bef0452e4b96a1c341c8910f81f')

其中 bert.small 是个相对较小的版本，使用它进行演示。它的内部包含一个vocab.json词典和一个BERT参数文件pretrained.params。

首先定义加载模型的函数，直接将现有模型参数加载到之前定义的BERT模型中：

def load_pretrained_model(pretrained_model, num_hiddens, ffn_num_hiddens,
                          num_heads, num_layers, dropout, max_len, devices):
    data_dir = d2l.download_extract(pretrained_model)
    # 定义空词表以加载预定义词表
    vocab = d2l.Vocab()
    vocab.idx_to_token = json.load(open(os.path.join(data_dir,
        'vocab.json')))
    vocab.token_to_idx = {token: idx for idx, token in enumerate(
        vocab.idx_to_token)}
    bert = d2l.BERTModel(len(vocab), num_hiddens, norm_shape=[256],
                         ffn_num_input=256, ffn_num_hiddens=ffn_num_hiddens,
                         num_heads=4, num_layers=2, dropout=0.2,
                         max_len=max_len, key_size=256, query_size=256,
                         value_size=256, hid_in_features=256,
                         mlm_in_features=256, nsp_in_features=256)
    # 加载预训练BERT参数
    bert.load_state_dict(torch.load(os.path.join(data_dir,
                                                 'pretrained.params')))
    return bert, vocab

返回BERT中自带的词典和BERT嵌入层模型，供我们直接使用。

devices = d2l.try_all_gpus()
bert, vocab = load_pretrained_model(
    'bert.small', num_hiddens=256, ffn_num_hiddens=512, num_heads=4,
    num_layers=2, dropout=0.1, max_len=512, devices=devices)

这样就加载好词典和模型了。

接着处理数据集，我们的任务是自然语言推断，需要前提和假设两个文本序列和一个标签。

class SNLIBERTDataset(torch.utils.data.Dataset):
    def __init__(self, dataset, max_len, vocab=None):
        all_premise_hypothesis_tokens = [[
            p_tokens, h_tokens] for p_tokens, h_tokens in zip(
            *[d2l.tokenize([s.lower() for s in sentences])
              for sentences in dataset[:2]])]

        self.labels = torch.tensor(dataset[2])
        self.vocab = vocab
        self.max_len = max_len
        (self.all_token_ids, self.all_segments,
         self.valid_lens) = self._preprocess(all_premise_hypothesis_tokens)
        print('read ' + str(len(self.all_token_ids)) + ' examples')

    def _preprocess(self, all_premise_hypothesis_tokens):
        pool = multiprocessing.Pool(4)  # 使用4个进程
        out = pool.map(self._mp_worker, all_premise_hypothesis_tokens)
        all_token_ids = [
            token_ids for token_ids, segments, valid_len in out]
        all_segments = [segments for token_ids, segments, valid_len in out]
        valid_lens = [valid_len for token_ids, segments, valid_len in out]
        return (torch.tensor(all_token_ids, dtype=torch.long),
                torch.tensor(all_segments, dtype=torch.long),
                torch.tensor(valid_lens))

    def _mp_worker(self, premise_hypothesis_tokens):
        p_tokens, h_tokens = premise_hypothesis_tokens
        self._truncate_pair_of_tokens(p_tokens, h_tokens)
        tokens, segments = d2l.get_tokens_and_segments(p_tokens, h_tokens)
        token_ids = self.vocab[tokens] + [self.vocab['<pad>']] \
                             * (self.max_len - len(tokens))
        segments = segments + [0] * (self.max_len - len(segments))
        valid_len = len(tokens)
        return token_ids, segments, valid_len

    def _truncate_pair_of_tokens(self, p_tokens, h_tokens):
        # 为BERT输入中的'<CLS>'、'<SEP>'和'<SEP>'词元保留位置
        while len(p_tokens) + len(h_tokens) > self.max_len - 3:
            if len(p_tokens) > len(h_tokens):
                p_tokens.pop()
            else:
                h_tokens.pop()

    def __getitem__(self, idx):
        return (self.all_token_ids[idx], self.all_segments[idx],
                self.valid_lens[idx]), self.labels[idx]

    def __len__(self):
        return len(self.all_token_ids)

包括了加载数据集，将每个文本序列长度控制在max_len，长的切断短的填充。

实例化这个类，加载为迭代器：

# 如果出现显存不足错误，请减少"batch_size"。在原始的BERT模型中，max_len=512
batch_size, max_len, num_workers = 512, 128, d2l.get_dataloader_workers()
data_dir = d2l.download_extract('SNLI')
train_set = SNLIBERTDataset(d2l.read_snli(data_dir, True), max_len, vocab)
test_set = SNLIBERTDataset(d2l.read_snli(data_dir, False), max_len, vocab)
train_iter = torch.utils.data.DataLoader(train_set, batch_size, shuffle=True,
                                   num_workers=num_workers)
test_iter = torch.utils.data.DataLoader(test_set, batch_size,
                                  num_workers=num_workers)

接下来就到了微调BERT的环节了。

为了方便演示，我们建立一个模型，包括BERT中模型和我们自己构建的用于分类的稠密层。

class BERTClassifier(nn.Module):
    def __init__(self, bert):
        super(BERTClassifier, self).__init__()
        self.encoder = bert.encoder
        self.hidden = bert.hidden
        self.output = nn.Linear(256, 3)

    def forward(self, inputs):
        tokens_X, segments_X, valid_lens_x = inputs
        encoded_X = self.encoder(tokens_X, segments_X, valid_lens_x)
        return self.output(self.hidden(encoded_X[:, 0, :]))

这里演示了整个模型的过程：首先BERT中的encoder将文本转化为向量表示，接着取文本的开头<cls>的词表式放入多层感知机用于分类。

所以说之前用于预测下一句和掩蔽语言模型的参数在这个任务中不需要，所以不会更新那两个模型的参数。

在这里，BERT的两层（encoder和hidden）都只进行微调，而output是要从零开始训练。

接下来就可以创建模型实例：

net = BERTClassifier(bert)

训练：

lr, num_epochs = 1e-4, 5
trainer = torch.optim.Adam(net.parameters(), lr=lr)
loss = nn.CrossEntropyLoss(reduction='none')
d2l.train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
    devices)

这样就完成了！

总之我们可以针对下游任务对BERT进行微调，相当于预训练BERT模型在微调过程中已经成为了下游模型的一部分。