Hugging Face 的 LOGO

Transformers 文档

T5

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

PyTorch TensorFlow Flax

T5

T5是一个编码器-解码器Transformer，其尺寸范围从60M到11B参数。它旨在通过将所有NLP任务视为文本到文本问题来处理各种NLP任务。这消除了对特定任务架构的需求，因为T5将每个NLP任务转换为文本生成任务。

为了将所有任务都表示为文本生成，每个任务都预置了一个特定于任务的前缀（例如，将英语翻译成德语：……，总结：……）。这使得T5能够处理翻译、摘要、问答等任务。

您可以在T5集合下找到所有官方T5检查点。

点击右侧边栏中的T5模型，了解更多如何将T5应用于不同语言任务的示例。

以下示例展示了如何使用Pipeline、AutoModel生成文本，以及如何通过命令行使用T5进行翻译。

流水线
自动模型
Transformers CLI
import torch
from transformers import pipeline

pipeline = pipeline(
    task="text2text-generation",
    model="google-t5/t5-base",
    torch_dtype=torch.float16,
    device=0
)
pipeline("translate English to French: The weather is nice today.")

量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。

以下示例使用torchao仅将权重量化为int4。

# pip install torchao
import torch
from transformers import TorchAoConfig, AutoModelForSeq2SeqLM, AutoTokenizer

quantization_config = TorchAoConfig("int4_weight_only", group_size=128)
model = AutoModelForSeq2SeqLM.from_pretrained(
    "google/t5-v1_1-xl",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    quantization_config=quantization_config
)

tokenizer = AutoTokenizer.from_pretrained("google/t5-v1_1-xl")
input_ids = tokenizer("translate English to French: The weather is nice today.", return_tensors="pt").to("cuda")

output = model.generate(**input_ids, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))

注意事项

  • T5使用相对标量嵌入，因此您可以对编码器输入进行左填充或右填充。
  • T5模型需要的学习率略高于Trainer中使用的默认值。通常，对于大多数任务，1e-4和3e-4的值效果良好。

T5Config

class transformers.T5Config

< >

( vocab_size = 32128 d_model = 512 d_kv = 64 d_ff = 2048 num_layers = 6 num_decoder_layers = None num_heads = 8 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 = 'relu' is_encoder_decoder = True use_cache = True pad_token_id = 0 eos_token_id = 1 classifier_dropout = 0.0 **kwargs )

参数

  • vocab_size (int, optional, 默认为 32128) — T5模型的词汇表大小。定义了调用T5Model或TFT5Model时传入的inputs_ids所能表示的不同标记的数量。
  • d_model (int, optional, 默认为 512) — 编码器层和池化器层的大小。
  • d_kv (int, optional, 默认为 64) — 每个注意力头键、查询、值投影的大小。投影层的inner_dim将被定义为num_heads * d_kv。
  • d_ff (int, optional, 默认为 2048) — 每个T5Block中中间前馈层的大小。
  • num_layers (int, optional, 默认为 6) — Transformer编码器中的隐藏层数量。
  • num_decoder_layers (int, optional) — Transformer解码器中的隐藏层数量。如果未设置，则使用与num_layers相同的值。
  • num_heads (int, optional, 默认为 8) — Transformer编码器中每个注意力层的注意力头数量。
  • relative_attention_num_buckets (int, optional, 默认为 32) — 每个注意力层使用的桶的数量。
  • relative_attention_max_distance (int, optional, 默认为 128) — 用于桶分离的较长序列的最大距离。
  • dropout_rate (float, optional, 默认为 0.1) — 所有Dropout层的比例。
  • classifier_dropout (float, optional, 默认为 0.0) — 分类器的Dropout比例。
  • layer_norm_eps (float, optional, 默认为 1e-6) — 层归一化层使用的epsilon。
  • initializer_factor (float, optional, 默认为 1) — 初始化所有权重矩阵的因子（应保持为 1，内部用于初始化测试）。
  • feed_forward_proj (string, optional, 默认为"relu") — 要使用的前馈层类型。应为"relu"或"gated-gelu"之一。T5v1.1使用"gated-gelu"前馈投影。原始T5使用"relu"。
  • use_cache (bool, optional, 默认为 True) — 模型是否应返回最后一个键/值注意力（并非所有模型都使用此参数）。

这是用于存储T5Model或TFT5Model配置的配置类。它用于根据指定参数实例化T5模型，定义模型架构。使用默认值实例化配置将生成与T5 google-t5/t5-small架构相似的配置。

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

T5分词器

class transformers.T5Tokenizer

< >

