标签: transformer-model

我现在正在使用hibernate5.2.我想将结果转换为使用本机查询的映射,但是setResultTransformer不推荐使用.当我@todo develop a new approach to result transformers在方法中看到doc:那么使用NativeQuery结果转换器的新方法是什么？

这是代码,事实上不推荐使用setResultTransformer()

 NativeQuery nativeQuery = session.createNativeQuery(sql);
            for (int i = 0; i < params.length; i++)
            {
                nativeQuery.setParameter(i, params[i]);
            }
            List res = nativeQuery.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).list();

我有两个关于如何使用 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 …

我正在尝试遵循此代码，但在另一个数据集上：https://www.tensorflow.org/tutorials/text/transformer#encoder_layer 我需要编译和拟合模型。但是，我在运行时收到此错误；我不知道这是什么意思：

 Models passed to `fit` can only have `training` and the first argument in `call` as positional arguments, found: ['tar', 'enc_padding_mask', 'look_ahead_mask', 'dec_padding_mask'].

这是模型：

class Transformer(tf.keras.Model):
  def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, 
               target_vocab_size, pe_input, pe_target, rate=0.1,**kwargs,):
    super(Transformer, self).__init__(**kwargs)

    self.encoder = Encoder(num_layers, d_model, num_heads, dff, 
                           input_vocab_size, pe_input, rate)

    self.decoder = Decoder(num_layers, d_model, num_heads, dff, 
                           target_vocab_size, pe_target, rate)

    self.final_layer = tf.keras.layers.Dense(target_vocab_size)
  def get_config(self):

        config = super().get_config().copy()
        config.update({
            'dff':self.dff,
            'input_vocab_size':self.input_vocab_size,
            'target_vocab_size':self.target_vocab_size,
            'pe_input':self.pe_input,
            'pe_target':self.pe_target,
            #'vocab_size': self.vocab_size,
            'num_layers': self.num_layers,
            #'units': self.units,
            'd_model': …

pytorchatt_mask和key_padding_maskin的区别MultiHeadAttnetion是什么：

key_padding_mask – 如果提供，键中指定的填充元素将被注意力忽略。当给定一个二元掩码并且值为 True 时，注意力层上的相应值将被忽略。当给定字节掩码且值为非零时，将忽略注意力层上的相应值

attn_mask – 2D 或 3D 掩码，防止对某些位置的注意。将为所有批次广播 2D 掩码，而 3D 掩码允许为每个批次的条目指定不同的掩码。

提前致谢。

我正在尝试拥抱脸 gpt2 模型。我看过run_generation.py脚本，它会根据提示生成一系列令牌。我知道我们可以将 GPT2 用于 NLG。

在我的用例中，我希望（仅）确定给定提示后紧接的下一个单词的概率分布。理想情况下，这种分布将覆盖整个词汇。

例如，给定提示：“How are”，它应该给出一个概率分布，其中“you”或“they”具有一些高浮点值而其他词汇具有非常低的浮点值。

如何使用拥抱面部变压器做到这一点？如果不能拥抱脸，是否还有其他变压器模型可以做到这一点？

我正在尝试seq2seq使用 Transformer 模型。我的输入和输出是相同的形状（torch.Size([499, 128])其中 499 是序列长度，128 是特征数。

我的输入看起来像：

我的输出看起来像：

我的训练循环是：

    for batch in tqdm(dataset):
        optimizer.zero_grad()
        x, y = batch

        x = x.to(DEVICE)
        y = y.to(DEVICE)

        pred = model(x, torch.zeros(x.size()).to(DEVICE))

        loss = loss_fn(pred, y)
        loss.backward()
        optimizer.step()

我的模型是：

import math
from typing import final
import torch
import torch.nn as nn

class Reconstructor(nn.Module):
    def __init__(self, input_dim, output_dim, dim_embedding, num_layers=4, nhead=8, dim_feedforward=2048, dropout=0.5):
        super(Reconstructor, self).__init__()

        self.model_type = 'Transformer'
        self.src_mask = None
        self.pos_encoder = PositionalEncoding(d_model=dim_embedding, dropout=dropout)
        self.transformer = nn.Transformer(d_model=dim_embedding, nhead=nhead, dim_feedforward=dim_feedforward, …

通过 Huggingface 给出零样本分类任务，如下所示：

from transformers import pipeline
classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")

example_text = "This is an example text about snowflakes in the summer"
labels = ["weather", "sports", "computer industry"]
        
output = classifier(example_text, labels, multi_label=True)
output 
{'sequence': 'This is an example text about snowflakes in the summer',
'labels': ['weather', 'sports'],
'scores': [0.9780895709991455, 0.021910419687628746]}

我正在尝试提取 SHAP 值以生成基于文本的预测结果解释，如下所示：SHAP for Transformers

我已经根据上面的网址尝试了以下操作：

from transformers import AutoModelForSequenceClassification, AutoTokenizer, ZeroShotClassificationPipeline

model = AutoModelForSequenceClassification.from_pretrained('facebook/bart-large-mnli')
tokenizer = AutoTokenizer.from_pretrained('facebook/bart-large-mnli')

pipe = ZeroShotClassificationPipeline(model=model, tokenizer=tokenizer, return_all_scores=True)

def score_and_visualize(text):
    prediction = …

我有几个屏蔽语言模型（主要是 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, …

OpenAI 文档model中有关微调 API 属性的说明有点令人困惑：

模型

要微调的基本模型的名称。您可以选择“ada”、“babbage”、“curie”、“davinci”之一或 2022 年 4 月 21 日之后创建的微调模型。

我的问题：微调基本模型还是微调模型更好？

ada我从with file创建了一个微调模型mydata1K.jsonl：

ada + mydata1K.jsonl --> ada:ft-acme-inc-2022-06-25

现在我有一个更大的样本文件mydata2K.jsonl，我想用它来改进微调模型。在这第二轮微调中，是ada再次微调好还是对我微调后的模型进行微调好ada:ft-acme-inc-2022-06-25？我假设这是可能的，因为我的微调模型是在 2022 年 4 月 21 日之后创建的。

ada + mydata2K.jsonl --> better-model

或者

ada:ft-acme-inc-2022-06-25 + mydata2K.jsonl --> even-better-model?