Transformers--4-37-中文文档-二十四-

Transformers 4.37 中文文档(二十四)

原文:huggingface.co/docs/transformers

MPNet

原文链接:huggingface.co/docs/transformers/v4.37.2/en/model_doc/mpnet

概述

MPNet 模型由 Kaitao Song,Xu Tan,Tao Qin,Jianfeng Lu,Tie-Yan Liu 在MPNet: Masked and Permuted Pre-training for Language Understanding中提出。

MPNet 采用一种新颖的预训练方法,称为掩码和置换语言建模,以继承掩码语言建模和置换语言建模在自然语言理解方面的优势。

该论文的摘要如下:

BERT 采用了掩码语言建模(MLM)进行预训练,是最成功的预训练模型之一。由于 BERT 忽略了预测标记之间的依赖关系,XLNet 引入了置换语言建模(PLM)进行预训练以解决这个问题。然而,XLNet 没有利用句子的完整位置信息,因此在预训练和微调之间存在位置差异。在本文中,我们提出了 MPNet,一种新颖的预训练方法,继承了 BERT 和 XLNet 的优势,并避免了它们的局限性。MPNet 通过置换语言建模(与 BERT 中的 MLM 相比)利用了预测标记之间的依赖关系,并将辅助位置信息作为输入,使模型看到完整的句子,从而减少位置差异(与 XLNet 中的 PLM 相比)。我们在大规模数据集(超过 160GB 文本语料库)上对 MPNet 进行预训练,并在各种下游任务(GLUE,SQuAD 等)上进行微调。实验结果表明,MPNet 在这些任务上的表现远远优于 MLM 和 PLM,并在相同的模型设置下与先前最先进的预训练方法(例如 BERT,XLNet,RoBERTa)相比取得了更好的结果。

原始代码可以在这里找到。

使用提示

MPNet 没有token_type_ids,您不需要指示哪个标记属于哪个段落。只需用分隔标记tokenizer.sep_token(或[sep])分隔您的段落。

资源

  • 文本分类任务指南

  • 标记分类任务指南

  • 问答任务指南

  • 掩码语言建模任务指南

  • 多项选择任务指南

MPNetConfig

class transformers.MPNetConfig

<来源>

( vocab_size = 30527 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 initializer_range = 0.02 layer_norm_eps = 1e-12 relative_attention_num_buckets = 32 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

  • vocab_sizeint可选,默认为 30527)— MPNet 模型的词汇表大小。定义了在调用 MPNetModel 或 TFMPNetModel 时可以表示的不同标记的数量。

  • hidden_sizeint可选,默认为 768)— 编码器层和池化层的维度。

  • num_hidden_layersint可选,默认为 12)— Transformer 编码器中的隐藏层数。

  • num_attention_headsint可选,默认为 12)— Transformer 编码器中每个注意力层的注意力头数。

  • intermediate_sizeint可选,默认为 3072)— Transformer 编码器中“中间”(通常称为前馈)层的维度。

  • hidden_actstrCallable可选,默认为"gelu")— 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu""relu""silu""gelu_new"

  • hidden_dropout_probfloat可选,默认为 0.1)— 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

  • attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的丢失比率。

  • max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512 或 1024 或 2048)。

  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。

  • relative_attention_num_buckets (int, optional, 默认为 32) — 每个注意力层使用的桶数。

这是用于存储 MPNetModel 或 TFMPNetModel 配置的配置类。根据指定的参数实例化 MPNet 模型,定义模型架构。使用默认值实例化配置将产生类似于 MPNet microsoft/mpnet-base 架构的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

>>> from transformers import MPNetModel, MPNetConfig

>>> # Initializing a MPNet mpnet-base style configuration
>>> configuration = MPNetConfig()

>>> # Initializing a model from the mpnet-base style configuration
>>> model = MPNetModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

MPNetTokenizer

class transformers.MPNetTokenizer

<来源>

( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '[UNK]' pad_token = '<pad>' mask_token = '<mask>' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

  • vocab_file (str) — 词汇文件的路径。

  • do_lower_case (bool, optional, 默认为 True) — 在标记化时是否将输入转换为小写。

  • do_basic_tokenize (bool, optional, 默认为 True) — 是否在 WordPiece 之前进行基本标记化。

  • never_split (Iterable, optional) — 在标记化期间永远不会拆分的标记集合。仅在 do_basic_tokenize=True 时有效。

  • bos_token (str, optional, 默认为 "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。

    构建序列时使用特殊标记时,这不是用于序列开头的标记。使用的标记是 cls_token

  • eos_token (str, optional, 默认为 "</s>") — 序列结束标记。

    构建序列时使用特殊标记时,这不是用于序列结尾的标记。使用的标记是 sep_token

  • sep_token (str, optional, 默认为 "</s>") — 分隔符标记,在从多个序列构建序列时使用,例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。

  • cls_token (str, optional, 默认为 "<s>") — 在进行序列分类(对整个序列而不是每个标记进行分类)时使用的分类器标记。在使用特殊标记构建序列时,它是序列的第一个标记。

  • unk_token (str, optional, 默认为 "[UNK]") — 未知标记。词汇表中不存在的标记无法转换为 ID,而是设置为此标记。

  • pad_token (str, optional, 默认为 "<pad>") — 用于填充的标记,例如在批处理不同长度的序列时使用。

  • mask_token (str, optional, 默认为 "<mask>") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

  • tokenize_chinese_chars (bool, 可选, 默认为 True) — 是否标记化中文字符。

    这可能应该在日语中停用(请参阅此 问题)。

  • strip_accents (bool, 可选) — 是否去除所有重音符号。如果未指定此选项,则将由 lowercase 的值确定(与原始 BERT 中相同)。

此标记器继承自 BertTokenizer,其中包含大部分方法。用户应参考超类以获取有关方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表

  • token_ids_1 (List[int], 可选) — 第二个序列对的可选 ID 列表。

返回

List[int]

带有适当特殊标记的 输入 ID 列表。

通过连接和添加特殊标记,从序列或序列对构建用于序列分类任务的模型输入。MPNet 序列的格式如下:

  • 单个序列:<s> X </s>

  • 序列对:<s> A </s></s> B </s>

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。

  • token_ids_1 (List[int], 可选) — 第二个序列对的可选 ID 列表。

  • already_has_special_tokens (bool, 可选, 默认为 False) — 如果标记列表已经格式化为模型的特殊标记,则设置为 True

返回

List[int]

一个整数列表,范围为 [0, 1]:1 表示特殊标记,0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。在使用标记器的 prepare_for_model 方法添加特殊标记时调用此方法。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。

  • token_ids_1 (List[int], 可选) — 第二个序列对的可选 ID 列表。

返回

List[int]

零列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。MPNet 不使用标记类型 ID,因此返回一个零列表。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

MPNetTokenizerFast

class transformers.MPNetTokenizerFast

<来源>

( vocab_file = None tokenizer_file = None do_lower_case = True bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '[UNK]' pad_token = '<pad>' mask_token = '<mask>' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

  • vocab_file (str) — 包含词汇表的文件。

  • do_lower_case (bool, 可选, 默认为 True) — 在标记化时是否将输入转换为小写。

  • bos_token (str, 可选, 默认为 "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。

    在使用特殊标记构建序列时,这不是用于序列开始的标记。使用的标记是 cls_token

  • eos_token (str, 可选, 默认为 "</s>") — 序列结束标记。

    在使用特殊标记构建序列时,这不是用于序列结尾的标记。使用的标记是 sep_token

  • sep_token (str, optional, 默认为 "</s>") — 分隔符标记,在构建来自多个序列的序列时使用,例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。

  • cls_token (str, optional, 默认为 "<s>") — 用于进行序列分类(对整个序列进行分类而不是每个标记分类)时使用的分类器标记。它是使用特殊标记构建的序列的第一个标记。

  • unk_token (str, optional, 默认为 "[UNK]") — 未知标记。词汇表中没有的标记无法转换为 ID,而是设置为此标记。

  • pad_token (str, optional, 默认为 "<pad>") — 用于填充的标记,例如在批处理不同长度的序列时。

  • mask_token (str, optional, 默认为 "<mask>") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

  • tokenize_chinese_chars (bool, optional, 默认为 True) — 是否对中文字符进行标记化。这可能应该在日语中停用(请参阅此问题)。

  • strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项,则将由lowercase的值确定(与原始 BERT 相同)。

构建一个“快速”MPNet 分词器(由 HuggingFace 的tokenizers库支持)。基于 WordPiece。

此分词器继承自 PreTrainedTokenizerFast,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。

  • token_ids_1 (List[int], optional) — 可选的第二个 ID 列表,用于序列对

返回

List[int]

零列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。MPNet 不使用标记类型 ID,因此返回一个零列表

PytorchHide Pytorch 内容

MPNetModel

class transformers.MPNetModel

<来源>

( config add_pooling_layer = True )

参数

  • config (MPNetConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

裸 MPNet 模型变压器输出原始隐藏状态,没有特定的头部。

此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法(例如下载或保存,调整输入嵌入,修剪头等)。

此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)— 避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值:

    • 1 表示未被掩盖的标记,

    • 0 表示被掩盖的标记。

    什么是注意力掩码?

  • position_ids(形状为(batch_size, sequence_length)torch.LongTensor可选)— 输入序列标记的位置嵌入的位置索引。选择在范围[0, config.max_position_embeddings - 1]中。

    什么是位置 ID?

  • head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于使自注意力模块的选定头部失效的掩码。选择在[0, 1]中的掩码值:

    • 1 表示头部未被掩盖

    • 0 表示头部被掩盖

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dictbool可选)— 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPooling 或tuple(torch.FloatTensor)

transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False时)包含各种元素,取决于配置(MPNetConfig)和输入。

  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor)— 模型最后一层的隐藏状态序列。

  • pooler_output(形状为(batch_size, hidden_size)torch.FloatTensor)— 经过用于辅助预训练任务的层进一步处理后,序列第一个标记(分类标记)的最后一层隐藏状态。例如,对于 BERT 系列模型,这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层权重是从预训练期间的下一个句子预测(分类)目标中训练的。

  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)— 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组。

    模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

MPNetModel 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MPNetModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = MPNetModel.from_pretrained("microsoft/mpnet-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

MPNetForMaskedLM

class transformers.MPNetForMaskedLM

<来源>

( config )

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为(batch_size, sequence_length)可选) — 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]内:

    • 1 表示未被掩码的标记,

    • 0 表示被掩码的标记。

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为(batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]内选择。

    什么是位置 ID?

  • head_mask (torch.FloatTensor,形状为(num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]内:

    • 1 表示头部未被掩码,

    • 0 表示头部被掩码。

  • inputs_embeds (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions

  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states

  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

  • labels (torch.LongTensor,形状为(batch_size, sequence_length)可选) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内(请参见input_ids文档字符串)。索引设置为-100的标记将被忽略(掩码),损失仅计算具有标签在[0, ..., config.vocab_size]内的标记

返回

transformers.modeling_outputs.MaskedLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组(如果传递了return_dict=False或当config.return_dict=False时)包含根据配置(MPNetConfig)和输入的各种元素。

  • loss(形状为(1,)torch.FloatTensor可选,当提供labels时返回)— 掩码语言建模(MLM)损失。

  • logits(形状为(batch_size, sequence_length, config.vocab_size)torch.FloatTensor)— 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。

  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=True或当config.output_hidden_states=True时返回)— 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。

    模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

MPNetForMaskedLM 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module实例,而不是在此之后调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MPNetForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = MPNetForMaskedLM.from_pretrained("microsoft/mpnet-base")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

MPNetForSequenceClassification

class transformers.MPNetForSequenceClassification

<来源>

( config )

参数

  • config(MPNetConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

MPNet 模型变换器,顶部带有一个序列分类/回归头(在池化输出的顶部是一个线性层),例如用于 GLUE 任务。

这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 输入序列标记在词汇表中的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为(batch_size, sequence_length)可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间:

    • 1 表示头部未被掩盖

    • 对于被掩盖的标记为 0。

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为(batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]

    什么是位置 ID?

  • head_mask (torch.FloatTensor,形状为(num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选在[0, 1]之间:

    • 1 表示头部未被掩盖

    • 0 表示头部被掩盖

  • inputs_embeds (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)可选) — 可选地,可以直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制权,以便将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions

  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

  • labels (torch.LongTensor,形状为(batch_size,)可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]之间。如果config.num_labels == 1,则计算回归损失(均方损失),如果config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor的元组(如果传递return_dict=Falseconfig.return_dict=False时)包含各种元素,这取决于配置(MPNetConfig)和输入。

  • loss (torch.FloatTensor,形状为(1,)可选,当提供labels时返回) — 分类(或回归,如果 config.num_labels==1)损失。

  • logits (torch.FloatTensor,形状为(batch_size, config.num_labels)) — 分类(或回归,如果 config.num_labels==1)得分(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — torch.FloatTensor的元组(如果模型有嵌入层,则为嵌入的输出+每一层的输出)的形状为(batch_size, sequence_length, hidden_size)

    模型在每一层输出的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

MPNetForSequenceClassification 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

单标签分类示例:

>>> import torch
>>> from transformers import AutoTokenizer, MPNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = MPNetForSequenceClassification.from_pretrained("microsoft/mpnet-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MPNetForSequenceClassification.from_pretrained("microsoft/mpnet-base", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例:

>>> import torch
>>> from transformers import AutoTokenizer, MPNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = MPNetForSequenceClassification.from_pretrained("microsoft/mpnet-base", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MPNetForSequenceClassification.from_pretrained(
...     "microsoft/mpnet-base", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

MPNetForMultipleChoice

class transformers.MPNetForMultipleChoice

<来源>

( config )

参数

  • config(MPNetConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部具有多项选择分类头部的 MPNet 模型(在汇总输出的顶部有一个线性层和一个 softmax),例如用于 RocStories/SWAG 任务。

这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为(batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为(batch_size, sequence_length)可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]之间:

    • 1 表示未被掩码的标记,

    • 0 表示被掩码的标记。

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为(batch_size, num_choices, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

    什么是位置 ID?

  • head_mask (torch.FloatTensor,形状为(num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]之间:

    • 1 表示头部未被掩码

    • 0 表示头部被掩码

  • inputs_embeds(形状为(batch_size, num_choices, sequence_length, hidden_size)torch.FloatTensor可选)- 可选地,您可以选择直接传递一个嵌入表示,而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • output_attentionsbool可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions

  • output_hidden_statesbool可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dictbool可选)- 是否返回一个 ModelOutput 而不是一个普通元组。

  • labels(形状为(batch_size,)torch.LongTensor可选)- 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内,其中num_choices是输入张量第二维的大小。 (参见上面的input_ids)

返回

transformers.modeling_outputs.MultipleChoiceModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或者一个torch.FloatTensor的元组(如果传递了return_dict=False或者config.return_dict=False时)包含不同的元素,取决于配置(MPNetConfig)和输入。

  • loss(形状为(1,)torch.FloatTensor可选,当提供labels时返回)- 分类损失。

  • logits(形状为(batch_size, num_choices)torch.FloatTensor)- num_choices是输入张量的第二维大小。 (见上面的input_ids)。

    分类得分(SoftMax 之前)。

  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入输出的形状+每层输出的形状)。

    模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

MPNetForMultipleChoice 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MPNetForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = MPNetForMultipleChoice.from_pretrained("microsoft/mpnet-base")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

MPNetForTokenClassification

class transformers.MPNetForTokenClassification

<来源>

( config )

参数

  • config(MPNetConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部带有标记分类头部的 MPNet 模型(隐藏状态输出的顶部线性层),例如用于命名实体识别(NER)任务。

这个模型继承自 PreTrainedModel。查看超类文档以了解库实现的所有模型的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]

    • 1 表示未被masked的标记,

    • 0 表示被masked的标记。

    什么是注意力掩码?

  • position_ids(形状为(batch_size, sequence_length)torch.LongTensor可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]

    什么是位置 ID?

  • head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]

    • 1 表示未被masked的头部,

    • 0 表示头部被masked

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。

  • labels(形状为(batch_size, sequence_length)torch.LongTensor可选)— 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]内。

返回

transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置(MPNetConfig)和输入的各种元素。

  • 损失 (torch.FloatTensor,形状为(1,)可选,在提供labels时返回) — 分类损失。

  • logits (torch.FloatTensor,形状为(batch_size, sequence_length, config.num_labels)) — SoftMax 之前的分类分数。

  • hidden_states (tuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)。

    模型在每一层输出的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

MPNetForTokenClassification 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MPNetForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = MPNetForTokenClassification.from_pretrained("microsoft/mpnet-base")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

MPNetForQuestionAnswering

class transformers.MPNetForQuestionAnswering

<源代码>

( config )

参数

  • config(MPNetConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

MPNet 模型,在顶部具有用于提取式问答任务(如 SQuAD)的跨度分类头(在隐藏状态输出顶部的线性层,用于计算跨度起始 logits跨度结束 logits)。

此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

forward

<源代码>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]

    • 1 表示未被屏蔽的标记,

    • 0 表示被屏蔽的标记。

    什么是注意力掩码?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]

    什么是位置 ID?

  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在 [0, 1]

    • 1 表示头部未被屏蔽,

    • 0 表示头部被屏蔽。

  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions

  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states

  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

  • start_positions (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算标记分类损失的标记跨度开始位置(索引)的标签。位置被夹紧到序列的长度 (sequence_length)。序列外的位置不会计入损失的计算。

  • end_positions (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算标记分类损失的标记跨度结束位置(索引)的标签。位置被夹紧到序列的长度 (sequence_length)。序列外的位置不会计入损失的计算。

返回

transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时)包含根据配置(MPNetConfig)和输入而异的各种元素。

  • loss (torch.FloatTensor,形状为 (1,)可选,当提供 labels 时返回) — 总跨度提取损失是起始和结束位置的交叉熵之和。

  • start_logits (torch.FloatTensor,形状为 (batch_size, sequence_length)) — 跨度开始得分(SoftMax 之前)。

  • end_logits (torch.FloatTensor,形状为 (batch_size, sequence_length)) — 跨度结束得分(SoftMax 之前)。

  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) - 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每个层的输出)。

    模型在每个层的输出处的隐藏状态以及可选的初始嵌入输出。

  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回) - 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

MPNetForQuestionAnswering 的前向方法重写了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MPNetForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = MPNetForQuestionAnswering.from_pretrained("microsoft/mpnet-base")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

TensorFlow 隐藏 TensorFlow 内容

TFMPNetModel

class transformers.TFMPNetModel

< source >

( config *inputs **kwargs )

参数

  • config(MPNetConfig) - 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

裸 MPNet 模型变换器输出原始隐藏状态,没有特定的头部。

该模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

该模型还是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入:

  • 将所有输入作为关键字参数(类似于 PyTorch 模型),或

  • 将所有输入作为列表、元组或字典放在第一个位置参数中。

第二种格式得到支持的原因是,当将输入传递给模型和层时,Keras 方法更喜欢这种格式。由于这种支持,当使用诸如model.fit()之类的方法时,对您来说应该“只需工作” - 只需以model.fit()支持的任何格式传递您的输入和标签!但是,如果您想在 Keras 方法之外使用第二种格式,比如在使用 KerasFunctional API 创建自己的层或模型时,有三种可能性可以用来收集所有输入张量在第一个位置参数中:

  • 一个仅包含input_ids的单个张量,没有其他内容:model(input_ids)

  • 一个长度可变的列表,其中包含一个或多个输入张量,按照文档字符串中给定的顺序:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])

  • 一个字典,其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意,当使用 子类化 创建模型和层时,您不需要担心这些问题,因为您可以像对待任何其他 Python 函数一样传递输入!

call

< source >

( input_ids: TFModelInputType | None = None attention_mask: Optional[Union[np.array, tf.Tensor]] = None position_ids: Optional[Union[np.array, tf.Tensor]] = None head_mask: Optional[Union[np.array, tf.Tensor]] = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)

参数

  • input_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。

    什么是输入 ID?

  • attention_mask (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间:

    • 1 表示头部是 未掩码

    • 0 表示标记是 掩码

    什么是注意力掩码?

  • position_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID?

  • head_mask (Numpy arraytf.Tensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选在 [0, 1] 之间:

    • 1 表示头部是 未掩码

    • 0 表示头部是 掩码

  • inputs_embeds (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以直接传递嵌入表示,而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量,这将很有用,而不是使用模型的内部嵌入查找矩阵。

  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的 attentions。此参数仅在急切模式下使用,在图模式下将使用配置中的值。

  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的 hidden_states。此参数仅在急切模式下使用,在图模式下将使用配置中的值。

  • return_dict (bool可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。这个参数可以在急切模式下使用,在图模式下该值将始终设置为 True。

  • training (bool可选,默认为 False) — 是否在训练模式下使用模型(一些模块,如 dropout 模块,在训练和评估之间有不同的行为)。

返回

transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个 tf.Tensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时)包含根据配置(MPNetConfig)和输入的不同元素。

  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)tf.Tensor)- 模型最后一层的隐藏状态序列。

  • hidden_statestuple(tf.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)tf.Tensor元组(一个用于嵌入的输出 + 一个用于每一层的输出)。

    模型在每一层的输出隐藏状态以及初始嵌入输出。

  • attentionstuple(tf.Tensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)tf.Tensor元组(每层一个)。

    用于计算自注意力头中加权平均值的注意力 softmax 之后的注意力权重。

TFMPNetModel 的前向方法覆盖了__call__特殊方法。

尽管前向传递的方法需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, TFMPNetModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = TFMPNetModel.from_pretrained("microsoft/mpnet-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFMPNetForMaskedLM

class transformers.TFMPNetForMaskedLM

<来源>

( config *inputs **kwargs )

参数

  • config(MPNetConfig)- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

带有顶部语言建模头的 MPNet 模型。

该模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

该模型也是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入:

  • 将所有输入作为关键字参数(类似于 PyTorch 模型),或

  • 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用model.fit()等方法时,应该“只需传递”您的输入和标签,以任何model.fit()支持的格式传递!但是,如果您想在 Keras 方法之外使用第二种格式,比如在使用 KerasFunctional API 创建自己的层或模型时,有三种可能性可以用来收集第一个位置参数中的所有输入张量:

  • 一个仅包含input_ids的单个张量,没有其他内容:model(input_ids)

  • 一个长度可变的列表,其中包含一个或多个输入张量,按照文档字符串中给定的顺序:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])

  • 一个包含与文档字符串中给定的输入名称相关联的一个或多个输入张量的字典:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像对待其他 Python 函数一样传递输入!

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)

