NLP面试题准备

基础知识篇

（1）简单介绍一下BERT，BERT的原理是什么？

BERT 来自 Google 的论文，BERT 是“Bidirectional Encoder Representations from Transformers”的首字母缩写，，并且其设计了两个任务来预训练

第一个任务是MASK LM的方式来训练模型。即随机选择一些词用MASK字符进行掩码。让模型去学习并根据上下文去预测这些被掩码的词。
【BERT 模型的这个预训练过程其实就是在模仿我们学语言的过程，思想来源于完形填空的任务】
第二个任务是预测两段文本是否为连续的文本，引入这个任务可以更好地让模型学到连续的文本片段之间的关系【模型中的CLS就是输出是否连续的文本】

BERT 只使用了 Transformer 的 Encoder 模块。
现有两种BERT模型，
一个是12层的BERT模型， 隐藏层有768维度，自注意力头12个，参数110M
一个是24层的BERT模型，隐藏层有1024维度，自注意力头16个，参数340M
【需要注意的是，与 Transformer 本身的 Encoder 端相比，BERT 的 Transformer Encoder 端输入的向量表示，多了 Segment Embeddings】

BERT 有什么局限性？

BERT 在第一个预训练阶段，假设句子中多个单词被 Mask 掉，这些被 Mask 掉的单词之间没有任何关系，是条件独立的，然而有时候这些单词之间是有关系的，比如”New York is a city”，假设我们 Mask 住”New”和”York”两个词，那么给定”is a city”的条件下”New”和”York”并不独立，因为”New York”是一个实体，看到”New”则后面出现”York”的概率要比看到”Old”后面出现”York”概率要大得多。。

BERT 的在预训练时会出现特殊的[MASK]，但是它在下游的 fine-tune 中不会出现，这就出现了预训练阶段和 fine-tune 阶段不一致的问题。其实这个问题对最后结果产生多大的影响也是不够明确的，因为后续有许多 BERT 相关的预训练模型仍然保持了[MASK]标记，也取得了很大的结果
【我做过这个实验，为了解决预训练阶段和 fine-tune 阶段不一致的问题，采取 相似词替换+Ngram的策略；并在OCNIL、AFQMC、IFLYTEK、TNEWS、CMNLI这几个传统数据集测试效果】
验记录的数据表明，加入ngrams策略的效果在这几个任务数据集上没有明显的提升；但加入相似词的策略的时候，效果却显著的下降。具体实验数据可以看下面的附件。

我在做相似词替换的时候，并没有像论文中使用的Synonym包；而是用自己的大概20G的语料库来训练一个词向量，再提取相似词；在面临相似词跟原词长度不一致的问题，是跳转到下一个长度一致的相似词来解决的。

（2）其他的模型 - ELMO 和RoBERTa的原理是什么

BERT 比 ELMo 效果好？ELMo 和 BERT 的区别是什么

（3）LSTM有哪三个门，LSTM解决了RNN的什么问题？为什么

（4）对Attention的理解

（5）BERT用字粒度和词粒度的优缺点有哪些

（6）BERT的Encoder与Decoder掩码有什么区别？

（7）BERT用的是Tranformer里面的encoder还是decoder？

（8）BERT和BiLSTM的区别有哪些

（9）BERT的softmax掩码怎么做的，为什么这么做

（10）NSP任务为什么没有用

（11）Transformer里面的position encoding怎么做的？

模型训练篇

（1）深度学习单卡的训练，怎么修改代码变成多卡

##（1）先看看机器有多少张卡
nvidia-smi
##（2）然后模型用DataParallel包装一下：
device_ids = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 10卡机
model = torch.nn.DataParallel(model, device_ids=device_ids) # 指定要用到的设备
model = model.cuda(device=device_ids[0]) # 模型加载到设备0

##数据也指定那台机器
X_train, y_train = X_train.cuda(device=device_ids[0]), y_train.cuda(device=device_ids[0])

这里只需要用device_ids[0]定义一个样式就好，不需要逐卡指定设备。但没这一步会报错
下面是一个小的demo来理解一下

import torch
from torchvision import datasets, transforms
import torchvision
from tqdm import tqdm

device_ids = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 可用GPU
BATCH_SIZE = 64

transform = transforms.Compose([transforms.ToTensor()])
data_train = datasets.MNIST(root = "./data/",
                            transform=transform,
                            train=True,
                            download=True)
data_test = datasets.MNIST(root="./data/",
                           transform=transform,
                           train=False)
 
data_loader_train = torch.utils.data.DataLoader(dataset=data_train,
                                                # 单卡batch size * 卡数
                                                batch_size=BATCH_SIZE * len(device_ids),
                                                shuffle=True,
                                                num_workers=2)
 
data_loader_test = torch.utils.data.DataLoader(dataset=data_test,
                                               batch_size=BATCH_SIZE * len(device_ids),
                                               shuffle=True,
                                               num_workers=2)

class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = torch.nn.Sequential(
        torch.nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1),
        torch.nn.ReLU(),
        torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
        torch.nn.ReLU(),
        torch.nn.MaxPool2d(stride=2, kernel_size=2),
    )
        self.dense = torch.nn.Sequential(
            torch.nn.Linear(14 * 14 * 128, 1024),
            torch.nn.ReLU(),
            torch.nn.Dropout(p=0.5),
            torch.nn.Linear(1024, 10)
    )
    def forward(self, x):
        x = self.conv1(x)
        x = x.view(-1, 14 * 14 * 128)
        x = self.dense(x)
        return x
model = Model()
# 指定要用到的设备
model = torch.nn.DataParallel(model, device_ids=device_ids)
# 模型加载到设备0
model = model.cuda(device=device_ids[0])
 
cost = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())
from time import sleep
n_epochs = 50
for epoch in range(n_epochs):
    running_loss = 0.0
    running_correct = 0
    print("Epoch {}/{}".format(epoch, n_epochs))
    print("-"*10)
    for data in tqdm(data_loader_train):
        X_train, y_train = data
        # 指定设备0
        X_train, y_train = X_train.cuda(device=device_ids[0]), y_train.cuda(device=device_ids[0])
        outputs = model(X_train)
        _,pred = torch.max(outputs.data, 1)
        optimizer.zero_grad()
        loss = cost(outputs, y_train)
 
        loss.backward()
        optimizer.step()
        running_loss += loss.data.item()
        running_correct += torch.sum(pred == y_train.data)
    testing_correct = 0
    for data in data_loader_test:
        X_test, y_test = data
        # 指定设备1
        X_test, y_test = X_test.cuda(device=device_ids[0]), y_test.cuda(device=device_ids[0])
        outputs = model(X_test)
        _, pred = torch.max(outputs.data, 1)
        testing_correct += torch.sum(pred == y_test.data)
torch.save(model.state_dict(), "model_parameter.pkl")