我想使用 BertForMaskedLM 或 BertModel 来计算句子的困惑度，所以我编写了这样的代码：

import numpy as np\nimport torch\nimport torch.nn as nn\nfrom transformers import BertTokenizer, BertForMaskedLM\n# Load pre-trained model (weights)\nwith torch.no_grad():\n    model = BertForMaskedLM.from_pretrained(\'hfl/chinese-bert-wwm-ext\')\n    model.eval()\n    # Load pre-trained model tokenizer (vocabulary)\n    tokenizer = BertTokenizer.from_pretrained(\'hfl/chinese-bert-wwm-ext\')\n    sentence = "\xe6\x88\x91\xe4\xb8\x8d\xe4\xbc\x9a\xe5\xbf\x98\xe8\xae\xb0\xe5\x92\x8c\xe4\xbd\xa0\xe4\xb8\x80\xe8\xb5\xb7\xe5\xa5\x8b\xe6\x96\x97\xe7\x9a\x84\xe6\x97\xb6\xe5\x85\x89\xe3\x80\x82"\n    tokenize_input = tokenizer.tokenize(sentence)\n    tensor_input = torch.tensor([tokenizer.convert_tokens_to_ids(tokenize_input)])\n    sen_len = len(tokenize_input)\n    sentence_loss = 0.\n\n    for i, word in enumerate(tokenize_input):\n        # add mask to i-th character of the sentence\n        tokenize_input[i] = \'[MASK]\'\n        mask_input = torch.tensor([tokenizer.convert_tokens_to_ids(tokenize_input)])\n\n        output = model(mask_input)\n\n        prediction_scores = output[0]\n        softmax = nn.Softmax(dim=0)\n …

我有两个关于如何使用 Transformers 的 Tensorflow 实现进行文本分类的问题。

• 首先，似乎人们大多只使用编码器层来完成文本分类任务。然而，编码器层为每个输入词生成一个预测。根据我对transformers的理解，每次到encoder的输入都是输入句子中的一个词。然后，使用当前输入词计算注意力权重和输出。我们可以对输入句子中的所有单词重复这个过程。因此，我们最终会得到输入句子中每个单词的（注意力权重、输出）对。那是对的吗？那么你将如何使用这些对来执行文本分类？
• 其次，基于这里的 Transformer 的 Tensorflow 实现，他们将整个输入句子嵌入到一个向量中，并将一批这些向量馈送到 Transformer。但是，根据我从The Illustrated Transformer中学到的知识，我希望输入是一批单词而不是句子

谢谢！

根据语言模型获得标记的概率相对容易，如下面的片段所示。您可以获取模型的输出，将自己限制在屏蔽标记的输出，然后在输出向量中找到您请求的标记的概率。然而，这仅适用于单标记词，例如本身在标记器词汇表中的词。当词汇表中不存在某个单词时，分词器会将其分成它确实知道的部分（参见示例底部）。但是由于输入的句子只有一个被屏蔽的位置，并且请求的标记比这个多，我们如何得到它的概率呢？最终，我正在寻找一种解决方案，无论一个单词有多少个子词单元，它都可以工作。

在下面的代码中，我添加了许多注释来解释正在发生的事情，以及打印出打印语句的给定输出。您会看到预测诸如“爱”和“恨”之类的标记很简单，因为它们位于标记器的词汇表中。然而，'reprimand' 不是，所以它不能在单个掩码位置预测 - 它由三个子词单元组成。那么我们如何在蒙面位置预测“谴责”呢？

from transformers import BertTokenizer, BertForMaskedLM
import torch

# init model and tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')
model.eval()
# init softmax to get probabilities later on
sm = torch.nn.Softmax(dim=0)
torch.set_grad_enabled(False)

# set sentence with MASK token, convert to token_ids
sentence = f"I {tokenizer.mask_token} you"
token_ids = tokenizer.encode(sentence, return_tensors='pt')
print(token_ids)
# tensor([[ 101, 1045,  103, 2017,  102]])
# get the position of the masked token
masked_position = (token_ids.squeeze() == tokenizer.mask_token_id).nonzero().item()