参数

  • input_ids(形状为(batch_size, sequence_length)Numpy数组或tf.Tensor)— 输入序列标记在词汇表中的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, sequence_length)Numpy数组或tf.Tensor可选)— 避免对填充标记索引执行注意力的掩码。选择的掩码值在[0, 1]中:

    • 1 表示未被“掩盖”的标记,

    • 对于被“掩盖”的标记为 0。

    什么是注意力掩码?

  • position_ids(形状为(batch_size, sequence_length)Numpy数组或tf.Tensor可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]

    什么是位置 ID?

  • head_mask(形状为(num_heads,)(num_layers, num_heads)Numpy数组或tf.Tensor可选)— 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中:

    • 1 表示头部未被“掩盖”,

    • 0 表示头部被“掩盖”。

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)tf.Tensor可选)— 可选地,您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions。此参数仅在急切模式下使用,在图模式下将使用配置中的值。

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states。此参数仅在急切模式下使用,在图模式下将使用配置中的值。

  • return_dictbool可选)— 是否返回一个 ModelOutput 而不是一个普通元组。此参数可以在急切模式下使用,在图模式下该值将始终设置为 True。

  • trainingbool可选,默认为False)— 是否在训练模式下使用模型(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

  • labels(形状为(batch_size, sequence_length)tf.Tensor可选)— 用于计算掩盖语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]中(请参阅input_ids文档字符串)。索引设置为-100的标记将被忽略(掩盖),损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回值

transformers.modeling_tf_outputs.TFMaskedLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMaskedLMOutput 或一个tf.Tensor元组(如果传递了return_dict=False或当config.return_dict=False时)包含根据配置(MPNetConfig)和输入的各种元素。

  • loss(形状为(n,)tf.Tensor可选,当提供labels时返回,其中 n 是非屏蔽标签的数量)- 掩蔽语言建模(MLM)损失。

  • logits(形状为(batch_size, sequence_length, config.vocab_size)tf.Tensor)- 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。

  • hidden_statestuple(tf.Tensor)可选,当传递output_hidden_states=True或当config.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)tf.Tensor元组(一个用于嵌入的输出 + 一个用于每一层的输出)。

    模型在每一层输出的隐藏状态加上初始嵌入输出。

  • attentionstuple(tf.Tensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)tf.Tensor元组(每层一个)。

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

TFMPNetForMaskedLM 的前向方法,覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, TFMPNetForMaskedLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = TFMPNetForMaskedLM.from_pretrained("microsoft/mpnet-base")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="tf")
>>> logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
>>> selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)

>>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="tf")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

TFMPNetForSequenceClassification

class transformers.TFMPNetForSequenceClassification

<来源>

( config *inputs **kwargs )

参数

  • config(MPNetConfig)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部有一个序列分类/回归头的 MPNet 模型变压器(在池化输出的顶部有一个线性层),例如 GLUE 任务。

该模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

该模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入:

  • 将所有输入作为关键字参数(类似于 PyTorch 模型),或

  • 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是,当将输入传递给模型和层时,Keras 方法更喜欢这种格式。由于有了这种支持,当使用model.fit()等方法时,您应该可以“轻松地”使用 - 只需以model.fit()支持的任何格式传递输入和标签即可!但是,如果您想在 Keras 方法之外使用第二种格式,比如在使用 KerasFunctional API 创建自己的层或模型时,有三种可能性可以用来收集第一个位置参数中的所有输入张量:

  • 一个仅包含input_ids的单个张量:model(input_ids)

  • 一个长度不定的列表,其中包含一个或多个输入张量,按照文档字符串中给定的顺序:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])

  • 一个字典,其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意,当使用子类化创建模型和层时,您无需担心这些问题,因为您可以像对待任何其他 Python 函数一样传递输入!

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: Optional[Union[np.array, tf.Tensor]] = None position_ids: Optional[Union[np.array, tf.Tensor]] = None head_mask: Optional[Union[np.array, tf.Tensor]] = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

  • input_ids(形状为(batch_size, sequence_length)Numpy数组或tf.Tensor)— 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, sequence_length)Numpy数组或tf.Tensor可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选定为[0, 1]

    • 对于未被masked的标记,值为 1,

    • 对于被masked的标记,值为 0。

    什么是注意力掩码?

  • position_ids(形状为(batch_size, sequence_length)Numpy数组或tf.Tensor可选)— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

    什么是位置 ID?

  • head_mask(形状为(num_heads,)(num_layers, num_heads)Numpy数组或tf.Tensor可选)— 用于使自注意力模块中选择的头部失效的掩码。掩码值选定为[0, 1]

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)tf.Tensor可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions。此参数仅在急切模式下可用,在图模式下将使用配置中的值。

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量中的hidden_states。此参数仅在急切模式下可用,在图模式下将使用配置中的值。

  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用,在图模式下该值将始终设置为 True。

  • training (bool可选,默认为False) — 是否在训练模式下使用模型(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

  • labels (tf.Tensor of shape (batch_size,)可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1,则计算回归损失(均方损失),如果config.num_labels > 1,则计算分类损失(交叉熵)。

返回值

transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个tf.Tensor元组(如果传递return_dict=Falseconfig.return_dict=False时)包含各种元素,取决于配置(MPNetConfig)和输入。

  • loss (tf.Tensor of shape (batch_size, )可选,当提供labels时返回) — 分类(如果 config.num_labels==1 则为回归)损失。

  • logits (tf.Tensor of shape (batch_size, config.num_labels)) — 分类(如果 config.num_labels==1 则为回归)得分(SoftMax 之前)。

  • hidden_states (tuple(tf.Tensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)tf.Tensor元组(一个用于嵌入的输出 + 一个用于每个层的输出)。

    模型在每个层的输出的隐藏状态加上初始嵌入输出。

  • attentions (tuple(tf.Tensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)tf.Tensor元组(每层一个)。

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

TFMPNetForSequenceClassification 前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例而不是这个,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, TFMPNetForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = TFMPNetForSequenceClassification.from_pretrained("microsoft/mpnet-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")

>>> logits = model(**inputs).logits

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFMPNetForSequenceClassification.from_pretrained("microsoft/mpnet-base", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

TFMPNetForMultipleChoice

class transformers.TFMPNetForMultipleChoice

< source >

( config *inputs **kwargs )

参数

  • config (MPNetConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部具有多项选择分类头的 MPNet 模型(在池化输出的顶部和 softmax 之上的线性层)例如用于 RocStories/SWAG 任务。

此模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入:

  • 将所有输入作为关键字参数(类似于 PyTorch 模型),或

  • 将所有输入作为列表、元组或字典传递给第一个位置参数。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持,当使用model.fit()等方法时,应该“只需工作” - 只需以model.fit()支持的任何格式传递输入和标签!但是,如果您想在 Keras 方法之外使用第二种格式,例如在使用 KerasFunctionalAPI 创建自己的层或模型时,有三种可能性可用于收集第一个位置参数中的所有输入张量:

  • 只有一个input_ids的张量,没有其他内容:model(input_ids)

  • 一个长度可变的列表,其中包含一个或多个按照文档字符串中给定的顺序的输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])

  • 一个字典,其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像对待任何其他 Python 函数一样传递输入!

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput or tuple(tf.Tensor)

参数

  • input_ids(形状为(batch_size, num_choices, sequence_length)Numpy数组或tf.Tensor)— 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, num_choices, sequence_length)Numpy数组或tf.Tensor可选)— 用于避免在填充标记索引上执行注意力的掩码。在[0, 1]中选择的掩码值:

    • 1 表示未被“掩盖”的标记,

    • 0 表示被“掩盖”的标记。

    什么是注意力掩码?

  • position_ids(形状为(batch_size, num_choices, sequence_length)Numpy数组或tf.Tensor可选)— 每个输入序列标记在位置嵌入中的位置的索引。在范围[0, config.max_position_embeddings - 1]中选择。

    什么是位置 ID?

  • head_mask(形状为(num_heads,)(num_layers, num_heads)Numpy数组或tf.Tensor可选)— 用于使自注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值:

    • 1 表示头部未被“掩盖”,

    • 0 表示头部被“掩盖”。

  • inputs_embeds(形状为(batch_size, num_choices, sequence_length, hidden_size)tf.Tensor可选)— 可选地,您可以直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions。此参数只能在急切模式下使用,在图模式下将使用配置中的值。

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states。此参数只能在急切模式下使用,在图模式下将使用配置中的值。

  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用,在图模式下该值将始终设置为 True。

  • trainingbool可选,默认为False)— 是否在训练模式下使用模型(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

  • labels(形状为(batch_size,)tf.Tensor可选)— 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices]范围内,其中num_choices是输入张量第二维的大小。(参见上面的input_ids

返回

transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或者tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或者一个tf.Tensor的元组(如果传递了return_dict=False或者当config.return_dict=False时),包括根据配置(MPNetConfig)和输入的不同元素。

  • loss(形状为(batch_size, )tf.Tensor可选,当提供labels时返回)— 分类损失。

  • logits(形状为(batch_size, num_choices)tf.Tensor)— num_choices是输入张量的第二维。(参见上面的input_ids)。

    分类得分(SoftMax 之前)。

  • hidden_statestuple(tf.Tensor)可选,当传递output_hidden_states=True或者当config.output_hidden_states=True时返回)— 形状为(batch_size, sequence_length, hidden_size)tf.Tensor元组(一个用于嵌入的输出 + 一个用于每个层的输出)。

    模型在每个层的输出处的隐藏状态加上初始嵌入输出。

  • attentionstuple(tf.Tensor)可选,当传递output_attentions=True或者当config.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)tf.Tensor元组(每个层一个)。

    在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

TFMPNetForMultipleChoice 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, TFMPNetForMultipleChoice
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = TFMPNetForMultipleChoice.from_pretrained("microsoft/mpnet-base")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> outputs = model(inputs)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> logits = outputs.logits

TFMPNetForTokenClassification

class transformers.TFMPNetForTokenClassification

<来源>

( config *inputs **kwargs )

参数

  • config(MPNetConfig)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部带有令牌分类头的 MPNet 模型(在隐藏状态输出的顶部有一个线性层),例如用于命名实体识别(NER)任务。

此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存,调整输入嵌入,修剪头等)。

此模型还是一个tf.keras.Model子类。将其用作常规 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取有关一般用法和行为的所有信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入:

  • 将所有输入作为关键字参数(类似于 PyTorch 模型),或

  • 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用model.fit()等方法时,应该“只需工作” - 只需以model.fit()支持的任何格式传递输入和标签!但是,如果您想在 Keras 方法之外使用第二种格式,例如在使用 KerasFunctional API 创建自己的层或模型时,有三种可能性可用于在第一个位置参数中收集所有输入张量:

  • 只有input_ids的单个张量,没有其他内容:model(input_ids)

  • 一个长度可变的列表,其中包含按照文档字符串中给定的顺序的一个或多个输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])

  • 一个字典,其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像对待其他 Python 函数一样传递输入!

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFTokenClassifierOutput or tuple(tf.Tensor)

参数

  • input_ids(形状为(batch_size, sequence_length)Numpy数组或tf.Tensor)- 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, sequence_length)Numpy数组或tf.Tensor可选)- 避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值:

    • 1 用于未被“掩码”的标记,

    • 0 用于被“掩码”的标记。

    什么是注意力掩码?

  • position_ids(形状为(batch_size, sequence_length)Numpy 数组tf.Tensor可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]

    什么是位置 ID?

  • head_mask(形状为(num_heads,)(num_layers, num_heads)Numpy 数组tf.Tensor可选)— 用于使自注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值:

    • 1 表示头部未被掩码

    • 0 表示头部被掩码

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)tf.Tensor可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions。此参数仅在急切模式下使用,在图模式下将使用配置中的值。

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states。此参数仅在急切模式下使用,在图模式下将使用配置中的值。

  • return_dictbool可选)— 是否返回一个 ModelOutput 而不是一个普通元组。此参数可以在急切模式下使用,在图模式下该值将始终设置为 True。

  • trainingbool可选,默认为False)— 是否在训练模式下使用模型(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

  • labels(形状为(batch_size, sequence_length)tf.Tensor可选)— 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。

返回

transformers.modeling_tf_outputs.TFTokenClassifierOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFTokenClassifierOutput 或者一个tf.Tensor元组(如果传递了return_dict=False或者当config.return_dict=False时)包含各种元素,取决于配置(MPNetConfig)和输入。

  • loss(形状为(n,)tf.Tensor可选,其中 n 是未掩码标签的数量,当提供labels时返回)— 分类损失。

  • logits(形状为(batch_size, sequence_length, config.num_labels)tf.Tensor)— 分类分数(SoftMax 之前)。

  • hidden_statestuple(tf.Tensor)可选,当传递output_hidden_states=True或者当config.output_hidden_states=True时返回)— 形状为(batch_size, sequence_length, hidden_size)tf.Tensor元组(一个用于嵌入的输出 + 一个用于每个层的输出)。

    模型在每一层输出的隐藏状态以及初始嵌入输出。

  • attentionstuple(tf.Tensor)可选,当传递output_attentions=True或者当config.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)tf.Tensor元组(每个层一个)。

    在自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。

TFMPNetForTokenClassification 的前向方法,覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, TFMPNetForTokenClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = TFMPNetForTokenClassification.from_pretrained("microsoft/mpnet-base")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )

>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]
>>> labels = predicted_token_class_ids
>>> loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)

TFMPNetForQuestionAnswering

class transformers.TFMPNetForQuestionAnswering

<来源>

( config *inputs **kwargs )