( vocab_file eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' extra_ids = 100 additional_special_tokens = None sp_model_kwargs: typing.Optional[dict[str, typing.Any]] = None legacy = None add_prefix_space = True **kwargs )

参数

  • vocab_file (str) — SentencePiece文件（通常具有.spm扩展名），包含实例化分词器所需的词汇表。
  • eos_token (str, optional, 默认为"</s>") — 序列结束符。

    当使用特殊标记构建序列时，这不是序列结束使用的标记。使用的标记是sep_token。
  • unk_token (str, optional, 默认为"<unk>") — 未知标记。不在词汇表中的标记不能转换为ID，并被设置为此标记。
  • pad_token (str, optional, 默认为"<pad>") — 用于填充的标记，例如在批处理不同长度的序列时。
  • extra_ids (int, optional, 默认为 100) — 为用作标记的词汇表添加额外ID的数量。这些标记可通过调用get_sentinel_tokens方法获取，标记ID可通过调用get_sentinel_token_ids方法获取 additional_special_tokens (list[str], optional): 分词器使用的额外特殊标记。
  • sp_model_kwargs (dict, optional) — 将传递给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的合并操作的dropout概率。
  • legacy (bool, optional) — 是否应使用分词器的legacy行为。在#24622和#25224合并之前是legacy，这些合并包括正确处理特殊标记后出现的标记的修复。一个简单示例：

    • legacy=True:

构造一个T5分词器。基于SentencePiece。

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

build_inputs_with_special_tokens

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]

参数

  • token_ids_0 (list[int]) — 将添加特殊标记的ID列表。
  • token_ids_1 (list[int], optional) — 可选的第二个ID列表，用于序列对。

返回

list[int]

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

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

  • 单个序列：X </s>
  • 序列对：A </s> B </s>

get_special_tokens_mask

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → 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方法添加特殊标记时调用。

create_token_type_ids_from_sequences

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]

参数

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

返回

list[int]

零列表。

根据传入的两个序列创建掩码，用于序列对分类任务。T5 不使用令牌类型 ID，因此返回零列表。

save_vocabulary

< >

( save_directory: str filename_prefix: typing.Optional[str] = None )

T5TokenizerFast

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 add_prefix_space = 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 数量。这些令牌可以通过“<extraid{%d}>”访问，其中“{%d}”是 0 到 extra_ids-1 之间的数字。这些令牌可以通过调用 get_sentinel_tokens 方法获取，令牌 ID 可以通过调用 get_sentinel_token_ids 方法获取。
  • additional_special_tokens (list[str], 可选) — 分词器使用的额外特殊令牌。
  • add_prefix_space (bool, 可选) — 分词器是否应自动添加前缀空格。
  • from_slow (bool, 可选, 默认为 False) — 分词器是否应从慢速分词器转换而来。如果设置了 add_prefix_space，则会将其设置为 True。

构建一个“快速”T5 分词器（由 HuggingFace 的 tokenizers 库支持）。基于 Unigram。

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

build_inputs_with_special_tokens

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → 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: typing.Optional[list[int]] = None ) → list[int]

参数

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

返回

list[int]

零列表。

根据传入的两个序列创建掩码，用于序列对分类任务。T5 不使用令牌类型 ID，因此返回零列表。

Pytorch
隐藏 Pytorch 内容

T5Model

class transformers.T5Model

< >

( config: T5Config )

参数

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

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

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是 input IDs？

    要了解如何为预训练准备 input_ids，请查看 T5 训练。

  • 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？

    T5 使用 pad_token_id 作为 decoder_input_ids 生成的起始令牌。如果使用 past_key_values，可以选择只输入最后一个 decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）（参见 past_key_values）。

    要了解如何为预训练准备 decoder_input_ids，请查看 T5 训练。

  • 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_outputs (tuple[tuple[torch.FloatTensor]], 可选) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) 形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state（可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (tuple[tuple[torch.FloatTensor]], 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码前一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

    允许两种格式：

    • Cache 实例，请参阅我们的 kv cache 指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含两个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。

    模型将输出与作为输入馈送的缓存格式相同的缓存格式。如果未传入 past_key_values，将返回旧版缓存格式。

    如果使用 past_key_values，用户可以选择只输入最后一个 input_ids（那些没有将其过去的键值状态提供给此模型的），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor, 可选) — 或者，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望对 input_ids 索引如何转换为关联向量拥有比模型内部嵌入查找矩阵更多的控制权，这将很有用。
  • decoder_inputs_embeds (形状为 (batch_size, target_sequence_length, hidden_size) 的 torch.Tensor, 可选) — 或者，您可以选择直接传递嵌入表示，而不是传递 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 而不是普通元组。
  • cache_position (形状为 (sequence_length) 的 torch.LongTensor, 可选) — 描述输入序列令牌在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