# forward
output …

我早些时候发布了这个问题。我想嵌入类似于这个youtube视频，时间 33 分钟以后。

1）我不认为我从CLS令牌中获得的嵌入与 YouTube 视频中显示的相似。我试图执行语义相似性并得到了可怕的结果。有人可以确认我得到的嵌入是否与视频的 35.27 标记中提到的嵌入相似？

2）如果上述问题的答案是“不相似”，那么我如何使用我编写的代码获得我正在寻找的嵌入？

3）如果第一个问题的答案是“它们很相似”，那么为什么我会得到可怕的结果？我需要使用更多数据进行微调吗？

更新 1

我用来微调的代码如下。它来自这个页面。对该代码进行了很少的更改以返回CLS嵌入。这些变化是基于对我的问题的回答

train_InputExamples = train2.apply(lambda x: run_classifier.InputExample(guid=None, # Globally unique ID for bookkeeping, unused in this example
                                                                   text_a = x[DATA_COLUMN], 
                                                                   text_b = None, 
                                                                   label = x[LABEL_COLUMN]), axis = 1)

"""
test_InputExamples = test2.apply(lambda x: run_classifier.InputExample(guid=None, 
                                                                   text_a = x[DATA_COLUMN], 
                                                                   text_b = None, 
                                                                   label = x[LABEL_COLUMN]), axis = 1)
"""


# In[17]:


# This is a path to an uncased …

我想使用spacy's pretrained BERT 模型进行文本分类，但我对cased/uncased模型有点困惑。我在某处读到cased模型应该只在字母大小写有可能对任务有帮助的情况下使用。在我的具体情况下：我正在处理德语文本。在德语中，所有名词都以大写字母开头。所以，我认为，（如果我错了，请纠正我）这是cased必须使用模型的确切情况。（在 中也没有uncased适用于德语的模型spacy）。

但是在这种情况下必须对数据做什么？我应该（在预处理火车数据时）保持原样（我的意思是不使用该.lower()功能）还是没有任何区别？

我正在使用 HuggingFace Transformers BERT 模型，我想使用 ormean函数计算句子中标记的摘要向量（也称为嵌入） max。复杂的是，有些标记是[PAD]，所以我想在计算平均值或最大值时忽略这些标记的向量。

这是一个例子。我最初实例化 aBertTokenizer和 a BertModel：

import torch
import transformers
from transformers import AutoTokenizer, AutoModel

transformer_name = 'bert-base-uncased'

tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)

model = AutoModel.from_pretrained(transformer_name)

然后，我将一些句子输入到分词器中，然后input_ids退出attention_mask。值得注意的是，attention_mask值 0 意味着该令牌是[PAD]我可以忽略的。

sentences = ['Deep learning is difficult yet very rewarding.',
             'Deep learning is not easy.',
             'But is rewarding if done right.']
tokenizer_result = tokenizer(sentences, max_length=32, padding=True, return_attention_mask=True, return_tensors='pt')

input_ids = tokenizer_result.input_ids
attention_mask …

我正在关注这个使用 BERT 和Huggingface库编写情感分析分类器的教程，我有一个非常奇怪的行为。当使用示例文本尝试 BERT 模型时，我得到一个字符串而不是隐藏状态。这是我正在使用的代码：

import transformers
from transformers import BertModel, BertTokenizer

print(transformers.__version__)

PRE_TRAINED_MODEL_NAME = 'bert-base-cased'
PATH_OF_CACHE = "/home/mwon/data-mwon/paperChega/src_classificador/data/hugingface"

tokenizer = BertTokenizer.from_pretrained(PRE_TRAINED_MODEL_NAME,cache_dir = PATH_OF_CACHE)

sample_txt = 'When was I last outside? I am stuck at home for 2 weeks.'

encoding_sample = tokenizer.encode_plus(
  sample_txt,
  max_length=32,
  add_special_tokens=True, # Add '[CLS]' and '[SEP]'
  return_token_type_ids=False,
  padding=True,
  truncation = True,
  return_attention_mask=True,
  return_tensors='pt',  # Return PyTorch tensors
)