参数

  • config(MPNetConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。

MPNet 模型在顶部具有跨度分类头,用于提取式问答任务,如 SQuAD(在隐藏状态输出的顶部进行线性层计算span start logitsspan end logits)。

此模型继承自 TFPreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

此模型还是一个tf.keras.Model子类。将其用作常规 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入:

  • 所有输入都作为关键字参数(类似于 PyTorch 模型),或者

  • 所有输入都作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用model.fit()等方法时,应该“只需传递”您的输入和标签,以任何model.fit()支持的格式!但是,如果您想在 Keras 方法之外使用第二种格式,例如在使用 KerasFunctional API 创建自己的层或模型时,有三种可能性可用于收集第一个位置参数中的所有输入张量:

  • 仅具有input_ids的单个张量,没有其他内容:model(input_ids)

  • 一个长度可变的列表,其中包含文档字符串中给定顺序的一个或多个输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])

  • 一个字典,其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像将输入传递给任何其他 Python 函数一样传递输入!

call

<来源>

( input_ids: TFModelInputType | None = None attention_mask: Optional[Union[np.array, tf.Tensor]] = None position_ids: Optional[Union[np.array, tf.Tensor]] = None head_mask: Optional[Union[np.array, tf.Tensor]] = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: tf.Tensor | None = None end_positions: tf.Tensor | None = None training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput or tuple(tf.Tensor)

参数

  • input_ids(形状为(batch_size, sequence_length)Numpy数组或tf.Tensor)-词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。

    什么是输入 ID?

  • attention_mask (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 遮罩,避免在填充标记索引上执行注意力。遮罩值选定在 [0, 1]

    • 1 表示未被 masked 的标记,

    • 0 表示被 masked 的标记。

    什么是注意力遮罩?

  • position_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。选定范围为 [0, config.max_position_embeddings - 1]

    什么是位置 ID?

  • head_mask (Numpy arraytf.Tensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块中选择的头部失效的遮罩。遮罩值选定在 [0, 1]

    • 1 表示头部未被 masked

    • 0 表示头部被 masked

  • inputs_embeds (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,可以直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这很有用。

  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions。此参数仅在急切模式下使用,在图模式下将使用配置中的值。

  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states。此参数仅在急切模式下使用,在图模式下将使用配置中的值。

  • return_dict (bool可选) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用,在图模式下该值将始终设置为 True。

  • training (bool可选,默认为 False) — 是否在训练模式下使用模型(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

  • start_positions (tf.Tensor,形状为 (batch_size,)可选) — 用于计算标记跨度起始位置(索引)的标签,用于计算标记分类损失。位置被夹紧到序列的长度 (sequence_length)。序列外的位置不会被考虑在内计算损失。

  • end_positions (tf.Tensor,形状为 (batch_size,)可选) — 用于计算标记跨度结束位置(索引)的标签,用于计算标记分类损失。位置被夹紧到序列的长度 (sequence_length)。序列外的位置不会被考虑在内计算损失。

返回

transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或一个 tf.Tensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时)包含根据配置(MPNetConfig)和输入的不同元素。

  • loss (tf.Tensor,形状为 (batch_size, )可选,当提供了 start_positionsend_positions 时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。

  • start_logits (tf.Tensor,形状为 (batch_size, sequence_length)) — 跨度起始分数(SoftMax 之前)。

  • end_logits(形状为(batch_size, sequence_length)tf.Tensor)- 跨度结束得分(SoftMax 之前)。

  • hidden_statestuple(tf.Tensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)tf.Tensor元组(一个用于嵌入的输出 + 一个用于每个层的输出)。

    模型在每个层的输出处的隐藏状态加上初始嵌入输出。

  • attentionstuple(tf.Tensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)tf.Tensor元组(每个层一个)。

    在注意力 SoftMax 之后的注意力权重,用于计算自注意力头中的加权平均值。

TFMPNetForQuestionAnswering 的前向方法,覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, TFMPNetForQuestionAnswering
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/mpnet-base")
>>> model = TFMPNetForQuestionAnswering.from_pretrained("microsoft/mpnet-base")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)

>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> # target is "nice puppet"
>>> target_start_index = tf.constant([14])
>>> target_end_index = tf.constant([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = tf.math.reduce_mean(outputs.loss)

MPT

原始文本: huggingface.co/docs/transformers/v4.37.2/en/model_doc/mpt

概述

MPT 模型由 MosaicML 团队提出,并发布了多种大小和微调变体。MPT 模型是一系列在 1T 令牌上预训练的开源和商业可用的 LLM。

MPT 模型是类似于 GPT 的仅解码器变压器,具有几项改进:性能优化的层实现、提供更大训练稳定性的架构更改,以及通过用 ALiBi 替换位置嵌入来消除上下文长度限制。

  • MPT 基础: MPT 基础预训练模型用于下一个令牌预测

  • MPT 指导: MPT 基础模型在基于指令的任务上进行了微调

  • MPT 故事创作者: MPT 基础模型在 books3 语料库中的 65k 令牌摘录上进行了 2500 步的微调,这使得模型能够处理非常长的序列

原始代码可在 llm-foundry 存储库中找到。

了解更多 在发布博客文章中

使用提示

  • 了解模型训练背后的一些技术 在 llm-foundry 存储库的这一部分

  • 如果要使用模型的高级版本(triton kernels、直接闪存注意力集成),仍然可以通过在调用 from_pretrained 时添加 trust_remote_code=True 来使用原始模型实现。

资源

  • 微调笔记本 关于如何在免费的 Google Colab 实例上微调 MPT-7B 以将模型转换为聊天机器人。

MptConfig

class transformers.MptConfig

<来源>

( d_model: int = 2048 n_heads: int = 16 n_layers: int = 24 expansion_ratio: int = 4 max_seq_len: int = 2048 vocab_size: int = 50368 resid_pdrop: float = 0.0 layer_norm_epsilon: float = 1e-05 emb_pdrop: float = 0.0 learned_pos_emb: bool = True attn_config: MptAttentionConfig = None init_device: str = 'cpu' logit_scale: Union = None no_bias: bool = True verbose: int = 0 embedding_fraction: float = 1.0 norm_type: str = 'low_precision_layernorm' use_cache: bool = False initializer_range = 0.02 **kwargs )

参数

  • d_model (int, 可选, 默认为 2048) — 嵌入和隐藏状态的维度。

  • n_heads (int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。

  • n_layers (int, 可选, 默认为 24) — Transformer 编码器中的隐藏层数量。

  • expansion_ratio (int, 可选, 默认为 4) — MLP 中上/下缩放比率。

  • max_seq_len (int, 可选, 默认为 2048) — 模型的最大序列长度。

  • vocab_size (int, 可选, 默认为 50368) — Mpt 模型的词汇量。定义了在调用 MptModel 时可以表示的不同令牌的最大数量。查看关于如何定义 vocab_size此讨论

  • resid_pdrop (float, 可选, 默认为 0.0) — 在与残差结合之前应用于注意力输出的丢弃概率。

  • layer_norm_epsilon (float, 可选, 默认为 1e-05) — 在层归一化层中使用的 epsilon。

  • emb_pdrop (float, 可选, 默认为 0.0) — 嵌入层的丢弃概率。

  • learned_pos_emb (bool, 可选, 默认为 True) — 是否使用学习的位置嵌入。

  • attn_config (dict, 可选) — 用于配置模型注意力模块的字典。

  • init_device (str, 可选, 默认为 "cpu") — 用于参数初始化的设备。为了向后兼容性而定义

  • logit_scale (float, 可选) — 如果不为 None,则通过此值缩放对数。

  • no_bias (bool, 可选, 默认为 True) — 是否在所有线性层中使用偏置。

  • verbose (int, 可选, 默认为 0) — 用于日志记录的详细级别。在先前版本的 MPT 模型中用于日志记录。此参数已弃用。

  • embedding_fraction (float, optional, defaults to 1.0) — 通过的嵌入层梯度的比例。

  • norm_type (str, optional, defaults to "low_precision_layernorm") — 要使用的层归一化类型。所有 MPT 模型使用相同的层归一化实现。为了向后兼容性而定义。

  • use_cache (bool, optional, defaults to False) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。

  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

这是用于存储 MptModel 配置的配置类。它用于根据指定的参数实例化一个 Mpt 模型,定义模型架构。使用默认值实例化配置将产生类似于 Mpt-7b 架构 mosaicml/mpt-7b 的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例:

>>> from transformers import MptConfig, MptModel

>>> # Initializing a Mpt configuration
>>> configuration = MptConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = MptModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

MptModel

class transformers.MptModel

< source >

( config: MptConfig )

参数

  • config (MptConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的 Mpt 模型变压器输出原始隐藏状态,没有特定的头部。

这个模型继承自 PreTrainedModel。检查超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入等)。

这个模型也是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, input_ids_length)) — input_ids_length = sequence_length 如果 past_key_valuesNone,否则 past_key_values[0][0].shape[2](输入过去键值状态的序列长度)。词汇表中输入序列标记的索引。

    如果使用了 past_key_values,则只应将未计算其过去的 input_ids 作为 input_ids 传递。

    可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以获取详细信息。

    什么是输入 ID?

  • past_key_values(长度为config.n_layersTuple[Tuple[torch.Tensor]])- 包含模型计算的预先计算的隐藏状态(注意力块中的键和值),如下面的past_key_values输出所示。可用于加速顺序解码。将过去给定给该模型的input_ids不应作为input_ids传递,因为它们已经被计算过。

    past_key_values的每个元素都是一个元组(past_key,past_value):

    • past_key: [batch_size * num_heads, head_dim, kv_length]

    • past_value: [batch_size * num_heads, kv_length, head_dim]

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)- 用于避免在填充令牌索引上执行注意力的掩码。选择的掩码值在[0, 1]中:

    • 1 表示未被掩码的标记,

    • 0 表示被掩码的标记。

    什么是注意力掩码?

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)- 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制权,以便将input_ids索引转换为相关向量,而不是模型的内部嵌入查找矩阵。

    如果使用past_key_values,可以选择仅输入最后的inputs_embeds(参见past_key_values)。

  • use_cachebool可选)- 如果设置为True,将返回past_key_values键值状态,并可用于加速解码(参见past_key_values)。

  • output_attentionsbool可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回的张量下的attentions

  • output_hidden_statesbool可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回的张量下的hidden_states

  • return_dictbool可选)- 是否返回一个 ModelOutput 而不是一个普通的元组。

返回值

transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False时)包含根据配置(MptConfig)和输入的不同元素。

  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor)- 模型最后一层的输出的隐藏状态序列。

    如果使用past_key_values,则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

  • past_key_values可选,当传递use_cache=Trueconfig.use_cache=True时返回)- 长度为config.n_layerstuple(tuple(torch.FloatTensor))元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量,如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块中的键和值,以及可选地如果config.is_encoder_decoder=True在交叉注意力块中)可用于加速顺序解码(参见past_key_values输入)。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当 output_hidden_states=True 被传递或者当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size)torch.FloatTensor 元组(一个用于嵌入的输出,如果模型有一个嵌入层,+ 一个用于每一层的输出)。

    模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当 output_attentions=True 被传递或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor 元组(每层一个)。

    在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor), 可选, 当 output_attentions=Trueconfig.add_cross_attention=True 被传递或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor 元组(每层一个)。

    解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

MptModel 的前向方法,覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在之后调用 Module 实例而不是这个,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MptModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptModel.from_pretrained("mosaicml/mpt-7b")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

MptForCausalLM

class transformers.MptForCausalLM

<来源>

( config: MptConfig )

参数

  • config (MptConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法来加载模型权重。

带有语言建模头部的 MPT 模型变压器(线性层,其权重与输入嵌入绑定)。

该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入等)。

该模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, input_ids_length)) — 如果 past_key_valuesNone,则 input_ids_length = sequence_length,否则为 past_key_values[0][0].shape[2](输入过去键值状态的序列长度)。词汇表中输入序列标记的索引。

    如果使用了 past_key_values,只有那些未计算过去的 input_ids 应该被传递。

    可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。

    什么是输入 ID?

  • past_key_values (Tuple[Tuple[torch.Tensor]] 长度为 config.n_layers) — 包含由模型计算的预计算隐藏状态(注意力块中的键和值),如下面的 past_key_values 输出所示。可用于加速顺序解码。将其过去给定给此模型的 input_ids 不应作为 input_ids 传递,因为它们已经计算过了。

    past_key_values 的每个元素都是一个元组(past_key, past_value):

    • past_key: [batch_size * num_heads, head_dim, kv_length]

    • past_value: [batch_size * num_heads, kv_length, head_dim]

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]

    • 对于未被掩盖的标记,为 1,

    • 对于被掩盖的标记,为 0。

    什么是注意力掩码?

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

    如果使用了 past_key_values,则可能只需输入最后的 inputs_embeds(参见 past_key_values)。

  • use_cache (bool, optional) — 如果设置为 True,则返回 past_key_values 键值状态,并可用于加速解码(参见 past_key_values)。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是一个普通元组。

  • labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 语言建模的标签。请注意,模型内部的标签 已经被移位,即您可以设置 labels = input_ids 索引选在 [-100, 0, ..., config.vocab_size] 所有设置为 -100 的标签都被忽略(掩盖),损失仅计算标签在 [0, ..., config.vocab_size] 中的标签。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或者 torch.FloatTensor 元组

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或者一个 torch.FloatTensor 元组(如果传递 return_dict=False 或者当 config.return_dict=False 时)包含各种元素,取决于配置(MptConfig)和输入。

  • loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 语言建模损失(用于下一个标记预测)。

  • logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。

  • hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或者当 config.output_hidden_states=True 时返回) — 一个元组,包含 torch.FloatTensor(一个用于嵌入层的输出,如果模型有一个嵌入层,+ 一个用于每一层的输出)的形状为 (batch_size, sequence_length, hidden_size)

    模型每一层的隐藏状态加上可选的初始嵌入输出。

  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

  • cross_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    在注意力 softmax 之后的交叉注意力权重,用于计算交叉注意力头中的加权平均值。

  • past_key_valuestuple(tuple(torch.FloatTensor))可选,当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layerstorch.FloatTensor元组的元组,每个元组包含自注意力和交叉注意力层的缓存键、值状态。仅在config.is_decoder = True时相关。

    包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码。

MptForCausalLM 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

>>> import torch
>>> from transformers import AutoTokenizer, MptForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptForCausalLM.from_pretrained("mosaicml/mpt-7b")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

MptForSequenceClassification

class transformers.MptForSequenceClassification

< source >

( config: MptConfig )

参数

  • config(MptConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

MPT 模型变压器,顶部带有序列分类头(线性层)。

MptForSequenceClassification 使用最后一个标记来进行分类,就像其他因果模型(例如 GPT-1)一样。

由于它对最后一个标记进行分类,因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id,它会找到每一行中不是填充标记的最后一个标记。如果未定义pad_token_id,它会简单地取每一批行中的最后一个值。由于在传递inputs_embeds而不是input_ids时无法猜测填充标记,因此它会执行相同操作(取每批行中的最后一个值)。

这个模型继承自 PreTrainedModel。查看超类文档,了解库为所有模型实现的通用方法(如下载或保存,调整输入嵌入等)。

这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

< source >

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutputWithPast or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为(batch_size, input_ids_length)) — input_ids_length = sequence_length(如果past_key_valuesNone)否则past_key_values[0][0].shape[2](输入过去键值状态的sequence_length)。 词汇表中输入序列标记的索引。

    如果使用了past_key_values,则只能传递尚未计算其过去的input_ids作为input_ids

    可以使用 AutoTokenizer 获取索引。 有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • past_key_values (Tuple[Tuple[torch.Tensor]],长度为config.n_layers) — 包含由模型计算的预计算隐藏状态(注意力块中的键和值)(请参见下面的past_key_values输出)。 可用于加速顺序解码。 将其过去传递给此模型的input_ids不应作为input_ids传递,因为它们已经计算过。

    past_key_values的每个元素都是一个元组(past_key,past_value):

    • past_key: [batch_size * num_heads, head_dim, kv_length]

    • past_value: [batch_size * num_heads, kv_length, head_dim]

  • attention_mask (torch.FloatTensor,形状为(batch_size, sequence_length)可选) — 避免对填充标记索引执行注意力的掩码。 选择在[0, 1]范围内的掩码值:

    • 对于未被masked的标记为 1,

    • 对于被masked的标记为 0。

    什么是注意力掩码?

  • inputs_embeds (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)可选) — 可选地,可以直接传递嵌入表示而不是传递input_ids。 如果要更好地控制如何将input_ids索引转换为相关向量,这很有用,而不是使用模型的内部嵌入查找矩阵。

    如果使用了past_key_values,则可以选择仅输入最后的inputs_embeds(参见past_key_values)。

  • use_cache (bool可选) — 如果设置为True,则返回past_key_values键值状态,可用于加速解码(参见past_key_values)。

  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回张量下的attentions

  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的hidden_states

  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

  • labels (torch.LongTensor,形状为(batch_size,)可选) — 用于计算序列分类/回归损失的标签。 索引应在[0, ..., config.num_labels - 1]范围内。 如果config.num_labels == 1,则计算回归损失(均方损失),如果config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_outputs.SequenceClassifierOutputWithPasttuple(torch.FloatTensor)

一个transformers.modeling_outputs.SequenceClassifierOutputWithPast或一个torch.FloatTensor元组(如果传递了return_dict=Falseconfig.return_dict=False或输入)包含根据配置(MptConfig)和输入的不同元素。

  • 损失 (torch.FloatTensor,形状为(1,)可选,在提供labels时返回) — 分类(如果config.num_labels==1则为回归)损失。

  • logits (torch.FloatTensor,形状为(batch_size, config.num_labels)) — 分类(如果config.num_labels==1则为回归)得分(SoftMax 之前)。

  • past_key_values (tuple(tuple(torch.FloatTensor))可选,当传递use_cache=Trueconfig.use_cache=True时返回)— 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量)

    包含预先计算的隐藏状态(自注意力块中的键和值),可用于加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)— 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(用于嵌入的输出和每个层的输出)。

    每层模型输出的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。

MptForSequenceClassification 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

单标签分类示例:

>>> import torch
>>> from transformers import AutoTokenizer, MptForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptForSequenceClassification.from_pretrained("mosaicml/mpt-7b")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MptForSequenceClassification.from_pretrained("mosaicml/mpt-7b", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例:

>>> import torch
>>> from transformers import AutoTokenizer, MptForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptForSequenceClassification.from_pretrained("mosaicml/mpt-7b", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MptForSequenceClassification.from_pretrained(
...     "mosaicml/mpt-7b", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

MptForTokenClassification

class transformers.MptForTokenClassification

<来源>

( config: MptConfig )

参数

  • config(MptConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部具有标记分类头的 MPT 模型(隐藏状态输出的线性层),例如用于命名实体识别(NER)任务。

该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入等)。

该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **deprecated_arguments ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, input_ids_length)torch.LongTensor)— 如果past_key_valuesNone,则input_ids_length=sequence_length,否则input_ids_length=past_key_values[0][0].shape[2](输入过去键值状态的序列长度)。词汇表中输入序列标记的索引。

    如果使用past_key_values,只应传递尚未计算其过去的input_ids作为input_ids

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • past_key_values(长度为config.n_layersTuple[Tuple[torch.Tensor]])— 包含由模型计算的预计算隐藏状态(注意力块中的键和值),可用于加速顺序解码。将其过去传递给此模型的input_ids不应作为input_ids传递,因为它们已经计算过。

    past_key_values的每个元素都是一个元组(past_key,past_value):

    • past_key: [batch_size * num_heads, head_dim, kv_length]

    • past_value: [batch_size * num_heads, kv_length, head_dim]

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]范围内:

    • 对于未被掩码的标记为 1,

    • 对于被掩码的标记为 0。

    什么是注意力掩码?

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。

    如果使用了past_key_values,则可能只需输入最后的inputs_embeds(请参见past_key_values)。

  • use_cachebool可选)— 如果设置为True,将返回past_key_values键值状态,可用于加速解码(请参见past_key_values)。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。

  • labels(形状为(batch_size,)torch.LongTensor可选)— 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1,则计算回归损失(均方损失),如果config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_outputs.TokenClassifierOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor元组(如果传递了return_dict=False或当config.return_dict=False时),包括根据配置(MptConfig)和输入的不同元素。

  • loss(形状为(1,)torch.FloatTensor可选,在提供labels时返回)— 分类损失。

  • logits(形状为(batch_size, sequence_length, config.num_labels)torch.FloatTensor)— 分类分数(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或者config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出加上每一层的输出)。

    模型在每一层输出的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选的, 当传递output_attentions=True或者config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

MptForTokenClassification 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MptForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptForTokenClassification.from_pretrained("mosaicml/mpt-7b")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

MptForQuestionAnswering

class transformers.MptForQuestionAnswering

<来源>

( config )

参数

  • config (MptConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法来加载模型权重。

MPT 模型变压器,在顶部具有用于提取问答任务的跨度分类头,如 SQuAD(在隐藏状态输出顶部的线性层,用于计算跨度起始对数跨度结束对数)。

这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存,调整输入嵌入等)。

这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

  • input_ids (torch.LongTensor,形状为(batch_size, input_ids_length)) — input_ids_length = sequence_length,如果past_key_valuesNone,否则为past_key_values[0][0].shape[2](输入过去键值状态的序列长度)。输入序列标记在词汇表中的索引。

    如果使用past_key_values,则只有那些没有计算过去的input_ids应该作为input_ids传递。

    可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

    什么是输入 ID?

  • past_key_values(长度为config.n_layersTuple[Tuple[torch.Tensor]])— 包含由模型计算的预计算隐藏状态(注意力块中的键和值)(请参阅下面的past_key_values输出)。可用于加速顺序解码。已经给出其过去的input_ids不应作为input_ids传递给此模型,因为它们已经计算过了。

    past_key_values的每个元素都是一个元组(past_key,past_value):

    • past_key: [batch_size * num_heads, head_dim, kv_length]

    • past_value: [batch_size * num_heads, kv_length, head_dim]

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间:

    • 1 表示未被掩码的标记,

    • 0 表示被掩码的标记。

    什么是注意力掩码?

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,可以直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制权,以便将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

    如果使用past_key_values,则可以选择仅输入最后的inputs_embeds(请参阅past_key_values)。

  • use_cachebool可选)— 如果设置为True,则会返回past_key_values键值状态,并可用于加速解码(请参阅past_key_values)。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量中的attentions

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量中的hidden_states

  • return_dictbool可选)— 是否返回一个 ModelOutput 而不是一个普通的元组。

  • start_positions(形状为(batch_size,)torch.LongTensor可选)— 用于计算标记跨度开始位置(索引)的标签,以计算标记分类损失。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会被考虑在内以计算损失。

  • end_positions(形状为(batch_size,)torch.LongTensor可选)— 用于计算标记跨度结束位置(索引)的标签,以计算标记分类损失。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会被考虑在内以计算损失。

MptForQuestionAnswering 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。

MRA

原始文本:huggingface.co/docs/transformers/v4.37.2/en/model_doc/mra

概述

MRA 模型由 Zhanpeng Zeng、Sourav Pal、Jeffery Kline、Glenn M Fung 和 Vikas Singh 在Multi Resolution Analysis (MRA) for Approximate Self-Attention中提出。

论文摘要如下:

Transformer 已成为自然语言处理和视觉中许多任务的首选模型。最近关于更有效地训练和部署 Transformer 的努力已经确定了许多近似自注意力矩阵的策略,这是 Transformer 架构中的关键模块。有效的想法包括各种预定义的稀疏模式、低秩基扩展以及它们的组合。在本文中,我们重新审视了经典的多分辨率分析(MRA)概念,如小波,其在这种设置中的潜在价值迄今为止尚未得到充分探索。我们展示了基于经验反馈和现代硬件以及实现挑战所指导的设计选择的简单近似,最终产生了一个基于 MRA 的自注意力方法,其在大多数感兴趣的标准上具有出色的性能。我们进行了大量实验,并证明这种多分辨率方案优于大多数高效的自注意力提议,并且对于短序列和长序列都是有利的。代码可在github.com/mlpen/mra-attention找到。

该模型由novice03贡献。原始代码可在此处找到。

MraConfig

class transformers.MraConfig

<来源>

( vocab_size = 50265 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 1 initializer_range = 0.02 layer_norm_eps = 1e-05 position_embedding_type = 'absolute' block_per_row = 4 approx_mode = 'full' initial_prior_first_n_blocks = 0 initial_prior_diagonal_n_blocks = 0 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

  • vocab_size (int, 可选, 默认为 50265) — Mra 模型的词汇表大小。定义了在调用 MraModel 时可以表示的不同标记的数量。

  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。

  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数。

  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。

  • intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。

  • hidden_act (strfunction, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu""relu""selu""gelu_new"

  • hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

  • attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。

  • max_position_embeddings (int, 可选, 默认为 512) — 该模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一(例如 512、1024 或 2048)。

  • type_vocab_size (int, 可选, 默认为 1) — 在调用 MraModel 时传递的token_type_ids的词汇表大小。

  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • layer_norm_eps (float, 可选, 默认为 1e-5) — 层归一化层使用的 epsilon。

  • position_embedding_type (str, optional, 默认为"absolute") — 位置嵌入的类型。选择"absolute""relative_key""relative_key_query"之一。

  • block_per_row (int, optional, 默认为 4) — 用于设置高分辨率比例的预算。

  • approx_mode (str, optional, 默认为"full") — 控制是否同时使用低分辨率和高分辨率的近似。设置为"full"表示同时使用低分辨率和高分辨率,设置为"sparse"表示仅使用低分辨率。

  • initial_prior_first_n_blocks (int, optional, 默认为 0) — 使用高分辨率的初始块数。

  • initial_prior_diagonal_n_blocks (int, optional, 默认为 0) — 使用高分辨率的对角块数。

这是用于存储 MraModel 配置的类。它用于根据指定的参数实例化一个 MRA 模型,定义模型架构。使用默认值实例化配置将产生类似于 Mra uw-madison/mra-base-512-4 架构的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

>>> from transformers import MraConfig, MraModel

>>> # Initializing a Mra uw-madison/mra-base-512-4 style configuration
>>> configuration = MraConfig()

>>> # Initializing a model (with random weights) from the uw-madison/mra-base-512-4 style configuration
>>> model = MraModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

MraModel

class transformers.MraModel

<来源>

( config )

参数

  • config (MraConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

裸的 MRA 模型变压器输出原始隐藏状态,没有特定的头部。这个模型是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间:

    • 对于未被masked的标记为 1,

    • 对于被masked的标记为 0。

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]之间:

    • 0 对应于 句子 A 标记,

    • 1 对应于 句子 B 标记。

    什么是标记类型 ID?

  • position_ids(形状为(batch_size, sequence_length)torch.LongTensor可选)- 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

    什么是位置 ID?

  • head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)- 用于使自注意力模块中选择的头部失效的掩码。选择的掩码值在[0, 1]中。

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)- 可选地,您可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • output_hidden_statesbool可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dictbool可选)- 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithCrossAttentions 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithCrossAttentions 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置(MraConfig)和输入的不同元素。

  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor)- 模型最后一层的隐藏状态序列输出。

  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。

    模型在每一层的输出隐藏状态加上可选的初始嵌入输出。

  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

  • cross_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.add_cross_attention=Trueconfig.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

MraModel 的前向方法,覆盖__call__特殊方法。

虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是在此之后调用,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MraModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/mra-base-512-4")
>>> model = MraModel.from_pretrained("uw-madison/mra-base-512-4")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

MraForMaskedLM

class transformers.MraForMaskedLM

<来源>

( config )