返回

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

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

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

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

  • past_key_values (EncoderDecoderCache, 可选, 当传入 use_cache=True 或 config.use_cache=True 时返回) — 它是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

    包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 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 之后，用于计算自注意力头中的加权平均。

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

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

示例

>>> from transformers import AutoTokenizer, T5Model

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

T5ForConditionalGeneration

class transformers.T5ForConditionalGeneration

< >

( config: T5Config )

参数

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

顶部带有 `language modeling` 头的 T5 模型。

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.Tensor]]] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是 input IDs？

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

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

    • 1 表示 token 未被掩码，
    • 0 表示 token 被掩码。

    什么是注意力掩码？

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

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

    什么是解码器输入 IDs？

    T5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，可以选择只输入最后一个 decoder_input_ids（那些没有将它们的 past key value 状态提供给此模型的）的形状 (batch_size, 1)，而不是所有 input_ids 的形状 (batch_size, sequence_length)。

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

  • decoder_attention_mask (torch.BoolTensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充 token 的张量。默认情况下也将使用因果掩码。
  • 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，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使解码器中交叉注意力模块的选定头部无效的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示头部未被掩码，
    • 0 表示头部被掩码。
  • encoder_outputs (tuple[tuple[torch.Tensor]]，可选) — 元组由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成，last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中用到。
  • past_key_values (tuple[tuple[torch.Tensor]]，可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

    允许两种格式：

    • Cache 实例，请参阅我们的 kv cache 指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量）。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传入 past_key_values，将返回旧版缓存格式。

    如果使用 past_key_values，用户可以选择只输入最后一个 input_ids（那些没有将其 past key value 状态提供给此模型的）的形状 (batch_size, 1)，而不是所有 input_ids 的形状 (batch_size, sequence_length)。

  • 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 的值。

  • labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [-100, 0, ..., config.vocab_size - 1] 范围内。所有设置为 -100 的标签都会被忽略（被掩码），损失仅针对 [0, ..., config.vocab_size] 范围内的标签计算。
  • use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
  • cache_position (torch.LongTensor，形状为 (sequence_length)，可选) — 表示输入序列 token 在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

返回

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

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含根据配置 (T5Config) 和输入的不同元素。

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

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

  • past_key_values (EncoderDecoderCache, 可选, 当传入 use_cache=True 或 config.use_cache=True 时返回) — 它是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

    包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 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 之后，用于计算自注意力头中的加权平均。

T5ForConditionalGeneration 的 forward 方法，重写了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, T5ForConditionalGeneration

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

T5EncoderModel

class transformers.T5EncoderModel

< >

( config: T5Config )

参数

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

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

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)

参数

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

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

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

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

    • 1 表示 token 未被掩码，
    • 0 表示 token 被掩码。

    什么是注意力掩码？

  • 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=False 或当 config.return_dict=False 时），其中包含根据配置 (T5Config) 和输入的不同元素。

  • 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 后的注意力权重，用于计算自注意力头中的加权平均值。

T5EncoderModel 的 forward 方法，重写了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, T5EncoderModel

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

T5ForSequenceClassification

class transformers.T5ForSequenceClassification

< >

( config: T5Config )

参数

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

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

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[list[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是 input IDs？

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

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充 token 索引上执行注意力操作的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示 token 未被掩码，
    • 0 表示 token 被掩码。

    什么是注意力掩码？

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

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

    什么是解码器输入 IDs？

    T5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，可以选择只输入最后一个 decoder_input_ids（那些没有将它们的 past key value 状态提供给此模型的）的形状 (batch_size, 1)，而不是所有 input_ids 的形状 (batch_size, sequence_length)。

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

  • decoder_attention_mask (torch.BoolTensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充 token 的张量。默认情况下也将使用因果掩码。
  • head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.Tensor，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值在 [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_outputs (list[torch.FloatTensor], 可选) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • 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_ids 和 decoder_inputs_embeds 都未设置，则 decoder_inputs_embeds 取 inputs_embeds 的值。

  • labels (形状为 (batch_size,) 的 torch.LongTensor，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels > 1 则计算分类损失 (交叉熵)。
  • 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.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)

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

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

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

  • past_key_values (EncoderDecoderCache, 可选, 当传入 use_cache=True 或 config.use_cache=True 时返回) — 它是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

    包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 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 之后，用于计算自注意力头中的加权平均。

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

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

单标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, T5ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5ForSequenceClassification.from_pretrained("google-t5/t5-small")

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

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

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # 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 = T5ForSequenceClassification.from_pretrained("google-t5/t5-small", num_labels=num_labels)

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

多标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, T5ForSequenceClassification

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

T5ForTokenClassification

class transformers.T5ForTokenClassification

< >

( config: T5Config )

参数

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

带有令牌分类头（在隐藏状态输出之上有一个线性层）的 T5 转换器，例如用于命名实体识别 (NER) 任务。

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

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

forward

 < >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

    要了解如何为预训练准备 input_ids，请参阅 T5 训练。

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

    • 1 表示令牌未被遮蔽，
    • 0 表示令牌被遮蔽。

    什么是注意力掩码？

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

    • 1 表示头部未被遮蔽，
    • 0 表示头部被遮蔽。
  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为相关向量，这会很有用。
  • labels (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 用于计算令牌分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参见返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多详细信息请参见返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

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

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

  • 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 时返回) — 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, T5ForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5ForTokenClassification.from_pretrained("google-t5/t5-small")

>>> 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]]
>>> predicted_tokens_classes
...

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

T5ForQuestionAnswering

class transformers.T5ForQuestionAnswering

< >

( config: T5Config )

参数

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

用于提取式问答任务（如 SQuAD）的 T5 转换器，顶部带有一个跨度分类头（在隐藏状态输出之上有一个线性层，用于计算 span start logits 和 span end logits）。

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

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

forward

 < >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.Tensor]]] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID？

    要了解如何为预训练准备 input_ids，请参阅 T5 训练。

  • 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？

    T5 使用 pad_token_id 作为 decoder_input_ids 生成的起始令牌。如果使用 past_key_values，可选地只需输入最后的 decoder_input_ids (参见 past_key_values)。

    要了解如何为预训练准备 decoder_input_ids，请参阅 T5 训练。

  • 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_outputs (tuple[tuple[torch.Tensor]]，可选) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • start_positions (形状为 (batch_size,) 的 torch.LongTensor，可选) — 用于计算令牌分类损失的标记跨度起始位置（索引）的标签。位置被限制为序列的长度（sequence_length）。序列外的位置不计入损失计算。
  • end_positions (形状为 (batch_size,) 的 torch.LongTensor，可选) — 用于计算令牌分类损失的标记跨度结束位置（索引）的标签。位置被限制为序列的长度（sequence_length）。序列外的位置不计入损失计算。
  • 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_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.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

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

  • loss (torch.FloatTensor of shape (1,), 可选, 当提供 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 (EncoderDecoderCache, 可选, 当传入 use_cache=True 或 config.use_cache=True 时返回) — 它是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

    包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 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 之后，用于计算自注意力头中的加权平均。

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

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

示例

>>> from transformers import AutoTokenizer, T5ForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = T5ForQuestionAnswering.from_pretrained("google-t5/t5-small")

>>> 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]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # 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
>>> round(loss.item(), 2)
...
TensorFlow
隐藏 TensorFlow 内容