bert_model = BertModel.from_pretrained(PRE_TRAINED_MODEL_NAME,cache_dir = PATH_OF_CACHE)


last_hidden_state, pooled_output = bert_model(
  encoding_sample['input_ids'],
  encoding_sample['attention_mask']
) …

我正在尝试构建图中所示的模型：

transformers我通过以下方式从 HuggingFace 获得了预训练的 BERT 和相应的分词器：

from transformers import AutoTokenizer, TFBertModel
model_name = "dbmdz/bert-base-italian-xxl-cased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
bert = TFBertModel.from_pretrained(model_name)

该模型将被输入一系列意大利推文，并需要确定它们是否具有讽刺意味。

我在构建模型的初始部分时遇到问题，该部分获取输入并将其提供给分词器，以获得可以提供给 BERT 的表示。

我可以在模型构建上下文之外做到这一点：

my_phrase = "Ciao, come va?"
# an equivalent version is tokenizer(my_phrase, other parameters)
bert_input = tokenizer.encode(my_phrase, add_special_tokens=True, return_tensors='tf', max_length=110, padding='max_length', truncation=True) 
attention_mask = bert_input > 0
outputs = bert(bert_input, attention_mask)['pooler_output']

但我在构建执行此操作的模型时遇到了麻烦。以下是构建此类模型的代码（问题出在前 4 行）：

def build_classifier_model():
  text_input = tf.keras.layers.Input(shape=(), dtype=tf.string, name='text')
  encoder_inputs = tokenizer(text_input, return_tensors='tf', add_special_tokens=True, max_length=110, padding='max_length', truncation=True)
  outputs = bert(encoder_inputs)
  net = outputs['pooler_output'] …

我有几个屏蔽语言模型（主要是 Bert、Roberta、Albert、Electra）。我还有一个句子数据集。我怎样才能得到每个句子的困惑度？

从这里的Huggingface 文档中，他们提到困惑度“对于像 BERT 这样的屏蔽语言模型来说没有很好的定义”，尽管我仍然看到人们以某种​​方式计算它。

例如，在这个SO问题中，他们使用函数计算它

def score(model, tokenizer, sentence,  mask_token_id=103):\n  tensor_input = tokenizer.encode(sentence, return_tensors=\'pt\')\n  repeat_input = tensor_input.repeat(tensor_input.size(-1)-2, 1)\n  mask = torch.ones(tensor_input.size(-1) - 1).diag(1)[:-2]\n  masked_input = repeat_input.masked_fill(mask == 1, 103)\n  labels = repeat_input.masked_fill( masked_input != 103, -100)\n  loss,_ = model(masked_input, masked_lm_labels=labels)\n  result = np.exp(loss.item())\n  return result\n\nscore(model, tokenizer, \'\xe6\x88\x91\xe7\x88\xb1\xe4\xbd\xa0\') # returns 45.63794545581973\n

但是，当我尝试使用我得到的代码时TypeError: forward() got an unexpected keyword argument \'masked_lm_labels\'。

我用我的几个模型尝试过：

from transformers import pipeline, BertForMaskedLM, BertForMaskedLM, AutoTokenizer, RobertaForMaskedLM, …

我正在尝试安装 bertopic 并收到此错误：

 pip install bertopic

 

    Collecting bertopic
>           Using cached bertopic-0.11.0-py2.py3-none-any.whl (76 kB)
>         Collecting hdbscan>=0.8.28
>           Using cached hdbscan-0.8.28.tar.gz (5.2 MB)
>           Installing build dependencies: started
>           Installing build dependencies: finished with status 'done'
>           Getting requirements to build wheel: started
>           Getting requirements to build wheel: finished with status 'done'
>           Preparing metadata (pyproject.toml): started
>           Preparing metadata (pyproject.toml): finished with status 'done'
>         Requirement already satisfied: tqdm>=4.41.1 in c:\users\martin kunth\anaconda3\lib\site-packages (from bertopic) (4.62.3)
>         Collecting umap-learn>=0.5.0 …