使用pytorch获取bert词向量 将字符转换成词向量

转载保存：

使用pytorch获取bert词向量_海蓝时见鲸_的博客-CSDN博客_获取bert词向量

pytorch-pretrained-bert简单使用_风吹草地现牛羊的马的博客-CSDN博客_pretrained pytorch

我的实现

源码：

from pytorch_pretrained_bert import BertModel, BertTokenizer
import numpy as np


# 加载bert的分词器
tokenizer = BertTokenizer.from_pretrained(  # 载入词典
    '/checkpoint_models/bert_checkpoint/bert-base-uncased-vocab.txt'
)
# 加载bert模型，这个路径文件夹下有bert_config.json配置文件和model.bin模型权重文件
bert = BertModel.from_pretrained(  # 
    '/checkpoint_models/bert_checkpoint/bert-base-uncased/'
)

tensor_label = torch.zeros([args.batch_size, 768])
print('tensor_label ori', tensor_label)
for i in range(args.batch_size):
    # 分词
    # label_tokens = tokenizer.tokenize('dog dog dog')
    label_tokens = tokenizer.tokenize(str(real_label[i]))  # 将字符转str
    # print("\\".join(tokens))
    
    # 获取词汇表索引
    indexed_tokens = torch.tensor(
        [tokenizer.convert_tokens_to_ids(label_tokens)])
    
    # 计算词向量
    with torch.no_grad():  # 仅测试，加速计算
        label_emb = bert(  # 输入有多少个单词就生成多少个
            indexed_tokens,  # 输出维度{[层数,batch号,单词号,特征层]}
            output_all_encoded_layers=False)[0][0]  # torch.Size([token_num, 768])
    
    # 根据bert的做法，对于多个单词，特征求和
    label_emb = label_emb.sum(dim=0)  # [token_num, 768]->[768]
    tensor_label[i] += label_emb

   
print('tensor_label then', tensor_label)

输出：

tensor_label ori tensor([[0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.],
        [0., 0., 0.,  ..., 0., 0., 0.]])
['rock beauty']
['cocktail shaker']
['bolete']
['komondor']
['cliff']
tensor_label then tensor([[ 1.6463, -0.4741, -3.8969,  ..., -1.1646,  0.4666, -0.2425],
        [ 0.4269, -1.4239, -0.8426,  ..., -2.0334,  2.6082,  1.9153],
        [ 0.9018, -0.7432, -1.7300,  ..., -0.0836,  4.3358,  2.2660],
        [ 2.7782, -0.2918, -0.4467,  ..., -1.0374,  1.5668,  2.3730],
        [ 1.4327, -1.0729,  2.3587,  ...,  0.4385,  4.0643,  0.7001]])

以下为源博客

本文主要为如何使用pytorch来获取bert词向量。

首先安装pytorch-pretrained-bert包：

pip install pytorch-pretrained-bert
然后加载预训练模型

from pytorch_pretrained_bert import BertTokenizer, BertModel, BertForMaskedLM
# Load pretrained model/tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')
 
如果是第一次使用，执行上述代码后程序会开始自动下载相应的模型，但是会耗费大量时间，因此最好事先下载好相应的模型，然后指定目录。

tokenizer = BertTokenizer.from_pretrained('data/cased_L-12_H-768_A-12') #改为自己存放模型的目录
model = BertModel.from_pretrained('data/cased_L-12_H-768_A-12')
如何下载模型：

Bert模型下载地址如下，根据自己的需求下载相应模型。

https://github.com/google-research/bert#pre-trained-models

该链接下载后的模型是支持tensorflow的而不是支持pytorch的，因此需要将其进行转化，生成pytorch_model.bin文件。

（也可以直接照pytorch_model.bin的链接下载，但是下载起来太慢了而且可能打不开，所有还是建议用上面的链接然后再转化）

详情可参考https://blog.csdn.net/weixin_41287060/article/details/105080705

转换完成之后，存放模型的目录下应有以下三个文件：

获取隐藏层向量

text = " the man went to the store "
tokenized_text = tokenizer.tokenize(text) #token初始化
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text) #获取词汇表索引
tokens_tensor = torch.tensor([indexed_tokens]) #将输入转化为torch的tensor
with torch.no_grad(): #禁用梯度计算 因为只是前向传播获取隐藏层状态，所以不需要计算梯度
    last_hidden_states = model(tokens_tensor)[0]
隐藏状态的四个维度（参考 Bert词向量指南）：

从输出可知，模型为每个单词输出了12个隐藏层向量，那么该如何利用这些隐藏层向量获取最终的词向量？

Bert作者利用不同的向量组合作为输入特征进行NER实验来测试这一点。

以下为通过最后四层的连接和求和来创建单词向量的示例