参数

  • config (MraConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。

具有顶部 语言建模 的 MRA 模型。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列令牌的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 用于避免在填充令牌索引上执行注意力的掩码。掩码值在 [0, 1] 中选择。

    • 1 表示 未掩码 的令牌,

    • 0 表示被 掩码 的令牌。

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 段令牌索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

    • 0 对应于 句子 A 的令牌,

    • 1 对应于 句子 B 的令牌。

    什么是令牌类型 ID?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 每个输入序列令牌在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID?

  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头部是 未掩码

    • 0 表示头部被 掩码

  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您想要更多控制权,以便将 input_ids 索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states

  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

  • labels (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中(请参阅 input_ids 文档字符串)。索引设置为 -100 的令牌将被忽略(掩码),损失仅计算具有标签在 [0, ..., config.vocab_size] 中的令牌。

返回

transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或者一个torch.FloatTensor元组(如果传递return_dict=False或者config.return_dict=False)包含各种元素,取决于配置(MraConfig)和输入。

  • loss (torch.FloatTensor,形状为(1,)可选的,当提供labels时返回) — 掩码语言建模(MLM)损失。

  • logits (torch.FloatTensor,形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。

  • hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或者config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(一个用于嵌入的输出,如果模型有一个嵌入层,+ 一个用于每一层的输出)。

    模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选的,当传递output_attentions=True或者config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

MraForMaskedLM 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MraForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/mra-base-512-4")
>>> model = MraForMaskedLM.from_pretrained("uw-madison/mra-base-512-4")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

MraForSequenceClassification

class transformers.MraForSequenceClassification

<来源>

( config )

参数

  • config (MraConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

MRA 模型变压器,顶部带有一个序列分类/回归头(一个线性层在池化输出的顶部),例如用于 GLUE 任务。这个模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

前向

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为(batch_size, sequence_length)可选的) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间:

    • 对于未被掩码的标记为 1,

    • 对于被掩码的标记为 0。

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor,形状为(batch_size, sequence_length)可选) — 段标记索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

    • 0 对应于 句子 A 标记,

    • 1 对应于 句子 B 标记。

    什么是标记类型 ID?

  • position_ids (torch.LongTensor,形状为(batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID?

  • head_mask (torch.FloatTensor,形状为(num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头部未被“掩码”,

    • 0 表示头部被“掩码”。

  • inputs_embeds (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。

  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states

  • return_dict (bool可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

  • labels (torch.LongTensor,形状为(batch_size,)可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1,则计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组(如果传递 return_dict=Falseconfig.return_dict=False 时)包含各种元素,取决于配置(MraConfig)和输入。

  • loss (torch.FloatTensor,形状为(1,)可选,当提供 labels 时返回) — 分类(如果 config.num_labels==1 则为回归)损失。

  • logits (torch.FloatTensor,形状为(batch_size, config.num_labels)) — 分类(如果 config.num_labels==1 则为回归)分数(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size)torch.FloatTensor 元组(如果模型有嵌入层的输出,则为一个 + 每个层的输出)。

    每层模型的隐藏状态加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor 元组(每层一个)。

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

MraForSequenceClassification 的前向方法,覆盖 __call__ 特殊方法。

虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行前处理和后处理步骤,而后者则默默地忽略它们。

单标签分类示例:

>>> import torch
>>> from transformers import AutoTokenizer, MraForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/mra-base-512-4")
>>> model = MraForSequenceClassification.from_pretrained("uw-madison/mra-base-512-4")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MraForSequenceClassification.from_pretrained("uw-madison/mra-base-512-4", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例:

>>> import torch
>>> from transformers import AutoTokenizer, MraForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/mra-base-512-4")
>>> model = MraForSequenceClassification.from_pretrained("uw-madison/mra-base-512-4", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MraForSequenceClassification.from_pretrained(
...     "uw-madison/mra-base-512-4", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

MraForMultipleChoice

class transformers.MraForMultipleChoice

<来源>

( config )

参数

  • config(MraConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

具有多选分类头部的 MRA 模型(池化输出顶部的线性层和 softmax),例如用于 RocStories/SWAG 任务。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, num_choices, sequence_length)torch.LongTensor)— 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    输入 ID 是什么?

  • attention_mask(形状为(batch_size, num_choices, sequence_length)torch.FloatTensor可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]中:

    • 1 表示未被masked的标记,

    • 0 表示被masked的标记。

    注意力掩码是什么?

  • token_type_ids(形状为(batch_size, num_choices, sequence_length)torch.LongTensor可选)— 段标记索引,指示输入的第一部分和第二部分。索引选定在[0, 1]中:

    • 0 对应于句子 A标记,

    • 1 对应于句子 B标记。

    什么是标记类型 ID?

  • position_ids(形状为(batch_size, num_choices, sequence_length)torch.LongTensor可选)— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

    位置 ID 是什么?

  • head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中:

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • inputs_embeds(形状为(batch_size, num_choices, sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量,而不是模型的内部嵌入查找矩阵,则这很有用。

  • output_hidden_states(布尔值,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。

  • labels(形状为(batch_size,)torch.LongTensor可选)— 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内,其中num_choices是输入张量第二维的大小。(参见上面的input_ids

返回

transformers.modeling_outputs.MultipleChoiceModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False,则返回)包含根据配置(MraConfig)和输入的不同元素。

  • loss(形状为(1,)torch.FloatTensor可选,当提供labels时返回)— 分类损失。

  • logits(形状为(batch_size, num_choices)torch.FloatTensor)— num_choices是输入张量的第二维。(参见input_ids

    分类得分(SoftMax 之前)。

  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)— 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组。

    模型在每个层的输出的隐藏状态,以及可选的初始嵌入输出。

  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组。

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

MraForMultipleChoice 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MraForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/mra-base-512-4")
>>> model = MraForMultipleChoice.from_pretrained("uw-madison/mra-base-512-4")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

MraForTokenClassification

class transformers.MraForTokenClassification

<来源>

( config )

参数

  • config(MraConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

MRA 模型在顶部带有一个标记分类头部(隐藏状态输出的线性层),例如用于命名实体识别(NER)任务。这个模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 输入序列标记在词汇表中的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择:

    • 1 表示未被masked的标记,

    • 0 表示被masked的标记。

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引,指示输入的第一部分和第二部分。索引在[0, 1]中选择:

    • 0 对应于句子 A标记,

    • 1 对应于句子 B标记。

    什么是标记类型 ID?

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

    什么是位置 ID?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择:

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地,可以直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

  • labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。

返回

transformers.modeling_outputs.TokenClassifierOutput 或者tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或者一个torch.FloatTensor元组(如果传递return_dict=False或者config.return_dict=False时)包含各种元素,取决于配置(MraConfig)和输入。

  • loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 分类损失。

  • logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类分数(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或者config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组。

    模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    在注意力 softmax 之后的注意力权重,用于计算自注意力头部中的加权平均值。

MraForTokenClassification 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MraForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/mra-base-512-4")
>>> model = MraForTokenClassification.from_pretrained("uw-madison/mra-base-512-4")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

MraForQuestionAnswering

class transformers.MraForQuestionAnswering

<来源>

( config )

参数

  • config(MraConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

具有顶部跨度分类头部的 MRA 模型,用于类似 SQuAD 的抽取式问答任务(在隐藏状态输出顶部的线性层上计算span start logitsspan end logits)。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 词汇表中输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]范围内:

    • 1 表示未被masked的标记,

    • 0 表示被masked的标记。

    什么是注意力掩码?

  • token_type_ids(形状为(batch_size, sequence_length)torch.LongTensor可选)— 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]内:

    • 0 对应于句子 A标记,

    • 1 对应于句子 B标记。

    什么是标记类型 ID?

  • position_ids(形状为(batch_size, sequence_length)torch.LongTensor可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]内。

    什么是位置 ID?

  • head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]范围内:

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • inputs_embeds (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)optional) — 可选地,可以直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

  • start_positions (torch.LongTensor,形状为(batch_size,)optional) — 用于计算标记跨度的开始位置(索引)的标签。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会计入损失计算。

  • end_positions (torch.LongTensor,形状为(batch_size,)optional) — 用于计算标记跨度的结束位置(索引)的标签。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会计入损失计算。

返回

transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含各种元素,具体取决于配置(MraConfig)和输入。

  • loss (torch.FloatTensor,形状为(1,)optional,当提供labels时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。

  • start_logits (torch.FloatTensor,形状为(batch_size, sequence_length)) — 跨度开始得分(SoftMax 之前)。

  • end_logits (torch.FloatTensor,形状为(batch_size, sequence_length)) — 跨度结束得分(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor)optional,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。

    模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    注意力权重经过注意力 softmax 后,用于计算自注意力头中的加权平均值。

MraForQuestionAnswering 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MraForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("uw-madison/mra-base-512-4")
>>> model = MraForQuestionAnswering.from_pretrained("uw-madison/mra-base-512-4")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

mT5

原始文本:huggingface.co/docs/transformers/v4.37.2/en/model_doc/mt5

模型 空间

概述

mT5 模型在Linting Xue, Noah Constant, Adam Roberts, Mihir Kale, Rami Al-Rfou, Aditya Siddhant, Aditya Barua, Colin Raffel 撰写的“mT5: A massively multilingual pre-trained text-to-text transformer”中提出。

论文摘要如下:

最近的“文本到文本转换 Transformer”(T5)利用了统一的文本到文本格式和规模,在各种英语自然语言处理任务中取得了最先进的结果。在本文中,我们介绍了 mT5,这是 T5 的多语言变体,它在基于新的 Common Crawl 数据集上进行了预训练,涵盖了 101 种语言。我们详细介绍了 mT5 的设计和修改训练,并展示了它在许多多语言基准测试中的最先进性能。我们还描述了一种简单的技术,以防止在零样本设置中“意外翻译”,在这种情况下,生成模型选择将其预测(部分)翻译成错误的语言。本文中使用的所有代码和模型检查点都是公开可用的。

注意:mT5 仅在mC4上进行了预训练,不包括任何监督训练。因此,该模型在用于下游任务之前必须进行微调,与原始 T5 模型不同。由于 mT5 是无监督预训练的,因此在单任务微调期间使用任务前缀没有真正的优势。如果进行多任务微调,应该使用前缀。

Google 发布了以下变体:

此模型由patrickvonplaten贡献。原始代码可以在这里找到。

资源

  • 翻译任务指南

  • 摘要任务指南

MT5 配置

class transformers.MT5Config

<来源>

( vocab_size = 250112 d_model = 512 d_kv = 64 d_ff = 1024 num_layers = 8 num_decoder_layers = None num_heads = 6 relative_attention_num_buckets = 32 relative_attention_max_distance = 128 dropout_rate = 0.1 layer_norm_epsilon = 1e-06 initializer_factor = 1.0 feed_forward_proj = 'gated-gelu' is_encoder_decoder = True use_cache = True tokenizer_class = 'T5Tokenizer' tie_word_embeddings = False pad_token_id = 0 eos_token_id = 1 decoder_start_token_id = 0 classifier_dropout = 0.0 **kwargs )

参数

  • vocab_size (int, 可选, 默认为 250112) — T5 模型的词汇大小。定义了在调用 T5Model 或 TFT5Model 时可以表示的不同标记数量。

  • d_model (int, 可选, 默认为 512) — 编码器层和池化层的大小。

  • d_kv (int, 可选, 默认为 64) — 每个注意力头中键、查询、值投影的大小。在传统上下文中,通常期望d_kv等于d_model // num_heads。但在 mt5-small 的架构中,d_kv不等于d_model // num_heads。投影层的inner_dim将定义为num_heads * d_kv

  • d_ff (int, 可选, 默认为 1024) — 每个T5Block中的中间前馈层的大小。

  • num_layers (int, 可选, 默认为 8) — Transformer 编码器中的隐藏层数量。

  • num_decoder_layers (int, 可选) — Transformer 解码器中的隐藏层数量。如果未设置,将使用与num_layers相同的值。

  • num_heads (int, 可选, 默认为 6) — Transformer 编码器中每个注意力层的注意力头数量。

  • relative_attention_num_buckets (int, 可选, 默认为 32) — 每个注意力层使用的桶数。

  • relative_attention_max_distance (int, 可选, 默认为 128) — 用于桶分离的较长序列的最大距离。

  • dropout_rate (float, 可选, 默认为 0.1) — 所有丢弃层的比率。

  • classifier_dropout (float, 可选, 默认为 0.0) — 分类器的丢弃比率。

  • layer_norm_eps (float, 可选, 默认为 1e-6) — 层归一化层使用的 epsilon。

  • initializer_factor (float, 可选, 默认为 1) — 用于初始化所有权重矩阵的因子(应保持为 1,用于内部初始化测试)。

  • feed_forward_proj (string, 可选, 默认为 "gated-gelu") — 要使用的前馈层类型。应为 "relu""gated-gelu" 之一。

  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。

这是用于存储 MT5Model 或 TFMT5Model 配置的配置类。它用于根据指定的参数实例化一个 mT5 模型,定义模型架构。使用默认值实例化配置将产生类似于 mT5 google/mt5-small 架构的配置。

配置对象继承自 PretrainedConfig 并可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

MT5Tokenizer

class transformers.T5Tokenizer

< source >

( vocab_file eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' extra_ids = 100 additional_special_tokens = None sp_model_kwargs: Optional = None legacy = None **kwargs )

参数

  • vocab_file (str) — 包含实例化分词器所需词汇的 SentencePiece 文件(通常具有 .spm 扩展名)。

  • eos_token (str, 可选, 默认为 "</s>") — 序列结束标记。

    在使用特殊标记构建序列时,这不是用于序列结束的标记。使用的标记是 sep_token

  • unk_token (str, 可选, 默认为 "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID,而是设置为此标记。

  • pad_token (str, 可选, 默认为 "<pad>") — 用于填充的标记,例如在批处理不同长度的序列时使用。

  • extra_ids (int, 可选, 默认为 100) — 添加一些额外的 id 到词汇表中以用作哨兵。这些标记可通过调用 get_sentinel_tokens 方法检索,标记 id 可通过调用 get_sentinel_token_ids 方法检索 additional_special_tokens (List[str], 可选): 分词器使用的其他特殊标记。

  • sp_model_kwargs (dict, 可选) — 将传递给 SentencePieceProcessor.__init__() 方法的参数。SentencePiece 的 Python 封装 可以用于设置以下内容之一:

    • enable_sampling: 启用子词正则化。

    • nbest_size: unigram 的抽样参数。对于 BPE-Dropout 无效。

      • nbest_size = {0,1}: 不执行抽样。

      • nbest_size > 1: 从 nbest_size 结果中抽样。

      • nbest_size < 0: 假设 nbest_size 为无限,并使用前向过滤和后向抽样算法从所有假设(格)中抽样。

    • alpha:用于 unigram 采样的平滑参数,以及 BPE-dropout 的合并操作的丢弃概率。

  • legacy (bool, 可选) — 是否应该使用分词器的legacy行为。Legacy 是在合并#24622 和#25224 之前的版本,其中包括修复以正确处理出现在特殊标记之后的标记的问题。一个简单的例子:

    • legacy=True:

构建一个 T5 分词器。基于SentencePiece

此分词器继承自 PreTrainedTokenizer,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<源代码>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。

  • token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

返回

List[int]

带有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记,从序列或序列对构建用于序列分类任务的模型输入。序列的格式如下:

  • 单个序列:X </s>

  • 序列对:A </s> B </s>

convert_tokens_to_string

<源代码>

( tokens )

将标记序列(字符串)转换为单个字符串。

create_token_type_ids_from_sequences

<源代码>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。

  • token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

返回

List[int]

零列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。T5 不使用标记类型 ID,因此返回一个零列表。

get_special_tokens_mask

<源代码>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。

  • token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

  • already_has_special_tokens (bool, 可选, 默认为 False) — 标记列表是否已经格式化为模型的特殊标记。

返回

List[int]

一个整数列表,范围为[0, 1]:1 表示特殊标记,0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。在使用分词器的prepare_for_model方法添加特殊标记时调用此方法。

tokenize

<源代码>

( text: TextInput add_special_tokens = False **kwargs )

将字符串转换为标记列表。如果self.legacy设置为False,则会添加前缀标记,除非第一个标记是特殊标记。

有关所有详细信息,请参阅 T5Tokenizer。

MT5TokenizerFast

class transformers.T5TokenizerFast

<源代码>

( vocab_file = None tokenizer_file = None eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' extra_ids = 100 additional_special_tokens = None **kwargs )

参数

  • vocab_file (str) — 包含实例化分词器所需词汇表的SentencePiece文件(通常具有.spm扩展名)。

  • eos_token (str, 可选, 默认为 "</s>") — 序列结束标记。

    在使用特殊标记构建序列时,这不是用于序列结束的标记。使用的标记是sep_token

  • unk_token (str, 可选, 默认为"<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID,而是设置为此标记。

  • pad_token (str, 可选, 默认为"<pad>") — 用于填充的标记,例如在批处理不同长度的序列时使用。

  • extra_ids (int, 可选, 默认为 100) — 添加一些额外的 id 到词汇表中,用作标记。这些标记可以通过调用 get_sentinel_tokens 方法检索,通过调用 get_sentinel_token_ids 方法获取标记 id

  • additional_special_tokens (List[str], 可选) — 分词器使用的额外特殊标记。

构建一个“快速”T5 分词器(由 HuggingFace 的tokenizers库支持)。基于Unigram

此分词器继承自 PreTrainedTokenizerFast,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — 将特殊标记添加到的 id 列表。

  • token_ids_1 (List[int], 可选) — 第二个序列对的可选 id 列表。

返回

List[int]

具有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记从一个序列或一个序列对构建用于序列分类任务的模型输入。一个序列的格式如下:

  • 单个序列:X </s>

  • 序列对:A </s> B </s>

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — id 列表。

  • token_ids_1 (List[int], 可选) — 第二个序列对的可选 id 列表。

返回

List[int]

零的列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。T5 不使用标记类型 id,因此返回一个零的列表。

查看 T5TokenizerFast 获取所有细节。

Pytorch 隐藏了 Pytorch 内容

MT5Model

class transformers.MT5Model

<来源>

( config: MT5Config )

参数

  • config (MT5Config) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

裸 MT5 模型 Transformer 输出原始隐藏状态,没有特定的头部。

MT5 模型由 Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu 在探索统一文本到文本 Transformer 的迁移学习极限中提出。它是一个在文本到文本去噪生成环境中预训练的编码器解码器 Transformer。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

该模型也是 PyTorch torch.nn.Module的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

示例:

>>> from transformers import MT5Model, AutoTokenizer

>>> model = MT5Model.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, return_tensors="pt")
>>> labels = tokenizer(text_target=summary, return_tensors="pt")

>>> outputs = model(input_ids=inputs["input_ids"], decoder_input_ids=labels["input_ids"])
>>> hidden_states = outputs.last_hidden_state

deparallelize

<来源>

( )

将模型从模型并行状态移动到 CPU。

示例:

# On a 4 GPU machine with mt5-xl:
model = MT5ForConditionalGeneration.from_pretrained("Mt5-xl")
device_map = {
    0: [0, 1, 2],
    1: [3, 4, 5, 6, 7, 8, 9],
    2: [10, 11, 12, 13, 14, 15, 16],
    3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map)  # Splits the model across several devices
model.deparallelize()  # Put the model back on cpu and cleans memory by calling torch.cuda.empty_cache()

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 输入序列标记在词汇表中的索引。MT5 是一个带有相对位置嵌入的模型,因此您应该能够在右侧和左侧填充输入。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

    要了解有关如何为预训练准备input_ids的更多信息,请查看 MT5 训练。

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)— 避免在填充标记索引上执行注意力的膜。膜值选择在[0, 1]范围内:

    • 1 表示标记未被遮蔽,

    • 0 表示标记被遮蔽。

    什么是注意力膜?

  • decoder_input_ids(形状为(batch_size, target_sequence_length)torch.LongTensor可选)— 解码器输入序列标记在词汇表中的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID?

    MT5 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values,则可以选择仅输入最后的decoder_input_ids(参见past_key_values)。

    要了解有关如何为预训练准备decoder_input_ids的更多信息,请查看 MT5 训练。

  • decoder_attention_mask(形状为(batch_size, target_sequence_length)torch.BoolTensor可选)— 默认行为:生成一个忽略decoder_input_ids中填充标记的张量。因果膜也将默认使用。

  • head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于在编码器中使自注意力模块的选定头部失效的膜。膜值选择在[0, 1]范围内。

    • 1 表示头部未被遮蔽,

    • 0 表示头部被遮蔽。

  • decoder_head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于在解码器中使自注意力模块的选定头部失效的膜。膜值选择在[0, 1]范围内:

    • 1 表示头部未被遮蔽,

    • 0 表示头部被遮蔽。

  • cross_attn_head_mask(形状为(num_heads,)(num_layers, num_heads)torch.Tensor可选)— 用于在解码器中使交叉注意力模块的选定头部失效的膜。膜值选择在[0, 1]范围内:

    • 1 表示头部未被遮蔽,

    • 0 表示头部被遮蔽。

  • encoder_outputstuple(tuple(torch.FloatTensor)可选)— 元组由(last_hidden_state可选hidden_states可选attentions)组成,last_hidden_state的形状为(batch_size, sequence_length, hidden_size),是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

  • past_key_values(长度为config.n_layerstuple(tuple(torch.FloatTensor)),每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量)— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

    如果使用past_key_values,用户可以选择仅输入最后的decoder_input_ids(即那些没有将它们的过去键值状态提供给此模型的)形状为(batch_size, 1),而不是形状为(batch_size, sequence_length)的所有decoder_input_ids

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • decoder_inputs_embeds(形状为(batch_size, target_sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递decoder_input_ids。如果使用past_key_values,可选地只需输入最后的decoder_inputs_embeds(参见past_key_values)。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

    如果decoder_input_idsdecoder_inputs_embeds都未设置,则decoder_inputs_embedsinputs_embeds的值。

  • use_cachebool可选)— 如果设置为True,则返回past_key_values键值状态,并可用于加速解码(参见past_key_values)。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states

  • return_dictbool可选)— 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_outputs.Seq2SeqModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个torch.FloatTensor元组(如果传递了return_dict=Falseconfig.return_dict=False时)包含各种元素,这取决于配置(MT5Config)和输入。

  • last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor)— 模型解码器最后一层的隐藏状态序列。

    如果仅使用past_key_values,则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

  • past_key_valuestuple(tuple(torch.FloatTensor))可选,当传递use_cache=Trueconfig.use_cache=True时返回)— 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参见past_key_values输入)。

  • decoder_hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=True或当config.output_hidden_states=True时返回)—形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层的输出一个,+每个层的输出一个)。

    每层解码器的隐藏状态加上可选的初始嵌入输出。

  • decoder_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回)—形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

  • cross_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回)—形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

  • encoder_last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)—模型编码器最后一层的隐藏状态序列。

  • encoder_hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=True或当config.output_hidden_states=True时返回)—形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层的输出一个,+每个层的输出一个)。

    每层编码器的隐藏状态加上可选的初始嵌入输出。

  • encoder_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回)—形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

MT5Model 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是在此之后调用,因为前者负责运行前处理和后处理步骤,而后者则默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MT5Model

>>> tokenizer = AutoTokenizer.from_pretrained("mt5-small")
>>> model = MT5Model.from_pretrained("mt5-small")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids  # Batch size 1

>>> # preprocess: Prepend decoder_input_ids with start token which is pad token for MT5Model.
>>> # This is not needed for torch's MT5ForConditionalGeneration as it does this internally using labels arg.
>>> decoder_input_ids = model._shift_right(decoder_input_ids)

>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state

parallelize

< source >

( device_map = None )

参数

  • device_mapDict[int, list],可选,默认为 None)—将注意力模块映射到设备的字典。请注意,嵌入模块和 LMHead 始终自动映射到第一个设备(出于奇特的原因)。这意味着第一个设备应该比其他设备有更少的注意力模块映射到它。作为参考,mt5 模型具有以下数量的注意力模块:

    • mt5-small: 6

    • mt5-base: 12

    • mt5-large: 24

    • mt5-xl: 24

    • mt5-xxl: 24

这是一个实验性功能,随时可能更改。

使用设备映射将模型的注意力模块分布到多个设备上。如果没有给出设备映射,它将均匀地将块分布到所有设备上。

示例:

# Here is an example of a device map on a machine with 4 GPUs using mt5-xl, which has a total of 24 attention modules:
model = MT5ForConditionalGeneration.from_pretrained("mt5-xl")
device_map = {
    0: [0, 1, 2],
    1: [3, 4, 5, 6, 7, 8, 9],
    2: [10, 11, 12, 13, 14, 15, 16],
    3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map)

MT5ForConditionalGeneration

class transformers.MT5ForConditionalGeneration

<来源>

( config: MT5Config )

参数

  • config(MT5Config)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

带有顶部语言建模头的 MT5 模型。

MT5 模型是由 Colin Raffel、Noam Shazeer、Adam Roberts、Katherine Lee、Sharan Narang、Michael Matena、Yanqi Zhou、Wei Li、Peter J. Liu 在探索统一文本到文本 Transformer 的迁移学习极限中提出的。它是一个在文本到文本去噪生成设置中预训练的编码器解码器 Transformer。

此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

示例:

>>> from transformers import MT5ForConditionalGeneration, AutoTokenizer

>>> model = MT5ForConditionalGeneration.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, text_target=summary, return_tensors="pt")

>>> outputs = model(**inputs)
>>> loss = outputs.loss

deparallelize

<来源>

( )

将模型从模型并行状态移动到 CPU。

示例:

# On a 4 GPU machine with mt5-xl:
model = MT5ForConditionalGeneration.from_pretrained("Mt5-xl")
device_map = {
    0: [0, 1, 2],
    1: [3, 4, 5, 6, 7, 8, 9],
    2: [10, 11, 12, 13, 14, 15, 16],
    3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map)  # Splits the model across several devices
model.deparallelize()  # Put the model back on cpu and cleans memory by calling torch.cuda.empty_cache()

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)- 词汇表中输入序列标记的索引。MT5 是一个具有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。

    可以使用 AutoTokenizer 获取索引。详细信息请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    输入 ID 是什么?

    要了解有关如何为预训练准备input_ids的更多信息,请查看 MT5 Training。

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中:

    • 对于未被“masked”的标记为 1。

    • 对于被masked的标记为 0。

    什么是注意力掩码?

  • decoder_input_ids(形状为(batch_size, target_sequence_length)torch.LongTensor可选)- 词汇表中解码器输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。详细信息请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    解码器输入 ID 是什么?

    MT5 使用pad_token_id作为生成decoder_input_ids的起始标记。如果使用past_key_values,则只需选择最后的decoder_input_ids作为输入(参见past_key_values)。

    要了解有关如何为预训练准备decoder_input_ids的更多信息,请查看 MT5 Training。

  • decoder_attention_mask(形状为(batch_size, target_sequence_length)torch.BoolTensor可选)— 默认行为:生成一个张量,忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

  • head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于使编码器中自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间:

    • 1 表示头部未被“掩盖”,

    • 0 表示头部被“掩盖”。

  • decoder_head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于使解码器中自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间:

    • 1 表示头部未被“掩盖”,

    • 0 表示头部被“掩盖”。

  • cross_attn_head_mask(形状为(num_heads,)(num_layers, num_heads)torch.Tensor可选)— 用于使解码器中交叉注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间:

    • 1 表示头部未被“掩盖”,

    • 0 表示头部被“掩盖”。

  • encoder_outputstuple(tuple(torch.FloatTensor)可选)— 元组由(last_hidden_state可选hidden_states可选attentions)组成,last_hidden_state的形状为(batch_size, sequence_length, hidden_size),是编码器最后一层的输出的隐藏状态序列。用于解码器的交叉注意力。

  • past_key_values(长度为config.n_layerstuple(tuple(torch.FloatTensor)),每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量)— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

    如果使用了past_key_values,用户可以选择仅输入最后的decoder_input_ids(这些没有将它们的过去键值状态提供给此模型)的形状为(batch_size, 1),而不是形状为(batch_size, sequence_length)的所有decoder_input_ids

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。

  • decoder_inputs_embeds(形状为(batch_size, target_sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递decoder_input_ids。如果使用了past_key_values,则可以选择仅输入最后的decoder_inputs_embeds(请参阅past_key_values)。如果您希望更多地控制如何将decoder_input_ids索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。

    如果decoder_input_idsdecoder_inputs_embeds都未设置,则decoder_inputs_embedsinputs_embeds的值。

  • use_cachebool可选)— 如果设置为True,则返回past_key_values键值状态,并可用于加速解码(请参阅past_key_values)。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dictbool可选)— 是否返回 ModelOutput 而不是普通元组。

  • labels(形状为(batch_size,)torch.LongTensor可选)- 用于计算序列分类/回归损失的标签。索引应在[-100, 0, ..., config.vocab_size - 1]范围内。所有标签设置为-100都将被忽略(掩码),损失仅计算标签在[0, ..., config.vocab_size]范围内的情况。

返回

transformers.modeling_outputs.Seq2SeqLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置(MT5Config)和输入的不同元素。

  • loss(形状为(1,)torch.FloatTensor可选,当提供labels时返回)- 语言建模损失。

  • logits(形状为(batch_size, sequence_length, config.vocab_size)torch.FloatTensor)- 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。

  • past_key_valuestuple(tuple(torch.FloatTensor))可选,当传递use_cache=Trueconfig.use_cache=True时返回)- 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参见past_key_values输入)。

  • decoder_hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。

    解码器在每一层输出的隐藏状态加上初始嵌入输出。

  • decoder_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

  • cross_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

  • encoder_last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)- 模型编码器最后一层的隐藏状态序列。

  • encoder_hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。

    编码器在每一层输出的隐藏状态加上初始嵌入输出。

  • encoder_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=True或当config.output_attentions=True时返回)—形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

