Hugging Face 的标志

Transformers 文档

UMT5

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

UMT5

Models Spaces

概述

UMT5 模型在 UniMax: Fairer and More Effective Language Sampling for Large-Scale Multilingual Pretraining 中被提出，作者是 Hyung Won Chung、Xavier Garcia、Adam Roberts、Yi Tay、Orhan Firat、Sharan Narang、Noah Constant。

论文的摘要如下：

预训练的多语言大型语言模型通常使用启发式基于温度的采样来平衡不同语言。然而，先前的工作并未系统地评估不同预训练语言分布在模型规模上的有效性。在本文中，我们提出了一种新的采样方法 UniMax，它通过显式限制每种语言语料库的重复次数，在减轻尾部语言的过拟合的同时，提供更均匀的头部语言覆盖率。我们进行了一系列广泛的消融实验，测试了一系列多语言基准上的采样策略，同时改变了模型规模。我们发现 UniMax 优于标准的基于温度的采样，并且随着规模的增加，其优势持续存在。作为我们贡献的一部分，我们发布了：（i）改进和刷新的 mC4 多语言语料库，包含 107 种语言的 29 万亿个字符，以及（ii）一套使用 UniMax 采样预训练的 umT5 模型检查点。

谷歌发布了以下变体：

此模型由 agemagician 和 stefan-it 贡献。原始代码可以在这里找到。

使用技巧

  • UMT5 仅在 mC4 上进行了预训练，不包括任何监督训练。因此，与原始 T5 模型不同，此模型必须先进行微调才能在下游任务中使用。
  • 由于 umT5 是以无监督方式预训练的，因此在单任务微调期间使用任务前缀并没有真正的优势。如果您正在进行多任务微调，则应使用前缀。

与 mT5 的区别？

UmT5 基于 mT5，具有为每一层计算的非共享相对位置偏差。这意味着模型为每一层设置了 has_relative_bias。转换脚本也不同，因为该模型以 t5x 的最新检查点格式保存。

示例用法

>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

>>> model = AutoModelForSeq2SeqLM.from_pretrained("google/umt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")

>>> inputs = tokenizer(
...     "A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.",
...     return_tensors="pt",
... )
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs))
['<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s>']

有关更多技巧、代码示例和笔记本，请参阅 T5 的文档页面。

UMT5Config

class transformers.UMT5Config

< >

（ 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 = True pad_token_id = 0 eos_token_id = 1 decoder_start_token_id = 0 classifier_dropout = 0.0 **kwargs ）

参数

  • vocab_size (int, 可选, 默认为 250112) — UMT5 模型的词汇表大小。定义了在调用 UMT5Model 或 TFUMT5Model 时，由 inputs_ids 传递的可表示的不同 token 的数量。
  • d_model (int, 可选, 默认为 512) — 编码器层和池化层的大小。
  • d_kv (int, 可选, 默认为 64) — 每个注意力头的键、查询、值投影的大小。 d_kv 必须等于 d_model // num_heads。
  • d_ff (int, 可选, 默认为 1024) — 每个 UMT5Block 中间前馈层的大小。
  • num_layers (int, 可选, 默认为 8) — Transformer 编码器中隐藏层的数量。
  • num_decoder_layers (int, 可选) — Transformer 解码器中隐藏层的数量。如果未设置，将使用与 num_layers 相同的值。
  • num_heads (int, 可选, 默认为 6) — Transformer 编码器中每个注意力层的注意力头数。
  • relative_attention_num_buckets (int, 可选, 默认为 32) — 用于每个注意力层的 bucket 数量。
  • relative_attention_max_distance (int, 可选, 默认为 128) — 用于 bucket 分离的较长序列的最大距离。
  • dropout_rate (float, 可选, 默认为 0.1) — 所有 dropout 层的比率。
  • classifier_dropout (float, 可选, 默认为 0.0) — 分类器的 dropout 比率。
  • 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) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