token_embeddings=[]
for token_i in range(len(tokenized_text)):
    hidden_layers=[]
    for layer_i in range(len(last_hidden_states)):
        vec=last_hidden_states[layer_i][0][token_i] #如果输入是单句不分块中间是0，因为只有一个维度，如果分块还要再遍历一次
        hidden_layers.append(vec)
    token_embeddings.append(hidden_layers)
concatenated_last_4_layers = [torch.cat((layer[-1], layer[-2], layer[-3], layer[-4]), 0) for layer in token_embeddings] #连接最后四层 [number_of_tokens, 3072]    
summed_last_4_layers = [torch.sum(torch.stack(layer)[-4:], 0) for layer in token_embeddings] #对最后四层求和 [number_of_tokens, 768]
 pytorch获取bert词向量的一些相关文章：

https://github.com/huggingface/transformers
https://blog.csdn.net/u011984148/article/details/99921480  （这个博主写得非常明白）
————————————————
版权声明：本文为CSDN博主「海蓝时见鲸_」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_42265325/article/details/107395914

转载自：9012年，该用bert打比赛了

从下载模型权重开始

# 切换到你的anaconda　gpu 环境
# source activate 你的conda环境名称
​
# 安装加载预训练模型＆权重的包
pip install pytorch-pretrained-bert

接着就是下载模型权重文件了，pytorch-pretrained-bert官方下载地址太慢了…，推荐去kaggle下载L-12_H-768-A-12 uncase版本，下载地址在这里，里面有两个文件，都下载下来，并把模型参数权重的文件bert-base-uncased解压出来，然后放在你熟悉的硬盘下即可。

加载模型试试

from pytorch_pretrained_bert import BertModel, BertTokenizer
import numpy as np
import torch

# 加载bert的分词器
tokenizer = BertTokenizer.from_pretrained('E:/Projects/bert-pytorch/bert-base-uncased-vocab.txt')
# 加载bert模型，这个路径文件夹下有bert_config.json配置文件和model.bin模型权重文件
bert = BertModel.from_pretrained('E:/Projects/bert-pytorch/bert-base-uncased/')

s = "I'm not sure, this can work, lol -.-"

tokens = tokenizer.tokenize(s)
print("\\".join(tokens))
# "i\\'\\m\\not\\sure\\,\\this\\can\\work\\,\\lo\\##l\\-\\.\\-"
# 是否需要这样做？
# tokens = ["[CLS]"] + tokens + ["[SEP]"]

ids = torch.tensor([tokenizer.convert_tokens_to_ids(tokens)])
print(ids.shape)
# torch.Size([1, 15])

result = bert(ids, output_all_encoded_layers=True)
print(result)

没问题，那么bert返回给我们了什么呢？

result = (
    [encoder_0_output, encoder_1_output, ..., encoder_11_output], 
    pool_output
)

1. 因为我选择了参数output_all_encoded_layers=True，12层Transformer的结果全返回了，存在第一个列表中，每个encoder_output的大小为[batch_size, sequence_length, hidden_size];
2. pool_out大小为[batch_size, hidden_size]，pooler层的输出在论文中描述为：
   which is the output of a classifier pretrained on top of the hidden state associated to the first character of the input (CLS) to train on the Next-Sentence task (see BERT’s paper).
   也就是说，取了最后一层Transformer的输出结果的第一个单词[cls]的hidden states，其已经蕴含了整个input句子的信息了。
3. 如果你用不上所有encoder层的输出，output_all_encoded_layers参数设置为Fasle，那么result中的第一个元素就不是列表了，只是encoder_11_output，大小为[batch_size, sequence_length, hidden_size]的张量，可以看作bert对于这句话的表示。

用bert微调我们的模型

将bert嵌入我们的模型即可。

class CustomModel(nn.Module):
    
    def __init__(self, bert_path, n_other_features, n_hidden):
        super().__init__()
        # 加载并冻结bert模型参数
        self.bert = BertModel.from_pretrained(bert_path)
        for param in self.bert.parameters():
            param.requires_grad = False
        self.output = nn.Sequential(
            nn.Dropout(0.2),
            nn.Linear(768 + n_other_features, n_hidden),
            nn.ReLU(),
            nn.Linear(n_hidden, 1)
        )
    def forward(self, seqs, features):
        _, pooled = self.bert(seqs, output_all_encoded_layers=False)
        concat = torch.cat([pooled, features], dim=1)
        logits = self.output(concat)
        return logits

测试:

s = "I'm not sure, this can work, lol -.-"
​
tokens = tokenizer.tokenize(s)
ids = torch.tensor([tokenizer.convert_tokens_to_ids(tokens)])
# print(ids)
# tensor([[1045, 1005, 1049, 2025, 2469, 1010, 2023, 2064, 2147, 1010, 8840, 2140,
#         1011, 1012, 1011]])
​
model = CustomModel('你的路径/bert-base-uncased/',10, 512)
outputs = model(ids, torch.rand(1, 10))
# print(outputs)
# tensor([[0.1127]], grad_fn=)