MT5ForConditionalGeneration 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module实例,而不是调用此函数,因为前者会负责运行前处理和后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MT5ForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("mt5-small")
>>> model = MT5ForConditionalGeneration.from_pretrained("mt5-small")

>>> # training
>>> input_ids = tokenizer("The <extra_id_0> walks in <extra_id_1> park", return_tensors="pt").input_ids
>>> labels = tokenizer("<extra_id_0> cute dog <extra_id_1> the <extra_id_2>", return_tensors="pt").input_ids
>>> outputs = model(input_ids=input_ids, labels=labels)
>>> loss = outputs.loss
>>> logits = outputs.logits

>>> # inference
>>> input_ids = tokenizer(
...     "summarize: studies have shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> outputs = model.generate(input_ids)
>>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
>>> # studies have shown that owning a dog is good for you.

parallelize

<来源>

( device_map = None )

参数

  • device_mapDict[int, list],可选,默认为 None)—将注意力模块映射到设备的字典。请注意,嵌入模块和 LMHead 始终会自动映射到第一个设备(出于奇怪的原因)。这意味着第一个设备应该比其他设备有更少的注意力模块映射到它。作为参考,mt5 模型具有以下数量的注意力模块:

    • mt5-small: 6

    • mt5-base: 12

    • mt5-large: 24

    • mt5-xl: 24

    • mt5-xxl: 24

这是一个实验性功能,随时可能更改。

使用设备映射将模型的注意力模块分布到多个设备上。如果没有给出设备映射,则将块均匀分布到所有设备上。

示例:

# Here is an example of a device map on a machine with 4 GPUs using mt5-xl, which has a total of 24 attention modules:
model = MT5ForConditionalGeneration.from_pretrained("mt5-xl")
device_map = {
    0: [0, 1, 2],
    1: [3, 4, 5, 6, 7, 8, 9],
    2: [10, 11, 12, 13, 14, 15, 16],
    3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map)

MT5EncoderModel

class transformers.MT5EncoderModel

<来源>

( config: MT5Config )

参数

  • config(MT5Config)—模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

MT5 模型是一个裸的 MT5 模型变换器,输出编码器的原始隐藏状态,没有任何特定的头部。

MT5 模型是由 Colin Raffel、Noam Shazeer、Adam Roberts、Katherine Lee、Sharan Narang、Michael Matena、Yanqi Zhou、Wei Li、Peter J. Liu 在探索统一文本到文本变换器的迁移学习极限中提出的。它是一个在文本到文本去噪生成设置中预训练的编码器解码器变换器。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

示例:

>>> from transformers import MT5EncoderModel, AutoTokenizer

>>> model = MT5EncoderModel.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> input_ids = tokenizer(article, return_tensors="pt").input_ids
>>> outputs = model(input_ids)
>>> hidden_state = outputs.last_hidden_state

deparallelize

<来源>

( )

将模型从模型并行状态移动到 CPU。

示例:

# On a 4 GPU machine with mt5-xl:
model = MT5ForConditionalGeneration.from_pretrained("Mt5-xl")
device_map = {
    0: [0, 1, 2],
    1: [3, 4, 5, 6, 7, 8, 9],
    2: [10, 11, 12, 13, 14, 15, 16],
    3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map)  # Splits the model across several devices
model.deparallelize()  # Put the model back on cpu and cleans memory by calling torch.cuda.empty_cache()

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)—词汇表中输入序列标记的索引。MT5 是一个具有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    要了解有关如何为预训练准备input_ids的更多信息,请查看 MT5 Training。

  • attention_mask (torch.FloatTensor,形状为(batch_size, sequence_length)可选) — 避免在填充令牌索引上执行注意力的掩码。选择的掩码值在[0, 1]中:

    • 对于未被掩盖的标记为 1,

    • 对于被掩盖的标记为 0。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor,形状为(num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中:

    • 1 表示头部未被掩盖,

    • 0 表示头部被掩盖。

  • inputs_embeds (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。

  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions

  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states

  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False时)包含根据配置(MT5Config)和输入的各种元素。

  • last_hidden_state (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出 + 每个层的输出)的形状为(batch_size, sequence_length, hidden_size)

    模型在每一层的输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回) — torch.FloatTensor元组(每个层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)

    在自注意力头中用于计算加权平均值的注意力 softmax 之后的注意力权重。

MT5EncoderModel 的前向方法覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MT5EncoderModel

>>> tokenizer = AutoTokenizer.from_pretrained("mt5-small")
>>> model = MT5EncoderModel.from_pretrained("mt5-small")
>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> outputs = model(input_ids=input_ids)
>>> last_hidden_states = outputs.last_hidden_state

parallelize

<来源>

( device_map = None )

参数

  • device_mapDict[int, list],可选,默认为 None)- 将注意力模块映射到设备的字典。请注意,嵌入模块和 LMHead 始终会自动映射到第一个设备(出于奇特的原因)。这意味着第一个设备应该比其他设备映射到更少的注意力模块。参考 mt5 模型具有以下数量的注意力模块:

    • mt5-small: 6

    • mt5-base: 12

    • mt5-large: 24

    • mt5-xl: 24

    • mt5-xxl: 24

这是一个实验性功能,随时可能更改。

使用设备映射将模型的注意力模块分布到多个设备上。如果没有给出设备映射,它将均匀分配块到所有设备上。

示例:

# Here is an example of a device map on a machine with 4 GPUs using mt5-xl, which has a total of 24 attention modules:
model = MT5ForConditionalGeneration.from_pretrained("mt5-xl")
device_map = {
    0: [0, 1, 2],
    1: [3, 4, 5, 6, 7, 8, 9],
    2: [10, 11, 12, 13, 14, 15, 16],
    3: [17, 18, 19, 20, 21, 22, 23],
}
model.parallelize(device_map)

MT5ForSequenceClassification

class transformers.MT5ForSequenceClassification

<来源>

( config: MT5Config )

参数

  • config(MT5Config)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。

带有顶部序列分类/头的 MT5 模型(汇总输出的顶部线性层),例如用于 GLUE 任务。

MT5 模型是由 Colin Raffel,Noam Shazeer,Adam Roberts,Katherine Lee,Sharan Narang,Michael Matena,Yanqi Zhou,Wei Li,Peter J. Liu 在探索统一文本到文本 Transformer 的迁移学习极限中提出的。它是一个在文本到文本去噪生成设置中预训练的编码器解码器 Transformer。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)- 词汇表中输入序列标记的索引。MT5 是一个具有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。

    可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()以获取详细信息。

    什么是输入 ID?

    要了解有关如何为预训练准备input_ids的更多信息,请查看 MT5 训练。

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)- 用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值:

    • 1 表示“未被掩码”的标记,

    • 0 表示“被掩码”的标记。

    什么是注意力掩码?

  • decoder_input_ids(形状为(batch_size, target_sequence_length)torch.LongTensor可选)- 解码器输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID?

    MT5 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values,则只需输入最后的decoder_input_ids(参见past_key_values)。

    要了解有关如何为预训练准备decoder_input_ids的更多信息,请查看 MT5 Training。

  • decoder_attention_mask (torch.BoolTensor of shape (batch_size, target_sequence_length), optional) — 默认行为:生成一个张量,忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于在编码器的自注意力模块中使选定头部失效的掩码。掩码值选定在[0, 1]之间:

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • decoder_head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于在解码器中使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]之间:

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • cross_attn_head_mask (torch.Tensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于在解码器中使交叉注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]之间:

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括(last_hidden_state可选hidden_states可选attentionslast_hidden_state的形状为(batch_size, sequence_length, hidden_size),是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

  • past_key_values (tuple(tuple(torch.FloatTensor)),长度为config.n_layers,每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

    如果使用past_key_values,用户可以选择仅输入最后的decoder_input_ids(这些没有将其过去的键值状态提供给此模型)的形状为(batch_size, 1),而不是所有形状为(batch_size, sequence_length)decoder_input_ids

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地,可以直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地,可以直接传递嵌入表示,而不是传递decoder_input_ids。如果使用past_key_values,则只需输入最后的decoder_inputs_embeds(参见past_key_values)。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

    如果decoder_input_idsdecoder_inputs_embeds都未设置,则decoder_inputs_embedsinputs_embeds的值。

  • use_cache (bool, optional) — 如果设置为True,将返回past_key_values键值状态,可用于加速解码(参见past_key_values)。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

  • labels (torch.LongTensor,形状为(batch_size,)optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置(MT5Config)和输入的不同元素。

  • loss (torch.FloatTensor,形状为(1,)optional,当提供label时返回) — 分类(如果config.num_labels==1则为回归)损失。

  • logits (torch.FloatTensor,形状为(batch_size, config.num_labels)) — 分类(如果config.num_labels==1则为回归)得分(SoftMax 之前)。

  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=Trueconfig.use_cache=True时返回) — 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参见past_key_values输入)。

  • decoder_hidden_states (tuple(torch.FloatTensor)optional,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组。

    解码器在每一层输出的隐藏状态加上初始嵌入输出。

  • decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组。

    解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组。

    解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

  • encoder_last_hidden_state (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)optional) — 模型编码器最后一层的隐藏状态序列。

  • encoder_hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)- 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型具有嵌入层的输出,则为一个+每层的输出一个)。

    编码器在每一层的隐藏状态加上初始嵌入输出。

  • encoder_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

MT5ForSequenceClassification 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。

MT5ForQuestionAnswering

class transformers.MT5ForQuestionAnswering

< source >

( config: MT5Config )

参数

  • config(MT5Config)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

具有用于提取问答任务的跨度分类头的 MT5 模型,例如 SQuAD(在隐藏状态输出之上的线性层,用于计算span start logitsspan end logits)。

MT5 模型是由 Colin Raffel,Noam Shazeer,Adam Roberts,Katherine Lee,Sharan Narang,Michael Matena,Yanqi Zhou,Wei Li,Peter J. Liu 在探索统一文本到文本 Transformer 的迁移学习极限中提出的。它是一个在文本到文本去噪生成设置中预训练的编码器解码器 Transformer。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None start_positions: Optional = None end_positions: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)- 词汇表中输入序列标记的索引。MT5 是一个具有相对位置嵌入的模型,因此您应该能够在右侧和左侧都填充输入。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

    了解如何为预训练准备input_ids,请查看 MT5 训练。

  • attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间:

    • 1 表示未被掩盖的标记,

    • 0 表示被掩盖的标记。

    什么是注意力掩码?

  • decoder_input_ids(形状为(batch_size, target_sequence_length)torch.LongTensor可选)— 词汇表中解码器输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID?

    MT5 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values,可以选择仅输入最后的decoder_input_ids(参见past_key_values)。

    了解如何为预训练准备decoder_input_ids,请查看 MT5 训练。

  • decoder_attention_mask(形状为(batch_size, target_sequence_length)torch.BoolTensor可选)— 默认行为:生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

  • head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于将编码器中自注意力模块的选定头部置零的掩码。掩码值选在[0, 1]之间:

    • 1 表示头部未被掩盖,

    • 0 表示头部被掩盖。

  • decoder_head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)— 用于将解码器中自注意力模块的选定头部置零的掩码。掩码值选在[0, 1]之间:

    • 1 表示头部未被掩盖,

    • 0 表示头部被掩盖。

  • cross_attn_head_mask(形状为(num_heads,)(num_layers, num_heads)torch.Tensor可选)— 用于将解码器中交叉注意力模块的选定头部置零的掩码。掩码值选在[0, 1]之间:

    • 1 表示头部未被掩盖,

    • 0 表示头部被掩盖。

  • encoder_outputstuple(tuple(torch.FloatTensor)可选)— 元组包括(last_hidden_state可选hidden_states可选attentionslast_hidden_state的形状为(batch_size, sequence_length, hidden_size),是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

  • past_key_values(长度为config.n_layerstuple(tuple(torch.FloatTensor)),每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量)— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

    如果使用了past_key_values,用户可以选择仅输入最后的decoder_input_ids(即没有将其过去键值状态提供给此模型的那些)的形状为(batch_size, 1)的张量,而不是形状为(batch_size, sequence_length)的所有decoder_input_ids

  • inputs_embeds(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)— 可选地,可以直接传递嵌入表示,而不是传递input_ids。如果您希望更好地控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

  • decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地,可以直接传递嵌入表示,而不是传递decoder_input_ids。如果使用了past_key_values,则只需输入最后的decoder_inputs_embeds(参见past_key_values)。如果要更好地控制如何将decoder_input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

    如果decoder_input_idsdecoder_inputs_embeds都未设置,则decoder_inputs_embedsinputs_embeds的值。

  • use_cache (bool, optional) — 如果设置为True,则返回past_key_values键值状态,并可用于加速解码(参见past_key_values)。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states

  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

  • start_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记范围的起始位置(索引)的标签,以计算标记分类损失。位置被夹紧到序列的长度(sequence_length)。超出序列范围的位置不会被考虑在内计算损失。

  • end_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记分类损失的标记范围的结束位置(索引)的标签。位置被夹紧到序列的长度(sequence_length)。超出序列范围的位置不会被考虑在内计算损失。

返回

transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置(MT5Config)和输入的不同元素。

  • loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 总跨度提取损失是起始和结束位置的交叉熵之和。

  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度开始得分(SoftMax 之前)。

  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度结束得分(SoftMax 之前)。

  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=Trueconfig.use_cache=True时返回) — 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见past_key_values输入)。

  • decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出 + 每个层的输出)的形状为(batch_size, sequence_length, hidden_size)

    解码器在每个层的输出以及初始嵌入输出的隐藏状态。

  • decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — torch.FloatTensor元组(每个层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)

    解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — torch.FloatTensor元组(每个层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)

    解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

  • encoder_last_hidden_state (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)optional) — 模型编码器最后一层的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出 + 每个层的输出)的形状为(batch_size, sequence_length, hidden_size)

    编码器在每个层的输出以及初始嵌入输出的隐藏状态。

  • encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — torch.FloatTensor元组(每个层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)

    编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

MT5ForQuestionAnswering 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。

TensorFlowHide TensorFlow content

TFMT5Model

class transformers.TFMT5Model

< source >

( *args **kwargs )

此类覆盖 TFT5Model。请查看超类以获取适当的文档和用法示例。

示例:

>>> from transformers import TFMT5Model, AutoTokenizer

>>> model = TFMT5Model.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, return_tensors="tf")
>>> labels = tokenizer(text_target=summary, return_tensors="tf")

>>> outputs = model(input_ids=inputs["input_ids"], decoder_input_ids=labels["input_ids"])
>>> hidden_states = outputs.last_hidden_state

TFMT5ForConditionalGeneration

class transformers.TFMT5ForConditionalGeneration

< source >

( *args **kwargs )

此类覆盖 TFT5ForConditionalGeneration。请查看超类以获取适当的文档和用法示例。

示例:

>>> from transformers import TFMT5ForConditionalGeneration, AutoTokenizer

>>> model = TFMT5ForConditionalGeneration.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, text_target=summary, return_tensors="tf")

>>> outputs = model(**inputs)
>>> loss = outputs.loss

TFMT5EncoderModel

class transformers.TFMT5EncoderModel

< source >

( *args **kwargs )

此类覆盖 TFT5EncoderModel。请查看超类以获取适当的文档和用法示例。

示例:

>>> from transformers import TFMT5EncoderModel, AutoTokenizer

>>> model = TFMT5EncoderModel.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> input_ids = tokenizer(article, return_tensors="tf").input_ids
>>> outputs = model(input_ids)
>>> hidden_state = outputs.last_hidden_state

