BERT-Pytorch demo初探

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

概述

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

1. pytorch-pretrained-BERT的基本框架和使用
2. 如何利用BERT将句子转为词向量
3. 如何使用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. 如何批量处理（将文件中的句子转为词向量）
2. 获得的词向量结构如何，是模型的哪个部分的输出

批量处理

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。

 

来源：CSDN

作者：kyle1314608

链接：https://blog.csdn.net/kyle1314608/article/details/100589472