标签: bert-language-model

众所周知，BERT模型的词嵌入能力，它可能比word2vec和任何其他模型都要好。

我想创建一个BERT词嵌入模型来生成同义词或相似的单词。就像我们在Gensim Word2Vec. 我想将 Gensim 的方法创建model.most_similar()到 BERT 词嵌入中。

我对此进行了很多研究，似乎可以做到这一点，但问题是它仅以数字形式显示嵌入，无法从中获取实际的单词。有人可以帮我解决这个问题吗？

我正在尝试使用 BERT 预训练模型进行多类分类（3 类）。这是我使用该模型的函数，还添加了一些额外的功能：

def create_model(max_seq_len, bert_ckpt_file):

  with tf.io.gfile.GFile(bert_config_file, "r") as reader:
      bc = StockBertConfig.from_json_string(reader.read())
      bert_params = map_stock_config_to_params(bc)
      bert_params.adapter_size = None
      bert = BertModelLayer.from_params(bert_params, name="bert")
        
  input_ids = keras.layers.Input(shape=(max_seq_len, ), dtype='int32', name="input_ids")
  bert_output = bert(input_ids)

  print("bert shape", bert_output.shape)

  cls_out = keras.layers.Lambda(lambda seq: seq[:, 0, :])(bert_output)
  cls_out = keras.layers.Dropout(0.5)(cls_out)
  logits = keras.layers.Dense(units=768, activation="tanh")(cls_out)
  logits = keras.layers.Dropout(0.5)(logits)
  logits = keras.layers.Dense(units=len(classes), activation="softmax")(logits)

  model = keras.Model(inputs=input_ids, outputs=logits)
  model.build(input_shape=(None, max_seq_len))

  load_stock_weights(bert, bert_ckpt_file)
        
  return model

现在，当我尝试调用该函数时，出现错误。参数值有 max_seq_len = 128，bert_ckpt_file = bert 检查点文件。

model = create_model(data.max_seq_len, bert_ckpt_file)

我收到以下错误： …

我刚刚在由电子商务网站的产品和标签（部门）组成的数据集上训练了 BERT 模型。这是一个多类问题。我使用 BertForSequenceClassification 来预测每个产品的部门。我将其分为训练和评估，我使用了 pytorch 的数据加载器，并且我得到了很好的分数，没有过度拟合。

现在我想在新的数据集上尝试它，以检查它如何处理看不见的数据。但我无法加载模型并应用于新数据集。我收到以下错误：

RuntimeError: Error(s) in loading state_dict for BertForSequenceClassification:
    size mismatch for classifier.weight: copying a param with shape torch.Size([59, 1024]) from checkpoint, the shape in current model is torch.Size([105, 1024]).
    size mismatch for classifier.bias: copying a param with shape torch.Size([59]) from checkpoint, the shape in current model is torch.Size([105]).

我发现问题可能是两个数据集之间的标签大小不匹配。我进行了一些搜索，找到了使用ignore_mismatched_sizes=Trueas 和 argument for 的建议pretrained。但我不断收到同样的错误。

这是我尝试预测看不见的数据时的代码的一部分：

from transformers import BertForSequenceClassification

# Just right before the actual usage select your hardware
device …

我正在复制此页面的代码。我已将 BERT 模型下载到本地系统并获取句子嵌入。

我有大约 500,000 个句子需要句子嵌入，这需要花费很多时间。

1. 有没有办法加快这个过程？
2. 发送一批句子而不是一次发送一个句子会有帮助吗？

。

#!pip install transformers
import torch
import transformers
from transformers import BertTokenizer, BertModel
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased',
                                  output_hidden_states = True, # Whether the model returns all hidden-states.
                                  )

# Put the model in "evaluation" mode, meaning feed-forward operation.
model.eval()

corpa=["i am a boy","i live in a city"]



storage=[]#list to store all embeddings

for text in corpa:
    # Add the special tokens.
    marked_text = "[CLS] " + text + …

我正在使用预训练的 BERT 句子转换器模型（如https://www.sbert.net/docs/training/overview.html中所述）来获取句子的嵌入。

我想微调这些预先训练的嵌入，并且我按照上面链接的教程中的说明进行操作。根据本教程，您可以通过向预训练模型提供句子对和指示一对句子之间相似性得分的标签得分来微调预训练模型。据我了解，这种微调是使用下图所示的架构进行的：

首先使用 BERT 模型对一对中的每个句子进行编码，然后“池”层聚合（通常通过取平均值）Bert 层生成的单词嵌入，为每个句子生成单个嵌入。在最后一步中计算两个句子嵌入的余弦相似度，并与标签分数进行比较。

我的问题是 - 使用给定架构微调模型时正在优化哪些参数？是只微调BERT模型最后一层的参数吗？通过查看教程中显示的用于微调模型的代码示例，我并不清楚这一点。