JAXHide JAX content

FlaxMT5Model

class transformers.FlaxMT5Model

< source >

( config: T5Config input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

这个类重写了 FlaxT5Model。请查看超类以获取适当的文档和用法示例。

示例:

>>> from transformers import FlaxMT5Model, AutoTokenizer

>>> model = FlaxMT5Model.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")

>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, return_tensors="np")

>>> decoder_input_ids = tokenizer(text_target=summary, return_tensors="np").input_ids

>>> outputs = model(input_ids=inputs["input_ids"], decoder_input_ids=decoder_input_ids)
>>> hidden_states = outputs.last_hidden_state

FlaxMT5ForConditionalGeneration

class transformers.FlaxMT5ForConditionalGeneration

< source >

( config: T5Config input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

这个类重写了 FlaxT5ForConditionalGeneration。请查看超类以获取适当的文档和用法示例。

示例:

>>> from transformers import FlaxMT5ForConditionalGeneration, AutoTokenizer

>>> model = FlaxMT5ForConditionalGeneration.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")

>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, return_tensors="np")

>>> decoder_input_ids = tokenizer(text_target=summary, return_tensors="np").input_ids

>>> outputs = model(**inputs, decoder_input_ids=decoder_input_ids)
>>> logits = outputs.logits

FlaxMT5EncoderModel

class transformers.FlaxMT5EncoderModel

< source >

( config: T5Config input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

这个类重写了 FlaxT5EncoderModel。请查看超类以获取适当的文档和用法示例。

示例:

>>> from transformers import FlaxT5EncoderModel, AutoTokenizer

>>> model = FlaxT5EncoderModel.from_pretrained("google/mt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")

>>> article = "UN Offizier sagt, dass weiter verhandelt werden muss in Syrien."
>>> summary = "Weiter Verhandlung in Syrien."
>>> inputs = tokenizer(article, return_tensors="np")

>>> decoder_input_ids = tokenizer(text_target=summary, return_tensors="np").input_ids

>>> outputs = model(input_ids=inputs["input_ids"])
>>> hidden_states = outputs.last_hidden_state

MVP

原文:huggingface.co/docs/transformers/v4.37.2/en/model_doc/mvp

概述

MVP 模型由唐天一、李俊毅、赵新文和文继荣在《MVP: 多任务监督预训练用于自然语言生成》中提出。

根据摘要,

  • MVP 遵循标准的 Transformer 编码器-解码器架构。

  • MVP 是使用标记数据集进行监督预训练的。

  • MVP 还具有任务特定的软提示,以激发模型在执行特定任务时的能力。

  • MVP 专为自然语言生成而设计,可适应各种生成任务,包括但不限于摘要、数据到文本生成、开放式对话系统、故事生成、问答、问题生成、任务导向对话系统、常识生成、释义生成、文本风格转换和文本简化。我们的模型也可以适应自然语言理解任务,如序列分类和(抽取式)问答。

此模型由Tianyi Tang贡献。详细信息和说明可在此处找到。

使用提示

  • 我们发布了一系列模型这里,包括 MVP、具有任务特定提示的 MVP 和多任务预训练变体。

  • 如果要使用没有提示的模型(标准 Transformer),可以通过MvpForConditionalGeneration.from_pretrained('RUCAIBox/mvp')加载。

  • 如果要使用具有任务特定提示的模型,例如摘要,可以通过MvpForConditionalGeneration.from_pretrained('RUCAIBox/mvp-summarization')加载。

  • 我们的模型支持轻量级提示调整,遵循Prefix-tuning,使用方法set_lightweight_tuning()

使用示例

对于摘要,可以使用 MVP 和具有摘要特定提示的 MVP 作为示例。

>>> from transformers import MvpTokenizer, MvpForConditionalGeneration

>>> tokenizer = MvpTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp")
>>> model_with_prompt = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp-summarization")

>>> inputs = tokenizer(
...     "Summarize: You may want to stick it to your boss and leave your job, but don't do it if these are your reasons.",
...     return_tensors="pt",
... )
>>> generated_ids = model.generate(**inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
["Why You Shouldn't Quit Your Job"]

>>> generated_ids = model_with_prompt.generate(**inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
["Don't do it if these are your reasons"]

对于数据到文本生成,可以使用 MVP 和多任务预训练变体作为示例。

>>> from transformers import MvpTokenizerFast, MvpForConditionalGeneration

>>> tokenizer = MvpTokenizerFast.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp")
>>> model_with_mtl = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mtl-data-to-text")

>>> inputs = tokenizer(
...     "Describe the following data: Iron Man | instance of | Superhero [SEP] Stan Lee | creator | Iron Man",
...     return_tensors="pt",
... )
>>> generated_ids = model.generate(**inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
['Stan Lee created the character of Iron Man, a fictional superhero appearing in American comic']

>>> generated_ids = model_with_mtl.generate(**inputs)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
['Iron Man is a fictional superhero appearing in American comic books published by Marvel Comics.']

对于轻量级调整,即固定模型并仅调整提示,您可以加载具有随机初始化提示或具有任务特定提示的 MVP。我们的代码还支持使用 BART 进行前缀调整,遵循原始论文

>>> from transformers import MvpForConditionalGeneration

>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp", use_prompt=True)
>>> # the number of trainable parameters (full tuning)
>>> sum(p.numel() for p in model.parameters() if p.requires_grad)
468116832

>>> # lightweight tuning with randomly initialized prompts
>>> model.set_lightweight_tuning()
>>> # the number of trainable parameters (lightweight tuning)
>>> sum(p.numel() for p in model.parameters() if p.requires_grad)
61823328

>>> # lightweight tuning with task-specific prompts
>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mtl-data-to-text")
>>> model.set_lightweight_tuning()
>>> # original lightweight Prefix-tuning
>>> model = MvpForConditionalGeneration.from_pretrained("facebook/bart-large", use_prompt=True)
>>> model.set_lightweight_tuning()

资源

  • 文本分类任务指南

  • 问答任务指南

  • 因果语言建模任务指南

  • 掩码语言建模任务指南

  • 翻译任务指南

  • 摘要任务指南

MvpConfig

class transformers.MvpConfig

<来源>

( vocab_size = 50267 max_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 activation_function = 'gelu' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 classifier_dropout = 0.0 scale_embedding = False use_cache = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 is_encoder_decoder = True decoder_start_token_id = 2 forced_eos_token_id = 2 use_prompt = False prompt_length = 100 prompt_mid_dim = 800 **kwargs )

参数

  • vocab_sizeint可选,默认为 50267)- MVP 模型的词汇量。定义了在调用 MvpModel 时可以表示的不同标记数量。

  • d_modelint可选,默认为 1024)- 层和池化层的维度。

  • encoder_layersint可选,默认为 12)- 编码器层数。

  • decoder_layersint可选,默认为 12)- 解码器层数。

  • encoder_attention_headsint可选,默认为 16)- Transformer 编码器中每个注意力层的注意力头数。

  • decoder_attention_headsint可选,默认为 16)- Transformer 解码器中每个注意力层的注意力头数。

  • decoder_ffn_dimint可选,默认为 4096)- 解码器中“中间”(通常称为前馈)层的维度。

  • encoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”(通常称为前馈)层的维度。

  • activation_function (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu""relu""silu""gelu_new"

  • dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

  • activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的 dropout 比率。

  • classifier_dropout (float, optional, defaults to 0.0) — 分类器的 dropout 比率。

  • max_position_embeddings (int, optional, defaults to 1024) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一(例如,512 或 1024 或 2048)。

  • init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

  • encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。更多细节请参阅 LayerDrop paper)。

  • decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。更多细节请参阅 LayerDrop paper)。

  • scale_embedding (bool, optional, defaults to False) — 通过 sqrt(d_model)缩放嵌入。

  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。

  • forced_eos_token_id (int, optional, defaults to 2) — 当达到max_length时,强制作为最后生成的 token 的 id。通常设置为eos_token_id

  • use_prompt (bool, optional, defaults to False) — 是否使用 prompt。

  • prompt_length (int, optional, defaults to 100) — prompt 的长度。

  • prompt_mid_dim (int, optional, defaults to 800) — prompt 中“中间”层的维度。

这是用于存储 MvpModel 配置的配置类。它用于根据指定的参数实例化 MVP 模型,定义模型架构。使用默认值实例化配置将产生类似于 MVP RUCAIBox/mvp 架构的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

>>> from transformers import MvpConfig, MvpModel

>>> # Initializing a MVP RUCAIBox/mvp style configuration
>>> configuration = MvpConfig()

>>> # Initializing a model (with random weights) from the RUCAIBox/mvp style configuration
>>> model = MvpModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

MvpTokenizer

class transformers.MvpTokenizer

< source >

( vocab_file merges_file errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False **kwargs )

参数

  • vocab_file (str) — 词汇文件的路径。

  • merges_file (str) — 合并文件的路径。

  • errors (str, optional, defaults to "replace") — 解码字节为 UTF-8 时要遵循的范例。更多信息请参阅bytes.decode

  • bos_token (str, optional, defaults to "<s>") — 在预训练期间使用的序列开始 token。可以用作序列分类器 token。

    构建序列时使用特殊 token 时,这不是用于序列开头的 token。用于开头的 token 是cls_token

  • eos_token (str, optional, defaults to "</s>") — 序列结束标记。

    在使用特殊标记构建序列时,这不是用于序列结尾的标记。使用的标记是sep_token

  • sep_token (str, optional, defaults to "</s>") — 分隔符标记,在从多个序列构建序列时使用,例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。

  • cls_token (str, optional, defaults to "<s>") — 用于序列分类(整个序列而不是每个标记的分类)时使用的分类器标记。当使用特殊标记构建序列时,它是序列的第一个标记。

  • unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID,而是设置为此标记。

  • pad_token (str, optional, defaults to "<pad>") — 用于填充的标记,例如在批处理不同长度的序列时使用。

  • mask_token (str, optional, defaults to "<mask>") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

  • add_prefix_space (bool, optional, defaults to False) — 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。(MVP 标记器通过前面的空格检测单词的开头)。

构建一个 MVP 标记器,类似于 RoBERTa 标记器,使用字节级字节对编码。

此标记器已经训练成将空格视为标记的一部分(有点像 sentencepiece),因此一个单词将

在句子开头(无空格)或不在句子开头时,将以不同方式编码:

>>> from transformers import MvpTokenizer

>>> tokenizer = MvpTokenizer.from_pretrained("RUCAIBox/mvp")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

您可以通过在实例化此标记器时或在对某些文本调用它时传递add_prefix_space=True来避免这种行为,但由于模型不是以这种方式进行预训练的,因此可能会导致性能下降。

当与is_split_into_words=True一起使用时,此标记器将在每个单词之前添加一个空格(甚至是第一个单词)。

此标记器继承自 PreTrainedTokenizer,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。

  • token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记,为序列分类任务从序列或序列对构建模型输入。MVP 序列的格式如下:

  • 单个序列:<s> X </s>

  • 序列对:<s> A </s></s> B </s>

convert_tokens_to_string

<来源>

( tokens )

将标记序列(字符串)转换为单个字符串。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。

  • token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

零列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。MVP 不使用标记类型 ID,因此返回一个零列表。

get_special_tokens_mask

< source >

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。

  • token_ids_1 (List[int], 可选) — 序列对的第二个 ID 列表。

  • already_has_special_tokens (bool, 可选, 默认为 False) — 标记列表是否已经格式化为模型的特殊标记。

返回

List[int]

一个整数列表,范围为[0, 1]:1 表示特殊标记,0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。在使用 tokenizer 的prepare_for_model方法添加特殊标记时调用此方法。

MvpTokenizerFast

class transformers.MvpTokenizerFast

< source >

( vocab_file = None merges_file = None tokenizer_file = None errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False trim_offsets = True **kwargs )

参数

  • vocab_file (str) — 词汇表文件的路径。

  • merges_file (str) — 合并文件的路径。

  • errors (str, 可选, 默认为 "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息,请参阅bytes.decode

  • bos_token (str, 可选, 默认为 "<s>") — 在预训练期间使用的序列开头标记。可用作序列分类器标记。

    构建序列时使用特殊标记时,这不是用于序列开头的标记。使用的标记是cls_token

  • eos_token (str, 可选, 默认为 "</s>") — 序列结束标记。

    在使用特殊标记构建序列时,这不是用于序列结尾的标记。使用的标记是sep_token

  • sep_token (str, 可选, 默认为 "</s>") — 分隔符标记,在从多个序列构建序列时使用,例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。

  • cls_token (str, 可选, 默认为 "<s>") — 分类器标记,用于进行序列分类(对整个序列进行分类而不是对每个标记进行分类)。在使用特殊标记构建时,它是序列的第一个标记。

  • unk_token (str, 可选, 默认为 "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID,而是设置为此标记。

  • pad_token (str, 可选, 默认为 "<pad>") — 用于填充的标记,例如在批处理不同长度的序列时。

  • mask_token (str, 可选, 默认为 "<mask>") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

  • add_prefix_space (bool, 可选, 默认为 False) — 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。(MVP tokenizer 通过前面的空格检测单词的开头)。

  • trim_offsets (bool, 可选, 默认为 True) — 后处理步骤是否应修剪偏移量以避免包含空格。

构建一个“快速”MVP tokenizer(由 HuggingFace 的tokenizers库支持),源自 GPT-2 tokenizer,使用字节级别的字节对编码。

此 tokenizer 已经训练成将空格视为标记的一部分(有点像 sentencepiece),因此一个单词将

在句子开头(无空格)或不在句子开头时,将以不同方式编码:

>>> from transformers import MvpTokenizerFast

>>> tokenizer = MvpTokenizerFast.from_pretrained("RUCAIBox/mvp")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

您可以通过在实例化此 tokenizer 时或在对某些文本调用它时传递add_prefix_space=True来避免该行为,但由于模型不是以这种方式进行预训练的,因此可能会降低性能。

当与is_split_into_words=True一起使用时,需要使用add_prefix_space=True来实例化此 tokenizer。

此标记生成器继承自 PreTrainedTokenizerFast,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

  • token_ids_0List[int])— ID 列表。

  • token_ids_1List[int]可选)— 序列对的第二个 ID 列表。

返回

List[int]

零的列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。MVP 不使用标记类型 id,因此返回一个零的列表。

MvpModel

class transformers.MvpModel

<来源>

( config: MvpConfig )

参数

  • config(MvpConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

裸 MVP 模型输出原始隐藏状态,没有特定的头部。此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。

此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 输入序列标记在词汇表中的索引。默认情况下将忽略填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    输入 ID 是什么?

  • attention_mask(形状为(batch_size, sequence_length)torch.Tensor可选)— 避免在填充标记索引上执行注意力的掩码。在[0, 1]中选择的掩码值:

    • 对于未屏蔽的标记为 1,

    • 对于被屏蔽的标记为 0。

    注意力掩码是什么?

  • decoder_input_ids(形状为(batch_size, target_sequence_length)torch.LongTensor可选)— 解码器输入序列标记在词汇表中的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    解码器输入 ID 是什么?

    Mvp 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values,则可以选择仅输入最后的decoder_input_ids(请参阅past_key_values)。

    对于翻译和摘要训练,应提供decoder_input_ids。如果未提供decoder_input_ids,模型将通过将input_ids向右移动来创建此张量,以用于去噪预训练。

  • decoder_attention_masktorch.LongTensor,形状为(batch_size, target_sequence_length)可选)— 默认行为:生成一个张量,忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

    如果您想要更改填充行为,您应该阅读modeling_mvp._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息,请参阅论文中的图表 1。

  • head_masktorch.Tensor,形状为(encoder_layers, encoder_attention_heads)可选)— 用于在编码器的注意力模块中使特定头部失效的掩码。掩码值选在[0, 1]之间:

    • 1 表示头部未被屏蔽,

    • 0 表示头部被屏蔽。

  • decoder_head_masktorch.Tensor,形状为(decoder_layers, decoder_attention_heads)可选)— 用于在解码器的注意力模块中使特定头部失效的掩码。掩码值选在[0, 1]之间:

    • 1 表示头部未被屏蔽,

    • 0 表示头部被屏蔽。

  • cross_attn_head_masktorch.Tensor,形状为(decoder_layers, decoder_attention_heads)可选)— 用于在解码器中使交叉注意力模块中的特定头部失效的掩码。掩码值选在[0, 1]之间:

    • 1 表示头部未被屏蔽,

    • 0 表示头部被屏蔽。

  • encoder_outputstuple(tuple(torch.FloatTensor)可选)— 元组由(last_hidden_state可选hidden_states可选attentions) 组成,last_hidden_state的形状为(batch_size, sequence_length, hidden_size)可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

  • past_key_valuestuple(tuple(torch.FloatTensor))可选,当传递use_cache=Trueconfig.use_cache=True时返回)— 长度为config.n_layers的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量,以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参阅past_key_values输入)。

    如果使用了past_key_values,用户可以选择仅输入最后的decoder_input_ids(那些没有将其过去的键值状态提供给此模型的)的形状为(batch_size, 1),而不是形状为(batch_size, sequence_length)的所有decoder_input_ids

  • inputs_embedstorch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

  • decoder_inputs_embedstorch.FloatTensor,形状为(batch_size, target_sequence_length, hidden_size)可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递decoder_input_ids。如果使用了past_key_values,则可以选择仅输入最后的decoder_inputs_embeds(请参阅past_key_values)。如果您希望更多地控制如何将decoder_input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

    如果decoder_input_idsdecoder_inputs_embeds都未设置,则decoder_inputs_embeds将取inputs_embeds的值。

  • use_cachebool可选)— 如果设置为True,则返回past_key_values键值状态,并可用于加速解码(请参阅past_key_values)。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states

  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.Seq2SeqModelOutput 或torch.FloatTensor元组

一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置(MvpConfig)和输入的各种元素。

  • last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。

    如果仅使用past_key_values,则输出形状为(batch_size, 1, hidden_size)序列的最后一个隐藏状态。

  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=Trueconfig.use_cache=True时返回) — 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见past_key_values输入)。

  • decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入输出的一个+每层输出的一个)。

    解码器每层输出的隐藏状态加上可选的初始嵌入输出。

  • decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

  • encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入输出的一个+每层输出的一个)。

    编码器在每一层的隐藏状态加上可选的初始嵌入输出。

  • encoder_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

