BERT-Pytorch demo初探

https://zhuanlan.zhihu.com/p/50773178

概述

本文基于 pytorch-pretrained-BERT(huggingface)版本的复现，探究如下几个问题：

pytorch-pretrained-BERT的基本框架和使用
如何利用BERT将句子转为词向量
如何使用BERT训练模型（针对SQuAD数据集的问答模型，篇幅问题，可能下篇再写）

因为已经有很多文章对BERT的结构和效果做了详尽的介绍，所以对于模型的效果和结构就不在这里赘述了。

基本框架和使用

环境

首先，利用pip安装包：

1    pip install pytorch-pretrained-bert

这种安装方法可能会导致一个编码问题，具体细节可以参考这里。作者已经把这个错误改了过来，但是没有发布新的版本（当前版本为0.1.2），因此需要我们先从github上下载源码，然后安装：

1    pip install [--editable] .

结构

Google提供了6种预训练的模型，具体细节如下：

bert-base-uncased: 12-layer, 768-hidden, 12-heads, 110M parameters
bert-large-uncased: 24-layer, 1024-hidden, 16-heads, 340M parameters
bert-base-cased: 12-layer, 768-hidden, 12-heads , 110M parameters
bert-base-multilingual: 102 languages, 12-layer, 768-hidden, 12-heads, 110M parameters
bert-base-chinese: Chinese Simplified and Traditional, 12-layer, 768-hidden, 12-heads, 110M parameters

作者对于每个预训练的模型都提供了6个model类和3个tokenizer类供我们使用。具体的模型简介和参数可以参照这里README中pytorch model和Tokenizer部分。

1    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

2    model = BertModel.from_pretrained('bert-base-uncased')

初始化

上面就是对model和tokenizer进行初始化的代码，“BertTokenizer”和“BertModel”可以替换为自己需要的模型和分词器，后面函数的参数对应6中预训练的模型。由于是预训练的模型，所以肯定是要下模型和词表的，作者把资源放到了亚马逊的云上，链接写在了一个环境变量里，如果第一次使用，要提前下载，下载后的文件存放在cache文件夹：~/.pytorch_pretrained_bert/下。

1    PRETRAINED_MODEL_ARCHIVE_MAP = {

2        'bert-base-uncased': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased.tar.gz",

3        'bert-large-uncased': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-large-uncased.tar.gz",

4        'bert-base-cased': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-cased.tar.gz",

5        'bert-base-multilingual': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-multilingual.tar.gz",

6        'bert-base-chinese': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-chinese.tar.gz",

7    }

不知道其他人下载情况如何，反正在我这边利用requeset去下就很慢，所以肯定是想提前下好，然后放过去的。这是我踩的一个大坑。在Folx上下好模型后，我欣喜的关掉了那个贼慢的python程序（虽然显示已经下了一半了），一波美滋滋的拷贝之后，发现并没有卵用，它并没有识别我下好的文件，又重新开始request了。只能先让它慢悠悠的下着，看看下下来的东西是啥，然后去读读源码。

后来发现大概的流程是这样的，它会把文件先下到一个tmp文件夹中，然后复制到cache文件夹下。（但我已经把资源放到里面了啊，并无卵用！）在读代码的同时，tokenizer的东西下好了，经过代码和文件的双重验证：它会把链接名和一堆烂七八糟的tag加起来做MD5，然后作为文件名，过程很复杂，看不太懂。

经过再一次深入的阅读，我发现了它大概的流程：它会先判断 from_pretrained 函数的参数，如果是上文中 PRETRAINED_MODEL_ARCHIVE_MAP 已有的，就会去cache里找；如果不是，就会判断它是不是一个路径，会在这个路径下找需要的文件，一个config文件和一个bin文件，正好和我们下载的文件对应。

 1    """

 2    Params:

 3    pretrained_model_name: either:

 4    - a str with the name of a pre-trained model to load selected in the list of:

 5    . `bert-base-uncased`

 6    . `bert-large-uncased`

 7    . `bert-base-cased`

 8    . `bert-base-multilingual`

 9    . `bert-base-chinese`

10    - a path or url to a pretrained model archive containing:

11    . `bert_config.json` a configuration file for the model

12    . `pytorch_model.bin` a PyTorch dump of a BertForPreTraining instance

13    *inputs, **kwargs: additional input for the specific Bert class

14    (ex: num_labels for BertForSequenceClassification)

15    """

16

接下来的操作就简单了，直接贴代码：