TFT5Model

class transformers.TFT5Model

< >

( config *inputs **kwargs )

参数

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

不带任何特定头部输出原始隐藏状态的裸 T5 模型转换器。

T5 模型由 Colin Raffel、Noam Shazeer、Adam Roberts、Katherine Lee、Sharan Narang、Michael Matena、Yanqi Zhou、Wei Li、Peter J. Liu 在 《探索迁移学习的极限与统一的文本到文本转换器》 中提出。它是一个编码器-解码器转换器，在文本到文本去噪生成设置中进行预训练。

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

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参阅 TF 2.0 文档以了解所有与一般用法和行为相关的事项。

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

  • 所有输入作为关键字参数（如 PyTorch 模型），或
  • 所有输入作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用 model.fit() 等方法时，一切都应该“正常工作”——只需以 model.fit() 支持的任何格式传递你的输入和标签即可！但是，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional 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 函数一样传递输入！

调用

 < >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: np.ndarray | tf.Tensor | None = None past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)

参数

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

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

    什么是输入 ID？

    要了解有关如何准备用于预训练的 inputs，请参阅 T5 训练。

  • decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 tf.Tensor, 可选) — 用于序列到序列训练。T5 使用 pad_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids（那些没有将过去的键值状态提供给此模型的）的形状为 (batch_size, 1)，而不是所有 decoder_input_ids 的形状为 (batch_size, sequence_length)。

    要了解有关如何准备用于预训练的 decoder_input_ids，请参阅 T5 训练。

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

    • 1 表示标记未被掩码,
    • 0 表示标记被掩码.

    什么是注意力掩码？

  • decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 tf.Tensor, 可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。因果掩码也将默认使用。
  • head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 tf.Tensor, 可选) — 用于将编码器中自注意力模块的选定头部置零的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示头部未被掩码,
    • 0 表示头部被掩码.
  • decoder_head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 tf.Tensor, 可选) — 用于将解码器中自注意力模块的选定头部置零的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示头部未被掩码,
    • 0 表示头部被掩码.
  • encoder_outputs (tuple(tuple(tf.FloatTensor), 可选) — 元组包括 (last_hidden_state, 可选: hidden_states, 可选: attentions)。形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (tuple(tuple(tf.Tensor))，长度为 config.n_layers，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量) — 包含注意力块的预计算键值隐藏状态。可用于加速解码。

    如果使用 past_key_values，用户可以选择只输入最后一个 decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为 (batch_size, 1)，而不是所有 decoder_input_ids 的形状为 (batch_size, sequence_length)。

  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，则此功能很有用。
  • decoder_inputs_embeds (形状为 (batch_size, target_sequence_length, hidden_size) 的 tf.Tensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 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) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。此参数可在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。
  • training (bool, 可选, 默认为 False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。

返回

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

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

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

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

  • past_key_values (list[tf.Tensor], 可选, 当传入 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见 past_key_values 输入）加速顺序解码。

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

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

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

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

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

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

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。

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

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

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

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

TFT5Model 的前向方法，覆盖 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, TFT5Model

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = TFT5Model.from_pretrained("google-t5/t5-small")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="tf"
... ).input_ids  # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="tf").input_ids  # Batch size 1

>>> # preprocess: Prepend decoder_input_ids with start token which is pad token for T5Model.
>>> # This is not needed for torch's T5ForConditionalGeneration as it does this internally using labels arg.
>>> decoder_input_ids = model._shift_right(decoder_input_ids)

>>> # forward pass
>>> outputs = model(input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state

TFT5ForConditionalGeneration

类 transformers.TFT5ForConditionalGeneration

< >

( config *inputs **kwargs )

参数

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

顶部带有 `language modeling` 头的 T5 模型。

T5 模型由 Colin Raffel、Noam Shazeer、Adam Roberts、Katherine Lee、Sharan Narang、Michael Matena、Yanqi Zhou、Wei Li、Peter J. Liu 在 《探索迁移学习的极限与统一的文本到文本转换器》 中提出。它是一个编码器-解码器转换器，在文本到文本去噪生成设置中进行预训练。

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

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参阅 TF 2.0 文档以了解所有与一般用法和行为相关的事项。

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

  • 所有输入作为关键字参数（如 PyTorch 模型），或
  • 所有输入作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用 model.fit() 等方法时，一切都应该“正常工作”——只需以 model.fit() 支持的任何格式传递你的输入和标签即可！但是，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional 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 函数一样传递输入！

调用

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: np.ndarray | tf.Tensor | None = None past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)

参数

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

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

    什么是输入 ID？

    要了解如何准备用于预训练的 inputs，请参阅 T5 训练。

  • decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 tf.Tensor, 可选) — 用于序列到序列训练。T5 使用 pad_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids（那些没有将过去的键值状态提供给此模型的）的形状为 (batch_size, 1)，而不是所有 decoder_input_ids 的形状为 (batch_size, sequence_length)。

    要了解如何准备用于预训练的 decoder_input_ids，请参阅 T5 训练。

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

    • 1 表示标记未被掩码,
    • 0 表示标记被掩码.

    什么是注意力掩码？

  • decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 tf.Tensor, 可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。因果掩码也将默认使用。
  • head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 tf.Tensor, 可选) — 用于将编码器中自注意力模块的选定头部置零的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示头部未被掩码,
    • 0 表示头部被掩码.
  • decoder_head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 tf.Tensor, 可选) — 用于将解码器中自注意力模块的选定头部置零的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示头部未被掩码,
    • 0 表示头部被掩码.
  • encoder_outputs (tuple(tuple(tf.FloatTensor), 可选) — 元组包括 (last_hidden_state, 可选: hidden_states, 可选: attentions)。形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (tuple(tuple(tf.Tensor))，长度为 config.n_layers，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量) — 包含注意力块的预计算键值隐藏状态。可用于加速解码。

    如果使用 past_key_values，用户可以选择只输入最后一个 decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为 (batch_size, 1)，而不是所有 decoder_input_ids 的形状为 (batch_size, sequence_length)。

  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，则此功能很有用。
  • decoder_inputs_embeds (形状为 (batch_size, target_sequence_length, hidden_size) 的 tf.Tensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 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) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。此参数可在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。
  • training (bool, 可选, 默认为 False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
  • labels (形状为 (batch_size, sequence_length) 的 tf.Tensor, 可选) — 用于计算交叉熵分类损失的标签。索引应在 [0, ..., config.vocab_size - 1] 范围内。

返回

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

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

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

  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前每个词汇标记的分数）。

  • past_key_values (list[tf.Tensor], 可选, 当传入 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见 past_key_values 输入）加速顺序解码。

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

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

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

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

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

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

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。

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

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

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

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

TFT5ForConditionalGeneration 的前向方法，覆盖 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, TFT5ForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = TFT5ForConditionalGeneration.from_pretrained("google-t5/t5-small")

>>> # training
>>> inputs = tokenizer("The <extra_id_0> walks in <extra_id_1> park", return_tensors="tf").input_ids
>>> labels = tokenizer("<extra_id_0> cute dog <extra_id_1> the <extra_id_2>", return_tensors="tf").input_ids
>>> outputs = model(inputs, labels=labels)
>>> loss = outputs.loss
>>> logits = outputs.logits

>>> # inference
>>> inputs = tokenizer(
...     "summarize: studies have shown that owning a dog is good for you", return_tensors="tf"
... ).input_ids  # Batch size 1
>>> outputs = model.generate(inputs)
>>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
>>> # studies have shown that owning a dog is good for you

TFT5EncoderModel

类 transformers.TFT5EncoderModel

< >

( config *inputs **kwargs )

参数

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

裸 T5 模型，输出编码器的原始隐藏状态，不带任何特定头部。

T5 模型由 Colin Raffel、Noam Shazeer、Adam Roberts、Katherine Lee、Sharan Narang、Michael Matena、Yanqi Zhou、Wei Li、Peter J. Liu 在 《探索迁移学习的极限与统一的文本到文本转换器》 中提出。它是一个编码器-解码器转换器，在文本到文本去噪生成设置中进行预训练。

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

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参阅 TF 2.0 文档以了解所有与一般用法和行为相关的事项。

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

  • 所有输入作为关键字参数（如 PyTorch 模型），或
  • 所有输入作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用 model.fit() 等方法时，一切都应该“正常工作”——只需以 model.fit() 支持的任何格式传递你的输入和标签即可！但是，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional 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 函数一样传递输入！

调用

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)

参数

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

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

    要了解如何准备用于预训练的 inputs，请参阅 T5 训练。

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

    • 1 表示标记未被掩码,
    • 0 表示标记被掩码.

    什么是注意力掩码？

  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，则此功能很有用。
  • head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 tf.Tensor，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头部未被遮蔽，
    • 0 表示头部被遮蔽。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多详情请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多详情请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通的元组。
  • 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 时），根据配置 (T5Config) 和输入包含各种元素。

  • last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

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

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

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

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

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

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

示例

>>> from transformers import AutoTokenizer, TFT5EncoderModel

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = TFT5EncoderModel.from_pretrained("google-t5/t5-small")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="tf"
... ).input_ids  # Batch size 1
>>> outputs = model(input_ids)
JAX
隐藏 JAX 内容

FlaxT5Model

class transformers.FlaxT5Model

< >

( 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 )

__call__

< >

( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: Array = None decoder_attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

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

    索引可以使用 AutoTokenizer 获取。更多详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是 input IDs？

    要了解如何为预训练准备 input_ids，请查看 T5 训练。

  • attention_mask (形状为 (batch_size, sequence_length) 的 jnp.ndarray，可选) — 避免对填充 token 索引执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示 token 未被遮蔽，
    • 0 表示 token 被遮蔽。

    什么是注意力掩码？

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

    索引可以使用 AutoTokenizer 获取。更多详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    T5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，可以选择只输入最后一个 decoder_input_ids（那些没有将过去的键值状态提供给此模型的）形状为 (batch_size, 1) 而不是所有 decoder_input_ids 形状为 (batch_size, sequence_length)。

    要了解如何为预训练准备 decoder_input_ids，请查看 T5 训练。

  • decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 jnp.ndarray，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充 token 的张量。默认情况下也将使用因果掩码。
  • encoder_outputs (tuple(tuple(jnp.ndarray)，可选) — 元组包含 (last_hidden_state, optional: hidden_states, optional: attentions)。形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。
  • past_key_values (长度为 config.n_layers 的 tuple(tuple(jnp.ndarray))，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

    如果使用 past_key_values，用户可以选择只输入最后一个 decoder_input_ids（那些没有将过去的键值状态提供给此模型的），形状为 (batch_size, 1)，而不是所有 decoder_input_ids 形状为 (batch_size, sequence_length)。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置 (T5Config) 和输入包含各种元素。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。

  • past_key_values (tuple(tuple(jnp.ndarray))，可选，当传入 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(jnp.ndarray) 元组，每个元组包含 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(jnp.ndarray)，可选，当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入层输出 + 每个层的输出）。

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

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

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

  • cross_attentions (tuple(jnp.ndarray)，可选，当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 jnp.ndarray 元组（每个层一个）。

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

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(jnp.ndarray)，可选，当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入层输出 + 每个层的输出）。

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

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

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

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

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

示例

>>> from transformers import AutoTokenizer, FlaxT5Model

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = FlaxT5Model.from_pretrained("google-t5/t5-small")

>>> input_ids = tokenizer(
...     "Studies have been shown that owning a dog is good for you", return_tensors="np"
... ).input_ids
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="np").input_ids

>>> # preprocess: Prepend decoder_input_ids with start token which is pad token for T5Model.
>>> # This is not needed for torch's T5ForConditionalGeneration 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

编码

< >

( input_ids: Array attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)

参数

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

    索引可以使用 AutoTokenizer 获取。更多详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    要了解如何为预训练准备 input_ids，请查看 T5 训练。

  • attention_mask (形状为 (batch_size, sequence_length) 的 jnp.ndarray，可选) — 避免对填充 token 索引执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示 token 未被遮蔽，
    • 0 表示 token 被遮蔽。

    什么是注意力掩码？

  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多详情请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多详情请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置 (<class 'transformers.models.t5.configuration_t5.T5Config'>) 和输入包含各种元素。

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

  • hidden_states (tuple(jnp.ndarray)，可选，当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入层输出 + 每个层的输出）。

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

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

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

示例

>>> from transformers import AutoTokenizer, FlaxT5ForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("google-t5/t5-small")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)

解码

< >

( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None past_key_values: typing.Optional[dict] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

参数

  • decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 jnp.ndarray) — 词汇表中解码器输入序列 token 的索引。

    索引可以使用 AutoTokenizer 获取。更多详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    对于训练，应提供 decoder_input_ids。

  • encoder_outputs (tuple(tuple(jnp.ndarray)) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions)。形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state，可选) 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。
  • encoder_attention_mask (形状为 (batch_size, sequence_length) 的 jnp.ndarray，可选) — 避免对填充 token 索引执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示 token 未被遮蔽，
    • 0 表示 token 被遮蔽。

    什么是注意力掩码？

  • decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 jnp.ndarray，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充 token 的张量。默认情况下也将使用因果掩码。

    如果您想改变填充行为，您应该根据您的需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。

  • past_key_values (Dict[str, np.ndarray]，可选，由 init_cache 返回或当传递之前的 past_key_values 时返回) — 预计算隐藏状态（注意力块中的键和值）的字典，可用于快速自回归解码。预计算的键和值隐藏状态的形状为 [batch_size, max_length]。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多详情请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多详情请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置 (<class 'transformers.models.t5.configuration_t5.T5Config'>) 和输入包含各种元素。

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

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

  • past_key_values (tuple(tuple(jnp.ndarray))，可选，当传入 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(jnp.ndarray) 元组，每个元组包含 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(jnp.ndarray)，可选，当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入层输出 + 每个层的输出）。

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

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

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

  • cross_attentions (tuple(jnp.ndarray)，可选，当传入 output_attentions=True 且 config.add_cross_attention=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 jnp.ndarray 元组（每个层一个）。

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

示例

>>> from transformers import AutoTokenizer, FlaxT5ForConditionalGeneration
>>> import jax.numpy as jnp

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("google-t5/t5-small")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)

>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id

>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logits

FlaxT5ForConditionalGeneration

class transformers.FlaxT5ForConditionalGeneration

< >

( 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 )

__call__

< >

( input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: Array = None decoder_attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

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

    索引可以使用 AutoTokenizer 获取。更多详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是 input IDs？

    要了解如何为预训练准备 input_ids，请查看 T5 训练。

  • attention_mask (形状为 (batch_size, sequence_length) 的 jnp.ndarray，可选) — 避免对填充 token 索引执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示 token 未被遮蔽，
    • 0 表示 token 被遮蔽。

    什么是注意力掩码？

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

    索引可以使用 AutoTokenizer 获取。更多详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    T5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，可以选择只输入最后一个 decoder_input_ids（那些没有将过去的键值状态提供给此模型的）形状为 (batch_size, 1) 而不是所有 decoder_input_ids 形状为 (batch_size, sequence_length)。

    要了解如何为预训练准备 decoder_input_ids，请查看 T5 训练。

  • decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 jnp.ndarray，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充 token 的张量。默认情况下也将使用因果掩码。
  • encoder_outputs (tuple(tuple(jnp.ndarray)，可选) — 元组包含 (last_hidden_state, optional: hidden_states, optional: attentions)。形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。
  • past_key_values (长度为 config.n_layers 的 tuple(tuple(jnp.ndarray))，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

    如果使用 past_key_values，用户可以选择只输入最后一个 decoder_input_ids（那些没有将过去的键值状态提供给此模型的）形状为 (batch_size, 1)，而不是所有 decoder_input_ids 形状为 (batch_size, sequence_length)。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置 (T5Config) 和输入包含各种元素。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。

  • past_key_values (tuple(tuple(jnp.ndarray))，可选，当传入 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(jnp.ndarray) 元组，每个元组包含 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(jnp.ndarray)，可选，当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入层输出 + 每个层的输出）。

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

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

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

  • cross_attentions (tuple(jnp.ndarray)，可选，当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 jnp.ndarray 元组（每个层一个）。

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

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(jnp.ndarray)，可选，当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入层输出 + 每个层的输出）。

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

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

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

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

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

示例

>>> from transformers import AutoTokenizer, FlaxT5ForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("google-t5/t5-small")

>>> ARTICLE_TO_SUMMARIZE = "summarize: My friends are cool but they eat too many carbs."
>>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], return_tensors="np")

>>> # Generate Summary
>>> summary_ids = model.generate(inputs["input_ids"]).sequences
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=False))

编码

< >

( input_ids: Array attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)

参数

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

    索引可以使用 AutoTokenizer 获取。更多详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    要了解如何为预训练准备 input_ids，请查看 T5 训练。

  • attention_mask (jnp.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示**未被掩码**的标记，
    • 0 表示**被掩码**的标记。

    什么是注意力掩码？

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量中的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置 (<class 'transformers.models.t5.configuration_t5.T5Config'>) 和输入包含各种元素。

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

  • hidden_states (tuple(jnp.ndarray)，可选，当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入层输出 + 每个层的输出）。

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

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

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

示例

>>> from transformers import AutoTokenizer, FlaxT5ForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("google-t5/t5-small")

>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)

解码

< >

( decoder_input_ids encoder_outputs encoder_attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None past_key_values: typing.Optional[dict] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

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

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

    什么是解码器输入 ID？

    对于训练，应提供 decoder_input_ids。

  • encoder_outputs (tuple(tuple(jnp.ndarray)) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state 形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中会使用到。
  • encoder_attention_mask (jnp.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示**未被掩码**的标记，
    • 0 表示**被掩码**的标记。

    什么是注意力掩码？

  • decoder_attention_mask (jnp.ndarray，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也会使用因果掩码。

    如果您想更改填充行为，应根据您的需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。

  • past_key_values (Dict[str, np.ndarray], 可选，由 init_cache 或传递先前的 past_key_values 时返回) — 预先计算的隐藏状态字典（注意力块中的键和值），可用于快速自回归解码。预先计算的键和值隐藏状态的形状为 [batch_size, max_length]。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量中的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 对象或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False），包含根据配置（<class 'transformers.models.t5.configuration_t5.T5Config'>）和输入而定的各种元素。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。

  • hidden_states (tuple(jnp.ndarray)，可选，当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入层输出 + 每个层的输出）。

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

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

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

  • cross_attentions (tuple(jnp.ndarray)，可选，当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 jnp.ndarray 元组（每个层一个）。

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

  • past_key_values (tuple(tuple(jnp.ndarray)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 jnp.ndarray 元组，每个元组包含自注意力和交叉注意力层的缓存键和值状态（如果模型在编码器-解码器设置中使用）。仅当 config.is_decoder = True 时相关。

    包含预先计算的隐藏状态（注意力块中的键和值），可用于（请参阅 past_key_values 输入）加速顺序解码。

示例

>>> from transformers import AutoTokenizer, FlaxT5ForConditionalGeneration
>>> import jax.numpy as jnp

>>> tokenizer = AutoTokenizer.from_pretrained("google-t5/t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("google-t5/t5-small")

>>> text = "summarize: My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)

>>> decoder_start_token_id = model.config.decoder_start_token_id
>>> decoder_input_ids = jnp.ones((inputs.input_ids.shape[0], 1), dtype="i4") * decoder_start_token_id

>>> outputs = model.decode(decoder_input_ids, encoder_outputs)
>>> logits = outputs.logits

FlaxT5EncoderModel

class transformers.FlaxT5EncoderModel

< >

( 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 )

__call__

< >

( input_ids: Array attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None )

参数

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

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

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

  • attention_mask (jnp.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示**未被掩码**的标记，
    • 0 表示**被掩码**的标记。

    什么是注意力掩码？

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量中的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

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

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

< > 在 GitHub 上更新

←SwitchTransformers T5Gemma→