MvpModel 的前向方法,覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

示例:

>>> from transformers import AutoTokenizer, MvpModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpModel.from_pretrained("RUCAIBox/mvp")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

MvpForConditionalGeneration

class transformers.MvpForConditionalGeneration

<来源>

( config: MvpConfig )

参数

  • config(MvpConfig)— 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,只加载配置。 查看 from_pretrained()方法以加载模型权重。

具有语言建模头的 MVP 模型。 可用于各种文本生成任务。 该模型继承自 PreTrainedModel。 检查超类文档以获取库为所有模型实现的通用方法(例如下载或保存,调整输入嵌入,修剪头等)。

该模型也是 PyTorch torch.nn.Module子类。 将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 词汇表中输入序列标记的索引。 默认情况下将忽略填充。

    可以使用 AutoTokenizer 获取索引。 有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    输入 ID 是什么?

  • attention_mask(形状为(batch_size, sequence_length)torch.Tensor可选)— 用于避免在填充标记索引上执行注意力的掩码。 选择在[0, 1]中的掩码值:

    • 1 表示未被掩码的标记,

    • 0 表示被掩码的标记。

    注意力掩码是什么?

  • decoder_input_ids(形状为(batch_size, target_sequence_length)torch.LongTensor可选)— 词汇表中解码器输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。 有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    解码器输入 ID 是什么?

    Mvp 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values,则可以选择仅输入最后的decoder_input_ids(请参阅past_key_values)。

    对于翻译和摘要训练,应提供decoder_input_ids。如果未提供decoder_input_ids,模型将通过将input_ids向右移动来创建此张量,以用于去噪预训练,遵循论文中的默认策略。

  • decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为:生成一个张量,忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

    如果要更改填充行为,您应该阅读modeling_mvp._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息,请参阅论文中的图表 1。

  • head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中:

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使解码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中:

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使解码器中交叉注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中:

    • 1 表示头部未被masked

    • 0 表示头部被masked

  • encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括(last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)optional) 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。

  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=Trueconfig.use_cache=True时返回) — 长度为config.n_layers的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量,以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可以用于加速顺序解码(请参阅past_key_values输入)。

    如果使用past_key_values,用户可以选择仅输入形状为(batch_size, 1)的最后的decoder_input_ids(这些没有将它们的过去键值状态提供给此模型)而不是形状为(batch_size, sequence_length)的所有decoder_input_ids

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制权,以便将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

  • decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递decoder_input_ids。如果使用past_key_values,则可以选择仅输入最后的decoder_inputs_embeds(请参阅past_key_values)。如果您想要更多控制权,以便将decoder_input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。

    如果decoder_input_idsdecoder_inputs_embeds都未设置,则decoder_inputs_embedsinputs_embeds的值。

  • use_cachebool可选)— 如果设置为True,将返回past_key_values键值状态,并可用于加速解码(请参见past_key_values)。

  • output_attentionsbool可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions

  • output_hidden_statesbool可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dictbool可选)— 是否返回一个 ModelOutput 而不是一个普通元组。

  • labels(形状为(batch_size, sequence_length)torch.LongTensor可选)— 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内,或者为-100(请参见input_ids文档字符串)。索引设置为-100的标记将被忽略(掩码),损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

返回

transformers.modeling_outputs.Seq2SeqLMOutput 或torch.FloatTensor元组。

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False),包括根据配置(MvpConfig)和输入的不同元素。

  • loss(形状为(1,)torch.FloatTensor可选,当提供labels时返回)— 语言建模损失。

  • logits(形状为(batch_size, sequence_length, config.vocab_size)torch.FloatTensor)— 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。

  • past_key_valuestuple(tuple(torch.FloatTensor))可选,当传递use_cache=Trueconfig.use_cache=True时返回)— 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参见past_key_values输入)。

  • decoder_hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)— 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组,包括每个层的嵌入输出(如果模型有嵌入层)+ 每个层的输出。

    解码器在每个层的输出以及初始嵌入输出的隐藏状态。

  • decoder_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)的每个层的torch.FloatTensor元组。

    解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

  • cross_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)的每个层的torch.FloatTensor元组。

    解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

  • encoder_last_hidden_state(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选) — 模型编码器最后一层的隐藏状态序列。

  • encoder_hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(一个用于嵌入的输出,如果模型有一个嵌入层,+ 一个用于每一层的输出)。

    每层编码器的隐藏状态以及初始嵌入输出。

  • encoder_attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

MvpForConditionalGeneration 的前向方法,覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。

摘要示例:

微调模型

>>> import torch
>>> from transformers import AutoTokenizer, MvpForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForConditionalGeneration.from_pretrained("RUCAIBox/mvp")

>>> inputs = tokenizer(
...     "Summarize: You may want to stick it to your boss and leave your job, but don't do it if these are your reasons.",
...     return_tensors="pt",
... )
>>> labels = tokenizer("Bad Reasons To Quit Your Job", return_tensors="pt")["input_ids"]

>>> loss = model(**inputs, labels=labels).loss
>>> loss.backward()

模型微调后的推断

>>> with torch.no_grad():
...     generated_ids = model.generate(**inputs)

>>> generated_text = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)

MvpForSequenceClassification

class transformers.MvpForSequenceClassification

<来源>

( config: MvpConfig **kwargs )

参数

  • config(MvpConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部具有序列分类/头的 Mvp 模型(在汇总输出的顶部有一个线性层),例如用于 GLUE 任务。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, sequence_length)torch.Tensor可选) — 避免对填充标记索引执行注意力的蒙版。蒙版值选在[0, 1]之间:

    • 对于未被“masked”的标记,为 1,

    • 对于被masked的标记,为 0。

    什么是注意力蒙版?

  • decoder_input_ids(形状为 (batch_size, target_sequence_length)torch.LongTensor可选)— 词汇表中解码器输入序列标记的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID?

    Mvp 使用 eos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用了 past_key_values,可以选择仅输入最后的 decoder_input_ids(请参见 past_key_values)。

    对于翻译和摘要训练,应提供 decoder_input_ids。如果未提供 decoder_input_ids,模型将通过将 input_ids 向右移动来创建此张量,以用于去噪预训练,遵循论文中的方法。

  • decoder_attention_mask(形状为 (batch_size, target_sequence_length)torch.LongTensor可选)— 默认行为:生成一个张量,忽略解码器输入中的填充标记。因果掩码也将默认使用。

    如果您想要更改填充行为,您应该阅读 modeling_mvp._prepare_decoder_attention_mask 并根据您的需求进行修改。有关默认策略的更多信息,请参见论文中的图表 1。

  • head_mask(形状为 (encoder_layers, encoder_attention_heads)torch.Tensor可选)— 用于使编码器中的注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1] 中:

    • 1 表示头部未被“掩盖”,

    • 0 表示头部被“掩盖”。

  • decoder_head_mask(形状为 (decoder_layers, decoder_attention_heads)torch.Tensor可选)— 用于使解码器中的注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1] 中:

    • 1 表示头部未被“掩盖”,

    • 0 表示头部被“掩盖”。

  • cross_attn_head_mask(形状为 (decoder_layers, decoder_attention_heads)torch.Tensor可选)— 用于使解码器中的交叉注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1] 中:

    • 1 表示头部未被“掩盖”,

    • 0 表示头部被“掩盖”。

  • encoder_outputstuple(tuple(torch.FloatTensor)可选)— 元组包括 (last_hidden_state可选hidden_states可选attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size) 的隐藏状态序列,可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

  • past_key_valuestuple(tuple(torch.FloatTensor))可选,当传递 use_cache=True 或当 config.use_cache=True 时返回)— 长度为 config.n_layerstuple(torch.FloatTensor) 的元组,每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参见 past_key_values 输入)。

    如果使用了 past_key_values,用户可以选择仅输入最后的 decoder_input_ids(那些没有将其过去的键值状态提供给此模型的)的形状为 (batch_size, 1) 的张量,而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids

  • inputs_embeds (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

  • decoder_inputs_embeds (torch.FloatTensor,形状为(batch_size, target_sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递decoder_input_ids。如果使用past_key_values,则可能只需输入最后的decoder_inputs_embeds(请参阅past_key_values)。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。

    如果decoder_input_idsdecoder_inputs_embeds都未设置,则decoder_inputs_embedsinputs_embeds的值。

  • use_cache (bool, 可选) — 如果设置为True,则返回past_key_values键值状态,并可用于加速解码(请参阅past_key_values)。

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions

  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

  • labels (torch.LongTensor,形状为(batch_size,)可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1,则计算分类损失(交叉熵)。

MvpForSequenceClassification 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。

单标签分类示例:

num_labels类上微调模型

>>> import torch
>>> from transformers import AutoTokenizer, MvpForSequenceClassification

>>> num_labels = 2  # for example, this is a binary classification task
>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForSequenceClassification.from_pretrained("RUCAIBox/mvp", num_labels=num_labels)

>>> inputs = tokenizer("Classify: Hello, my dog is cute", return_tensors="pt")
>>> labels = torch.tensor(1)  # the real label for inputs

>>> loss = model(**inputs, labels=labels).loss
>>> loss.backward()

在模型微调后进行推理

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax()

MvpForQuestionAnswering

class transformers.MvpForQuestionAnswering

<来源>

( config )

参数

  • config (MvpConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。

MVP 模型,顶部带有用于提取式问答任务(如 SQuAD)的跨度分类头(在隐藏状态输出顶部的线性层上计算span start logitsspan end logits)。

该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。

该模型还是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Tensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None start_positions: Optional = None end_positions: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)— 词汇表中输入序列标记的索引。默认情况下将忽略填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, sequence_length)torch.Tensor可选)— 用于避免在填充令牌索引上执行注意力的遮罩。遮罩值在[0, 1]中选择:

    • 1 表示令牌未被遮罩,

    • 0 表示被遮罩的令牌。

    什么是注意力遮罩?

  • decoder_input_ids(形状为(batch_size, target_sequence_length)torch.LongTensor可选)— 解码器输入序列标记在词汇表中的索引。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID?

    Mvp 使用eos_token_id作为decoder_input_ids生成的起始令牌。如果使用past_key_values,则只需选择最后的decoder_input_ids作为输入(参见past_key_values)。

    对于翻译和摘要训练,应提供decoder_input_ids。如果未提供decoder_input_ids,模型将通过将input_ids向右移动来创建此张量,以进行去噪预训练,遵循论文。

  • decoder_attention_mask(形状为(batch_size, target_sequence_length)torch.LongTensor可选)— 默认行为:生成一个忽略decoder_input_ids中填充令牌的张量。因果遮罩也将默认使用。

    如果要更改填充行为,应阅读modeling_mvp._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息,请参阅论文中的图表 1

  • head_mask(形状为(encoder_layers, encoder_attention_heads)torch.Tensor可选)— 用于在编码器中使注意力模块的选定头部失效的遮罩。遮罩值在[0, 1]中选择:

    • 1 表示头部未被遮罩,

    • 0 表示头部被遮罩。

  • decoder_head_mask(形状为(decoder_layers, decoder_attention_heads)torch.Tensor可选)— 用于在解码器中使注意力模块的选定头部失效的遮罩。遮罩值在[0, 1]中选择:

    • 1 表示头部未被遮罩,

    • 0 表示头部被遮罩。

  • cross_attn_head_mask(形状为(decoder_layers, decoder_attention_heads)torch.Tensor可选)— 用于在解码器中使交叉注意力模块的选定头部失效的遮罩。遮罩值在[0, 1]中选择:

    • 1 表示头部未被遮罩,

    • 0 表示头部被遮罩。

  • encoder_outputstuple(tuple(torch.FloatTensor)可选)— 元组包括(last_hidden_state可选hidden_states可选attentionslast_hidden_state的形状为(batch_size, sequence_length, hidden_size)可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

  • past_key_values (tuple(tuple(torch.FloatTensor))optional,当传递use_cache=Trueconfig.use_cache=True时返回) — 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

    包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见past_key_values输入)。

    如果使用了past_key_values,用户可以选择仅输入最后一个形状为(batch_size, 1)decoder_input_ids(那些没有将它们的过去键值状态提供给此模型的输入)而不是形状为(batch_size, sequence_length)的所有decoder_input_ids

  • inputs_embeds (torch.FloatTensor,形状为(batch_size, sequence_length, hidden_size)optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。

  • decoder_inputs_embeds (torch.FloatTensor,形状为(batch_size, target_sequence_length, hidden_size)optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递decoder_input_ids。如果使用了past_key_values,则可以选择仅输入最后一个decoder_inputs_embeds(参见past_key_values)。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。

    如果decoder_input_idsdecoder_inputs_embeds都未设置,则decoder_inputs_embedsinputs_embeds的值。

  • use_cache (bool, optional) — 如果设置为True,将返回past_key_values键值状态,并可用于加速解码(参见past_key_values)。

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions

  • output_hidden_states (booloptional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量中的hidden_states

  • return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

  • start_positions (torch.LongTensor,形状为(batch_size,)optional) — 用于计算标记跨度开始位置的位置(索引)的标签。位置被夹紧到序列的长度(sequence_length)。超出序列范围的位置不会被考虑在内计算损失。

  • end_positions (torch.LongTensor,形状为(batch_size,)optional) — 用于计算标记跨度结束位置的位置(索引)的标签。位置被夹紧到序列的长度(sequence_length)。超出序列范围的位置不会被考虑在内计算损失。

MvpForQuestionAnswering 的前向方法,覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。

示例:

对于抽取式问答模型进行微调,我们的模型还支持使用BartForConditionalGeneration进行生成式问答。

>>> import torch
>>> from transformers import AutoTokenizer, MvpForQuestionAnswering

>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForQuestionAnswering.from_pretrained("RUCAIBox/mvp")

>>> inputs = tokenizer(
...     "Answer the following question: Who was Jim Henson? [SEP] Jim Henson was a nice puppet",
...     return_tensors="pt",
... )
>>> target_start_index = torch.tensor([18])
>>> target_end_index = torch.tensor([19])

>>> loss = model(**inputs, start_positions=target_start_index, end_positions=target_end_index).loss
>>> loss.backward()

在模型微调后进行推理

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> predict_answer = tokenizer.decode(predict_answer_tokens)

MvpForCausalLM

class transformers.MvpForCausalLM

<来源>

( config )

前向

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

  • input_ids(形状为(batch_size, sequence_length)torch.LongTensor)- 词汇表中输入序列标记的索引。默认情况下将忽略填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID?

  • attention_mask(形状为(batch_size, sequence_length)torch.Tensor可选)- 用于避免在填充标记索引上执行注意力。在[0, 1]中选择的掩码值:

    • 1 表示未被掩盖的标记,

    • 0 表示被掩盖的标记。

    什么是注意力掩码?

  • encoder_hidden_states(形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选)- 编码器最后一层的隐藏状态序列。如果模型配置为解码器,则在交叉注意力中使用。

  • encoder_attention_mask(形状为(batch_size, sequence_length)torch.FloatTensor可选)- 用于避免在编码器输入的填充标记索引上执行注意力。如果模型配置为解码器,则在交叉注意力中使用此掩码。在[0, 1]中选择的掩码值:

  • head_mask(形状为(decoder_layers, decoder_attention_heads)torch.Tensor可选)- 用于使注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值:

    • 1 表示头部未被掩盖

    • 0 表示头部被掩盖

  • cross_attn_head_mask(形状为(decoder_layers, decoder_attention_heads)torch.Tensor可选)- 用于使交叉注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值:

    • 1 表示头部未被掩盖

    • 0 表示头部被掩盖

  • past_key_valuestuple(tuple(torch.FloatTensor))可选,当传递use_cache=Trueconfig.use_cache=True时返回)- 长度为config.n_layerstuple(torch.FloatTensor)元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。当模型用作序列到序列模型中的解码器时,只有在需要时才需要这两个额外的张量。

    包含预先计算的隐藏状态(自注意块和交叉注意块中的键和值),可用于加速顺序解码(请参见past_key_values输入)。

    如果使用past_key_values,用户可以选择性地仅输入最后一个形状为(batch_size, 1)decoder_input_ids(那些没有将它们的过去键值状态提供给此模型的)而不是形状为(batch_size, sequence_length)的所有decoder_input_ids

  • labels(形状为(batch_size, sequence_length)torch.LongTensor可选)- 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100(参见input_ids文档字符串)。将索引设置为-100的标记将被忽略(掩盖),损失仅计算具有[0, ..., config.vocab_size]标签的标记。

  • use_cachebool可选)- 如果设置为True,将返回past_key_values键值状态,并可用于加速解码(参见past_key_values)。

    • 1 表示未被掩盖的标记,

    • 0 表示被掩盖的标记。

  • output_attentions (booloptional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions

  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states

  • return_dict (booloptional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor元组

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False时)包含根据配置(MvpConfig)和输入的不同元素。

  • loss (torch.FloatTensor,形状为(1,)optional,当提供labels时返回) — 语言建模损失(用于下一个标记预测)。

  • logits (torch.FloatTensor,形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。

  • hidden_states (tuple(torch.FloatTensor)optional,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入输出的一个+每层输出的一个)。

    模型在每一层输出时的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)optional,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor)optional,当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)torch.FloatTensor元组(每层一个)。

    注意力 softmax 后的交叉注意力权重,用于计算交叉注意力头中的加权平均值。

  • past_key_values (tuple(tuple(torch.FloatTensor))optional,当传递use_cache=Trueconfig.use_cache=True时返回) — 长度为config.n_layerstorch.FloatTensor元组的元组,每个元组包含自注意力和交叉注意力层的缓存键、值状态,如果模型用于编码器-解码器设置,则相关。仅在config.is_decoder = True时相关。

    包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码。

示例:

>>> from transformers import AutoTokenizer, MvpForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("RUCAIBox/mvp")
>>> model = MvpForCausalLM.from_pretrained("RUCAIBox/mvp", add_cross_attention=False)

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> list(logits.shape)
[1, 8, 50267]
posted @   绝不原创的飞龙  阅读(13)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 如何使用 Uni-app 实现视频聊天(源码,支持安卓、iOS)
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
点击右上角即可分享
微信分享提示