在通过 BERT 传递我的代币之前，我想对它们的嵌入（嵌入查找层的结果）执行一些处理。HuggingFace BERT TensorFlow 实现允许我们使用以下方式访问嵌入查找的输出：

import tensorflow as tf
from transformers import BertConfig, BertTokenizer, TFBertModel

bert_tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

input_ids = tf.constant(bert_tokenizer.encode("Hello, my dog is cute", add_special_tokens=True))[None, :]
attention_mask = tf.stack([tf.ones(shape=(len(sent),)) for sent in input_ids])
token_type_ids = tf.stack([tf.ones(shape=(len(sent),)) for sent in input_ids])

config = BertConfig.from_pretrained('bert-base-uncased', output_hidden_states=True)
bert_model = TFBertModel.from_pretrained('bert-base-uncased', config=config)

result = bert_model(inputs={'input_ids': input_ids, 
                            'attention_mask': attention_mask, 
                            'token_type_ids': token_type_ids})
inputs_embeds = result[-1][0]  # output of embedding lookup

随后，可以inputs_embeds使用以下方法处理并将其作为输入发送到同一模型：

inputs_embeds = process(inputs_embeds)  # some processing on inputs_embeds done here …

我试图了解 merge.txt 文件在 HuggingFace 库中的 RoBERTa 模型的分词器中推断出什么。然而，他们的网站上没有提及此事。任何帮助表示赞赏。

背景：

遵循这个问题，当使用 bert 对序列进行分类时，模型使用表示分类任务的“[CLS]”标记。据该论文称：

每个序列的第一个标记始终是一个特殊的分类标记（[CLS]）。与该标记对应的最终隐藏状态用作分类任务的聚合序列表示。

查看 Huggingfaces 存储库，他们的 BertForSequenceClassification 使用 bert pooler 方法：

class BertPooler(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
        self.activation = nn.Tanh()

    def forward(self, hidden_states):
        # We "pool" the model by simply taking the hidden state corresponding
        # to the first token.
        first_token_tensor = hidden_states[:, 0]
        pooled_output = self.dense(first_token_tensor)
        pooled_output = self.activation(pooled_output)
        return pooled_output

我们可以看到他们采用第一个标记（CLS）并将其用作整个句子的表示。具体来说，他们执行的操作hidden_states[:, 0]看起来很像从每个状态中获取第一个元素，而不是获取第一个标记隐藏状态？

我的问题：

我不明白的是他们如何将整个句子的信息编码到这个标记中？CLS 标记是一个常规标记，它有自己的嵌入向量来“学习”句子级别表示吗？为什么我们不能只使用隐藏状态的平均值（编码器的输出）并用它来分类？

编辑：经过一番思考：因为我们使用 CLS 令牌隐藏状态来预测，所以 CLS 令牌嵌入是否正在接受分类任务的训练，因为这是用于分类的令牌（因此是导致错误的主要因素）哪个会传播到它的权重？）

我正在尝试解决 10 个类别的多标签分类任务，其中相对平衡的训练集由约 25K 样本组成，评估集由约 5K 样本组成。

我正在使用拥抱脸：

model = transformers.BertForSequenceClassification.from_pretrained(...

并获得相当不错的结果（ROC AUC = 0.98）。

然而，我目睹了一些奇怪的行为，我似乎无法理解 -

我添加以下代码行：

for param in model.bert.parameters():
    param.requires_grad = False

同时确保学习模型的其他层，即：

[param[0] for param in model.named_parameters() if param[1].requires_grad == True]
gives
['classifier.weight', 'classifier.bias']

像这样配置时训练模型会产生一些令人尴尬的糟糕结果（ROC AUC = 0.59）。

我的假设是，开箱​​即用的预训练 BERT 模型（无需任何微调）应该作为分类层相对较好的特征提取器。那么，我到底哪里做错了呢？

我正在尝试在 Colab 云 GPU 上使用 HuggingFace 转换器库训练 NER 模型，对其进行 pickle 并将模型加载到我自己的 CPU 上以进行预测。

代码

模型如下：

from transformers import BertForTokenClassification

model = BertForTokenClassification.from_pretrained(
    "bert-base-cased",
    num_labels=NUM_LABELS,
    output_attentions = False,
    output_hidden_states = False
)

我正在使用此代码片段将模型保存在 Colab 上

import torch

torch.save(model.state_dict(), FILENAME)

然后使用将其加载到我的本地CPU上

# Initiating an instance of the model type

model_reload = BertForTokenClassification.from_pretrained(
    "bert-base-cased",
    num_labels=len(tag2idx),
    output_attentions = False,
    output_hidden_states = False
)

# Loading the model
model_reload.load_state_dict(torch.load(FILENAME, map_location='cpu'))
model_reload.eval()

用于标记文本并进行实际预测的代码片段在 Colab GPU 笔记本实例和我的 CPU 笔记本实例上都是相同的。

预期行为

经过 GPU 训练的模型行为正确，并且可以完美地对以下标记进行分类：

O       [CLS]
O       Good …