这是用于存储 UMT5Model 配置的配置类。它用于根据指定的参数实例化 UMT5 模型，定义模型架构。使用默认值实例化配置将产生与 UMT5 google/umt5-small 架构类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。

UMT5Model

class transformers.UMT5Model

< >

（ config ）

参数

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

裸 UMT5 模型 Transformer 输出原始隐藏状态，顶部没有任何特定的头。

UMT5 模型在 Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer 中提出，作者是 Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu。它是一个在文本到文本去噪生成设置中预训练的编码器-解码器 Transformer。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

示例

>>> from transformers import UMT5Model, AutoTokenizer

>>> model = UMT5Model.from_pretrained("google/umt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> noisy_text = "UN Offizier sagt, dass weiter <extra_id_0> werden muss in Syrien."
>>> label = "<extra_id_0> verhandelt"
>>> inputs = tokenizer(inputs, return_tensors="pt")
>>> labels = tokenizer(label=label, return_tensors="pt")

>>> outputs = model(input_ids=inputs["input_ids"], decoder_input_ids=labels["input_ids"])
>>> hidden_states = outputs.last_hidden_state

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 ） → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。UMT5 是具有相对位置嵌入的模型，因此您应该能够在右侧和左侧填充输入。

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

    什么是输入 ID？

    要了解有关如何为预训练准备 input_ids 的更多信息，请查看 UMT5 训练。

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行注意力的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示 token 未被 Mask，
    • 0 表示 token 已被 Mask。

    什么是注意力 Mask？

  • decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length), 可选) — 解码器输入序列 token 在词汇表中的索引。

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

    什么是解码器输入 ID？

    UMT5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids（请参见 past_key_values）。

    要了解有关如何为预训练准备 decoder_input_ids 的更多信息，请查看 UMT5 训练。

  • decoder_attention_mask (torch.BoolTensor，形状为 (batch_size, target_sequence_length), 可选) — 默认行为：生成一个 tensor，该 tensor 忽略 decoder_input_ids 中的 pad token。默认情况下，也将使用因果 Mask。
  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于置空编码器中自注意力模块的选定头的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示头 未被 Mask，
    • 0 表示头 已被 Mask。
  • decoder_head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于屏蔽解码器自注意力模块中选定的注意力头。 掩码值在 [0, 1] 中选择：

    • 1 表示注意力头不被屏蔽，
    • 0 表示注意力头被屏蔽。
  • cross_attn_head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于屏蔽解码器交叉注意力模块中选定的注意力头。 掩码值在 [0, 1] 中选择：

    • 1 表示注意力头不被屏蔽，
    • 0 表示注意力头被屏蔽。
  • encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — 元组由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成。last_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，形状为 (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_ids 和 decoder_inputs_embeds 均未设置，则 decoder_inputs_embeds 取 inputs_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 而不是普通元组。

返回值

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

一个 transformers.modeling_outputs.Seq2SeqModelOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (UMT5Config) 和输入。

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

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

  • past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(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)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每层输出提供一个），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每层输出的隐藏状态以及可选的初始嵌入输出。

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

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

  • cross_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.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)，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每层输出提供一个），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每层输出的隐藏状态以及可选的初始嵌入输出。

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

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

UMT5Model 的 forward 方法，覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, UMT5Model

