[人工智能] 使用pytorch获取bert词向量将字符转换成词向量

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 人工智能 -> 使用pytorch获取bert词向量将字符转换成词向量 -> 正文阅读

[人工智能]使用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
)
因为我选择了参数output_all_encoded_layers=True，12层Transformer的结果全返回了，存在第一个列表中，每个encoder_output的大小为[batch_size, sequence_length, hidden_size];
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句子的信息了。
如果你用不上所有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=<AddmmBackward>)