1    UNCASED='./bert-base-uncased' # your path for model and vocab

2    VOCAB='bert-base-uncased-vocab.txt'

3    tokenizer=BertTokenizer.from_pretrained(os.path.join(UNCASED,VOCAB))

4    model = BertModel.from_pretrained(UNCASED)

需要注意的是，Tokenizer需要的是词表，我们看到的model需要的是文件，词表的链接如下：

1    PRETRAINED_VOCAB_ARCHIVE_MAP = {

2        'bert-base-uncased': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-vocab.txt",

3        'bert-large-uncased': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-large-uncased-vocab.txt",

4        'bert-base-cased': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-cased-vocab.txt",

5        'bert-base-multilingual': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-multilingual-vocab.txt",

6        'bert-base-chinese': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-chinese-vocab.txt",

7    }

利用BERT获取词向量

作者其实在README中的 Usage给出了将句子转为词向量的demo，但是有点简略。同时，作者在extract_features.py中提供了详细的使用方法，接下来的内容就是对这里面的代码进行解读了。

因为Usage中的注释已经很详细了，所以接下来重点关注两个点：

如何批量处理（将文件中的句子转为词向量）
获得的词向量结构如何，是模型的哪个部分的输出

批量处理

1    layer_indexes = [int(x) for x in args.layers.split(",")]

2    tokenizer = BertTokenizer.from_pretrained(args.bert_model)

3    examples = read_examples(args.input_file)

4    features = convert_examples_to_features(

5        examples=examples, seq_length=args.max_seq_length, tokenizer=tokenizer)

6    unique_id_to_feature = {}

7    for feature in features:

8        unique_id_to_feature[feature.unique_id] = feature

9    model = BertModel.from_pretrained(args.bert_model)

其实处理的流程很简单，就是读入文件，然后将其转为需要的格式（InputFeatures类），然后利用模型进行处理。重点在于文件读取的函数中：

 1    def read_examples(input_file):

 2        """Read a list of `InputExample`s from an input file."""

 3        examples = []

 4        unique_id = 0

 5        with open(input_file, "r") as reader:

 6            while True:

 7                line = convert_to_unicode(reader.readline())

 8                if not line:

 9                    break

10                line = line.strip()

11                text_a = None

12                text_b = None

13                m = re.match(r"^(.*) \|\|\| (.*)$", line)

14                if m is None:

15                    text_a = line

16                else:

17                    text_a = m.group(1)

18                    text_b = m.group(2)

19                examples.append(

20                    InputExample(unique_id=unique_id, text_a=text_a, text_b=text_b))

21                unique_id += 1

22        return examples

最关键的部分就是13行的那个正则表达式，模型中对于文本会分成两部分，part A 和 part B。在这个函数中，将两个部分的文本以“ ||| ” 分割（注意前后有空格），所以文件中的每一行应该是“I love you ||| Hello world”这样。

词向量结构

 1    all_encoder_layers, _ = model(input_ids, token_type_ids=None, attention_mask=input_mask)

 2    all_encoder_layers = all_encoder_layers

 3

 4    for b, example_index in enumerate(example_indices):

 5        feature = features[example_index.item()]

 6        unique_id = int(feature.unique_id)

 7        # feature = unique_id_to_feature[unique_id]

 8        output_json = collections.OrderedDict()

 9        output_json["linex_index"] = unique_id

10        all_out_features = []

11        for (i, token) in enumerate(feature.tokens):

12            all_layers = []

13            for (j, layer_index) in enumerate(layer_indexes):

14                layer_output = all_encoder_layers[int(layer_index)].detach().cpu().numpy()

15                layer_output = layer_output[b]

16                layers = collections.OrderedDict()

17                layers["index"] = layer_index

18                layers["values"] = [

19                    round(x.item(), 6) for x in layer_output[i]

20                ]

21                all_layers.append(layers)

22                out_features = collections.OrderedDict()

23                out_features["token"] = token

24                out_features["layers"] = all_layers

25                all_out_features.append(out_features)

26                output_json["features"] = all_out_features

27                writer.write(json.dumps(output_json) + "\n")

19行得到的是一个list，长度为网络的层数，每个元素是[batch,sequence,embedding]的向量。

对于每个序列，序列中每个向量的token，分别获取它相应层（由参数arg.layers控制，本文中是最后四层）的编码。最后对于每个序列中的每个token会获取到[layer,dimension]大小的向量作为features。

巴特西