>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5Model.from_pretrained("google/umt5-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 UMT5Model.
>>> # This is not needed for torch's UMT5ForConditionalGeneration 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

UMT5ForConditionalGeneration

class transformers.UMT5ForConditionalGeneration

< >

（ config ）

参数

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

UMT5 模型，顶部带有语言建模头。

UMT5 模型在 Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer 中提出，作者是 Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu。它是一个在文本到文本去噪生成设置中预训练的编码器-解码器 Transformer。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

示例

>>> from transformers import UMT5ForConditionalGeneration, AutoTokenizer

>>> model = UMT5ForConditionalGeneration.from_pretrained("google/umt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-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

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 ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。 UMT5 是一个具有相对位置嵌入的模型，因此您应该能够在左右两侧填充输入。

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

    什么是输入 ID？

    要了解有关如何为预训练准备 input_ids 的更多信息，请查看 UMT5 训练。

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

    • 1 表示标记不被屏蔽，
    • 0 表示标记被屏蔽。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。

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

    什么是解码器输入 ID？

    UMT5 使用 pad_token_id 作为 decoder_input_ids 生成的起始标记。 如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids（请参阅 past_key_values）。

    要了解有关如何为预训练准备 decoder_input_ids 的更多信息，请查看 UMT5 训练。

  • decoder_attention_mask (torch.BoolTensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。 默认情况下也会使用因果掩码。
  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于屏蔽编码器自注意力模块中选定的注意力头。 掩码值在 [0, 1] 中选择：

    • 1 表示注意力头不被屏蔽，
    • 0 表示注意力头被屏蔽。
  • decoder_head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于屏蔽解码器自注意力模块中选定的注意力头。 掩码值在 [0, 1] 中选择：

    • 1 表示注意力头不被屏蔽，
    • 0 表示注意力头被屏蔽。
  • cross_attn_head_mask (torch.Tensor of shape (num_heads,) or (num_layers, num_heads), optional) — Mask to nullify selected heads of the cross-attention modules in the decoder. Mask values selected in [0, 1]:

    • 1 indicates the head is not masked,
    • 0 indicates the head is masked.
  • encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — Tuple consists of (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state of shape (batch_size, sequence_length, hidden_size) is a sequence of hidden states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.
  • past_key_values (tuple(tuple(torch.FloatTensor)) of length config.n_layers with each tuple having 4 tensors of shape (batch_size, num_heads, sequence_length - 1, embed_size_per_head)) — Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.

    If past_key_values are used, the user can optionally input only the last decoder_input_ids (those that don’t have their past key value states given to this model) of shape (batch_size, 1) instead of all decoder_input_ids of shape (batch_size, sequence_length).

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — Optionally, instead of passing input_ids you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert input_ids indices into associated vectors than the model’s internal embedding lookup matrix.
  • decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — Optionally, instead of passing decoder_input_ids you can choose to directly pass an embedded representation. If past_key_values is used, optionally only the last decoder_inputs_embeds have to be input (see past_key_values). This is useful if you want more control over how to convert decoder_input_ids indices into associated vectors than the model’s internal embedding lookup matrix.

    If decoder_input_ids and decoder_inputs_embeds are both unset, decoder_inputs_embeds takes the value of inputs_embeds.

  • use_cache (bool, optional) — If set to True, past_key_values key value states are returned and can be used to speed up decoding (see past_key_values).
  • output_attentions (bool, optional) — Whether or not to return the attentions tensors of all attention layers. See attentions under returned tensors for more detail.
  • output_hidden_states (bool, optional) — Whether or not to return the hidden states of all layers. See hidden_states under returned tensors for more detail.
  • return_dict (bool, optional) — Whether or not to return a ModelOutput instead of a plain tuple.
  • labels (torch.LongTensor of shape (batch_size,), optional) — Labels for computing the sequence classification/regression loss. Indices should be in [-100, 0, ..., config.vocab_size - 1]. All labels set to -100 are ignored (masked), the loss is only computed for labels in [0, ..., config.vocab_size]

返回值

transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

transformers.modeling_outputs.Seq2SeqLMOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (UMT5Config) 和输入。

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

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

  • past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(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)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每层输出提供一个），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出端的隐藏状态，加上初始嵌入输出。

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

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

  • cross_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.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)，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每层输出提供一个），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出端的隐藏状态，加上初始嵌入输出。

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

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

UMT5ForConditionalGeneration 前向方法，覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, UMT5ForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5ForConditionalGeneration.from_pretrained("google/umt5-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("Studies have shown that <extra_id_0> good for you", return_tensors="pt").input_ids
>>> outputs = model.generate(input_ids)
>>> tokenizer.decode(outputs[0], skip_special_tokens=True)

UMT5EncoderModel

类 transformers.UMT5EncoderModel

< >

（ config ）

参数

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

裸UMT5模型 Transformer，输出编码器的原始隐藏状态，顶部没有任何特定的 head。

UMT5 模型在 Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer 中提出，作者是 Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu。它是一个在文本到文本去噪生成设置中预训练的编码器-解码器 Transformer。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

示例

>>> from transformers import UMT5EncoderModel, AutoTokenizer

>>> model = UMT5EncoderModel.from_pretrained("google/umt5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-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

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 ) → transformers.modeling_outputs.BaseModelOutput 或 torch.FloatTensor 元组

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — Indices of input sequence tokens in the vocabulary. UMT5 is a model with relative position embeddings so you should be able to pad the inputs on both the right and the left.

    Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for detail.

    To know more on how to prepare input_ids for pretraining take a look a UMT5 Training.

  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — Mask to avoid performing attention on padding token indices. Mask values selected in [0, 1]:

    • 1 for tokens that are not masked,
    • 0 for tokens that are masked.

    What are attention masks?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — Mask to nullify selected heads of the self-attention modules. Mask values selected in [0, 1]:

    • 1 indicates the head is not masked,
    • 0 indicates the head is masked.
  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — Optionally, instead of passing input_ids you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert input_ids indices into associated vectors than the model’s internal embedding lookup matrix.
  • output_attentions (bool, optional) — Whether or not to return the attentions tensors of all attention layers. See attentions under returned tensors for more detail.
  • output_hidden_states (bool, optional) — Whether or not to return the hidden states of all layers. See hidden_states under returned tensors for more detail.
  • return_dict (bool, optional) — Whether or not to return a ModelOutput instead of a plain tuple.

返回值

transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

transformers.modeling_outputs.BaseModelOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (UMT5Config) 和输入。

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

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

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

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

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

UMT5EncoderModel 前向方法，覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, UMT5EncoderModel

>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5EncoderModel.from_pretrained("google/umt5-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

UMT5ForSequenceClassification

类 transformers.UMT5ForSequenceClassification

 < >

( config: UMT5Config )

参数

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

带有序列分类/头部（池化输出顶部的线性层）的 UMT5 模型，例如用于 GLUE 任务。

UMT5 模型在 Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer 中提出，作者是 Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu。它是一个在文本到文本去噪生成设置中预训练的编码器-解码器 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 ) → transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。UMT5 是一个带有相对位置嵌入的模型，因此您应该能够在右侧和左侧填充输入。

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

    什么是输入 IDs？

    要了解更多关于如何为预训练准备 input_ids 的信息，请查看 UMT5 训练。

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示 tokens 未被 Mask，
    • 0 表示 tokens 被 Mask。

    什么是 attention masks？

  • decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 词汇表中 decoder 输入序列 tokens 的索引。

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

    什么是 decoder 输入 IDs？

    UMT5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids（请参阅 past_key_values）。

    要了解更多关于如何为预训练准备 decoder_input_ids 的信息，请查看 UMT5 训练。

  • decoder_attention_mask (torch.BoolTensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中 pad tokens 的 tensor。默认情况下也会使用因果 mask。
  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify encoder 中 self-attention 模块的选定 head 的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示 head 未被 Mask，
    • 0 表示 head 被 Mask。
  • decoder_head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify decoder 中 self-attention 模块的选定 head 的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示 head 未被 Mask，
    • 0 表示 head 被 Mask。
  • cross_attn_head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify decoder 中 cross-attention 模块的选定 head 的 Mask。Mask 值在 [0, 1] 中选择：

    • 1 表示 head 未被 Mask，
    • 0 表示 head 被 Mask。
  • encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — Tuple 由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成，形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是 encoder 最后一层输出的 hidden states 序列。在 decoder 的 cross-attention 中使用。
  • past_key_values (tuple(tuple(torch.FloatTensor))，长度为 config.n_layers，每个 tuple 有 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的 tensors) — 包含 attention blocks 的预计算的 key 和 value hidden states。可用于加速解码。

    如果使用 past_key_values，用户可以选择仅输入最后一个 decoder_input_ids（那些没有将其过去的 key value states 提供给此模型的），形状为 (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_ids 和 decoder_inputs_embeds 均未设置，则 decoder_inputs_embeds 将采用 inputs_embeds 的值。

  • use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values key value states，并可用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参阅返回的 tensors 下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回的 tensors 下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通 tuple。
  • labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

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

一个 transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或一个 torch.FloatTensor 的 tuple（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (UMT5Config) 和输入。

  • loss (torch.FloatTensor，形状为 (1,)，可选，当提供 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))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(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)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每层输出提供一个），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出端的隐藏状态，加上初始嵌入输出。

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

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

  • cross_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.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)，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每层输出提供一个），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出端的隐藏状态，加上初始嵌入输出。

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

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

UMT5ForSequenceClassification forward 方法，覆盖了 __call__ 特殊方法。

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

UMT5ForTokenClassification

class transformers.UMT5ForTokenClassification

< >

( config: UMT5Config )

参数

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

带有 token 分类头（hidden-states 输出顶部的线性层）的 UMT5 Encoder 模型，例如用于命名实体识别 (NER) 任务。

UMT5 模型在 Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer 中提出，作者是 Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu。它是一个在文本到文本去噪生成设置中预训练的编码器-解码器 Transformer。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: 可选 = None attention_mask: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 UMT5 是一个使用相对位置嵌入的模型，因此你应该可以在右侧和左侧填充输入。

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

    什么是输入 IDs？

    要了解更多关于如何为预训练准备 input_ids 的信息，请查看 UMT5 训练。

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 tokens 未被 mask，
    • 0 表示 tokens 已被 mask。

    什么是 attention masks？

  • decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 词汇表中 decoder 输入序列 tokens 的索引。

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

    什么是 decoder 输入 IDs？

    UMT5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，则可以选择只输入最后的 decoder_input_ids （请参阅 past_key_values）。

    要了解更多关于如何为预训练准备 decoder_input_ids 的信息，请查看 UMT5 训练。

  • decoder_attention_mask (torch.BoolTensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中的 pad tokens 的 tensor。 默认情况下，也会使用因果 mask。
  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify encoder 中 self-attention 模块的选定 head 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 head 未被 mask，
    • 0 表示 head 已被 mask。
  • decoder_head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify decoder 中 self-attention 模块的选定 head 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 head 未被 mask，
    • 0 表示 head 已被 mask。
  • cross_attn_head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify decoder 中 cross-attention 模块的选定 head 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 head 未被 mask，
    • 0 表示 head 已被 mask。
  • encoder_outputs (tuple(tuple(torch.FloatTensor)，可选) — Tuple 由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成。 形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是 encoder 最后一层的输出端的 hidden states 序列。 在 decoder 的 cross-attention 中使用。
  • past_key_values (tuple(tuple(torch.FloatTensor))，长度为 config.n_layers，每个 tuple 具有 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的 tensors) — 包含 attention blocks 的预计算 key 和 value hidden states。 可用于加速解码。

    如果使用 past_key_values，用户可以选择只输入最后的 decoder_input_ids （那些没有将过去的 key value states 提供给此模型的），形状为 (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_ids 和 decoder_inputs_embeds 均未设置，则 decoder_inputs_embeds 采用 inputs_embeds 的值。

  • use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values key value states，并且可以用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通的 tuple。
  • labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算 token 分类 loss 的标签。 索引应在 [0, ..., config.num_labels - 1] 中。

返回值

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

一个 transformers.modeling_outputs.TokenClassifierOutput 或 torch.FloatTensor 的 tuple (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (UMT5Config) 和输入。

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

  • logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.num_labels)) — 分类得分（在 SoftMax 之前）。

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

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

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

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

UMT5ForTokenClassification forward 方法，覆盖了 __call__ 特殊方法。

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

UMT5ForQuestionAnswering

class transformers.UMT5ForQuestionAnswering

< >

（ config ）

参数

  • config (UMT5Config) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法来加载模型权重。

UMT5 模型，顶部带有 span 分类 head，用于抽取式问答任务，如 SQuAD（hidden-states 输出顶部的线性层，用于计算 span start logits 和 span end logits）。

UMT5 模型在 Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer 中提出，作者是 Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu。它是一个在文本到文本去噪生成设置中预训练的编码器-解码器 Transformer。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: 可选 = None attention_mask: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None head_mask: 可选 = None decoder_head_mask: 可选 = None cross_attn_head_mask: 可选 = None encoder_outputs: 可选 = None start_positions: 可选 = None end_positions: 可选 = None inputs_embeds: 可选 = None decoder_inputs_embeds: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 UMT5 是一个使用相对位置嵌入的模型，因此你应该可以在右侧和左侧填充输入。

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

    什么是输入 IDs？

    要了解更多关于如何为预训练准备 input_ids 的信息，请查看 UMT5 训练。

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择：

    • 1 表示 tokens 未被 mask，
    • 0 表示 tokens 已被 mask。

    什么是 attention masks？

  • decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列 tokens 的索引。

    索引可以通过 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。

    什么是解码器输入 ID？

    UMT5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。 如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids（请参阅 past_key_values）。

    要了解有关如何为预训练准备 decoder_input_ids 的更多信息，请查看 UMT5 训练。

  • decoder_attention_mask (torch.BoolTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，该张量忽略 decoder_input_ids 中的填充 tokens。默认情况下，也将使用因果掩码。
  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使编码器中自注意力模块的选定 head 失效的掩码。 在 [0, 1] 中选择的掩码值：

    • 1 表示 head 未被掩蔽，
    • 0 表示 head 被掩蔽。
  • decoder_head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使解码器中自注意力模块的选定 head 失效的掩码。 在 [0, 1] 中选择的掩码值：

    • 1 表示 head 未被掩蔽，
    • 0 表示 head 被掩蔽。
  • cross_attn_head_mask (torch.Tensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使解码器中交叉注意力模块的选定 head 失效的掩码。 在 [0, 1] 中选择的掩码值：

    • 1 表示 head 未被掩蔽，
    • 0 表示 head 被掩蔽。
  • encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成。 形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是编码器最后一层的输出端的隐藏状态序列。 在解码器的交叉注意力中使用。
  • past_key_values (tuple(tuple(torch.FloatTensor)) of length config.n_layers with each tuple having 4 tensors of shape (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_ids 和 decoder_inputs_embeds 均未设置，则 decoder_inputs_embeds 采用 inputs_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) — 用于计算 token 分类损失的标签跨度的开始位置（索引）的标签。 位置被限制为序列的长度（sequence_length）。 序列之外的位置不纳入损失计算的考虑范围。
  • end_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算 token 分类损失的标签跨度的结束位置（索引）的标签。 位置被限制为序列的长度（sequence_length）。 序列之外的位置不纳入损失计算的考虑范围。

返回值

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

一个 transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时），包括取决于配置 (UMT5Config) 和输入的各种元素。

  • 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))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(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)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每层输出提供一个），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出端的隐藏状态，加上初始嵌入输出。

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

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

  • cross_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.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)，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每层输出提供一个），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出端的隐藏状态，加上初始嵌入输出。

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

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

UMT5ForQuestionAnswering 前向方法，覆盖了 __call__ 特殊方法。

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

< > 在 GitHub 上更新

←UL2 X-MOD→