Transformers 4.37 中文文档（五十九）（5）

Transformers 4.37 中文文档（五十九）（4）https://developer.aliyun.com/article/156529

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: Optional = None decoder_input_ids: Array = None decoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids (jnp.ndarray of shape (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。T5 是一个具有相对位置嵌入的模型，因此您应该能够在右侧和左侧填充输入。
  索引可以使用 AutoTokenizer 获得。详细信息请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  输入 ID 是什么？
  要了解如何为预训练准备input_ids，请查看 T5 训练。
  
• attention_mask (jnp.ndarray of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：

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

• 注意力掩码是什么？
  
• decoder_input_ids (jnp.ndarray of shape (batch_size, target_sequence_length), optional) — 解码器输入序列标记在词汇表中的索引。
  索引可以使用 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 (jnp.ndarray of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。
  
• encoder_outputs (tuple(tuple(jnp.ndarray), optional) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  
• past_key_values (tuple(tuple(jnp.ndarray))，长度为config.n_layers，每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量） — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。
  如果使用了past_key_values，用户可以选择仅输入最后一个形状为(batch_size, 1)的decoder_input_ids（这些没有将它们的过去键值状态提供给此模型）而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。
  

返回

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

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

• logits (jnp.ndarray，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• 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 (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
  
• 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的前向方法覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, FlaxT5Model
>>> tokenizer = AutoTokenizer.from_pretrained("t5-small")
>>> model = FlaxT5Model.from_pretrained("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

encode

<来源>

( input_ids: Array attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

• 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]之间：

• 对于未被masked的标记为 1。
  
• 对于被masked的标记为 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 (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
  
• 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("t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("t5-small")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)

decode

<来源>

( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions or 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, optional: hidden_states, optional: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，optional) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  
• encoder_attention_mask (jnp.ndarray of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 之间：

• 对于未被 masked 的标记，值为 1。
  
• 对于被 masked 的标记，值为 0。
  

• 什么是注意力掩码？
  
• decoder_attention_mask (jnp.ndarray of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。因果掩码也将默认使用。
  如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见 论文 中的图表 1。
  
• past_key_values (Dict[str, np.ndarray], optional, 由 init_cache 返回或传递先前的 past_key_values 时返回) — 可用于快速自回归解码的预计算隐藏状态（注意力块中的键和值）的字典。预计算的键和值隐藏状态的形状为 [batch_size, max_length]。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的 attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的 hidden_states。
  
• return_dict (bool, optional) — 是否返回 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 (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
  如果仅使用 past_key_values，则输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
  
• past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递 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), optional, 当传递 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("t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("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: Optional = None decoder_input_ids: Array = None decoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids (jnp.ndarray，形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。T5 是一个具有相对位置嵌入的模型，因此您应该能够在右侧和左侧都对输入进行填充。
  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。
  什么是输入 ID？
  要了解有关如何为预训练准备input_ids的更多信息，请查看 T5 训练。
  
• attention_mask (jnp.ndarray，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

• 1 表示未被masked的标记。
  
• 0 表示被masked的标记。
  

• 什么是注意力掩码？
  
• decoder_input_ids (jnp.ndarray，形状为(batch_size, target_sequence_length)，可选) — 解码器输入序列标记在词汇表中的索引。
  可以使用 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 (jnp.ndarray，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。
  
• encoder_outputs (tuple(tuple(jnp.ndarray)，可选) — 元组包括(last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  
• past_key_values (tuple(tuple(jnp.ndarray))，长度为config.n_layers，每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量） — 包含注意力块的预先计算的键和值隐藏状态。可用于加速解码。
  如果使用past_key_values，用户可以选择只输入形状为(batch_size, 1)的最后一个decoder_input_ids（那些没有将其过去键值状态提供给此模型的）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
  

返回

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

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（T5Config）和输入的不同元素。

• logits (jnp.ndarray，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递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)的张量。
  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。
  
• decoder_hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
  解码器在每一层的输出的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(jnp.ndarray)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(jnp.ndarray)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。
  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(jnp.ndarray)，optional，当传递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的前向方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, FlaxT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("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))

encode

<来源>

( input_ids: Array attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的jnp.ndarray）— 词汇表中输入序列标记的索引。T5 是一个具有相对位置嵌入的模型，因此您应该能够在右侧和左侧都填充输入。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  了解如何为预训练准备input_ids，请查看 T5 训练。
  
• attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

• 对于未被masked的标记为 1，
  
• 对于被masked的标记为 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("t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("t5-small")
>>> text = "My friends are cool but they eat too many carbs."
>>> inputs = tokenizer(text, return_tensors="np")
>>> encoder_outputs = model.encode(**inputs)

decode

<来源>

( decoder_input_ids encoder_outputs encoder_attention_mask: Optional = None decoder_attention_mask: Optional = None past_key_values: dict = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• decoder_input_ids (jnp.ndarray of shape (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 of shape (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 之间：

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

• 什么是注意力掩码？
  
• decoder_attention_mask (jnp.ndarray of shape (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 (jnp.ndarray of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• 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("t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("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: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None )

参数

• input_ids（形状为(batch_size, sequence_length)的jnp.ndarray） — 词汇表中输入序列标记的索引。T5 是一个具有相对位置嵌入的模型，因此您应该能够在右侧和左侧填充输入。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  了解如何为预训练准备input_ids，请查看 T5 训练。
  
• attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选） — 避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：

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

• 什么是注意力遮罩？
  
• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。
  
• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
  
• return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。
  

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

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

力 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("t5-small")
>>> model = FlaxT5ForConditionalGeneration.from_pretrained("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: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None )

参数

• input_ids（形状为(batch_size, sequence_length)的jnp.ndarray） — 词汇表中输入序列标记的索引。T5 是一个具有相对位置嵌入的模型，因此您应该能够在右侧和左侧填充输入。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  了解如何为预训练准备input_ids，请查看 T5 训练。
  
• attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选） — 避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：

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

• 什么是注意力遮罩？
  
• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。
  
• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
  
• return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。
  

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

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