Hugging Face 的标志

Transformers 文档

模型输出

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

模型输出

所有模型的输出都是 ModelOutput 子类的实例。这些数据结构包含模型返回的所有信息，但也可以用作元组或字典。

让我们看一个例子，了解一下它是怎样的

from transformers import BertTokenizer, BertForSequenceClassification
import torch

tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = BertForSequenceClassification.from_pretrained("google-bert/bert-base-uncased")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
labels = torch.tensor([1]).unsqueeze(0)  # Batch size 1
outputs = model(**inputs, labels=labels)

outputs 对象是一个 SequenceClassifierOutput，正如我们在下面该类的文档中看到的，这意味着它有一个可选的 loss、一个 logits、一个可选的 hidden_states 和一个可选的 attentions 属性。这里我们有 loss，因为我们传递了 labels，但我们没有 hidden_states 和 attentions，因为我们没有传递 output_hidden_states=True 或 output_attentions=True。

当传递 output_hidden_states=True 时，您可能期望 outputs.hidden_states[-1] 与 outputs.last_hidden_state 完全匹配。但是，情况并非总是如此。有些模型在返回最后一个隐藏状态时会应用归一化或后续处理。

您可以像往常一样访问每个属性，如果该属性未被模型返回，您将得到 None。例如，这里的 outputs.loss 是模型计算的损失，而 outputs.attentions 是 None。

当将我们的 outputs 对象视为元组时，它只考虑没有 None 值的属性。例如，这里它有两个元素，loss 然后是 logits，所以

outputs[:2]

将返回元组 (outputs.loss, outputs.logits) 例如。

当将我们的 outputs 对象视为字典时，它只考虑没有 None 值的属性。例如，这里它有两个键，分别是 loss 和 logits。

我们在此处记录了多个模型类型通用的模型输出。特定输出类型记录在其对应的模型页面上。

ModelOutput

class transformers.utils.ModelOutput

< >

( *args **kwargs )

所有模型输出的数据类基类。具有 __getitem__ 方法，允许通过整数或切片（如元组）或字符串（如字典）进行索引，这将忽略 None 属性。否则行为类似于常规 python 字典。

您不能直接解包 ModelOutput。使用 to_tuple() 方法将其转换为元组后再使用。

to_tuple

< >

( )

将自身转换为包含所有非 None 属性/键的元组。

BaseModelOutput

class transformers.modeling_outputs.BaseModelOutput

< >

( last_hidden_state: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

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

模型输出的基类，具有潜在的隐藏状态和注意力。

BaseModelOutputWithPooling

class transformers.modeling_outputs.BaseModelOutputWithPooling

< >

( last_hidden_state: FloatTensor = None pooler_output: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出端的隐藏状态序列。
  • pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 序列的第一个标记（分类标记）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理。例如，对于 BERT 系列模型，这返回分类标记，该标记在经过线性层和 tanh 激活函数处理后返回。线性层权重从预训练期间的下一个句子预测（分类）目标中训练而来。
  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

模型输出的基类，也包含最后一层隐藏状态的池化。

BaseModelOutputWithCrossAttentions

class transformers.modeling_outputs.BaseModelOutputWithCrossAttentions

< >

( last_hidden_state: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • 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 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组 (每层一个)。

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

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

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

模型输出的基类，具有潜在的隐藏状态和注意力。

BaseModelOutputWithPoolingAndCrossAttentions

class transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions

< >

( last_hidden_state: FloatTensor = None pooler_output: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor) — 模型最后一层的输出处的隐藏状态序列。
  • pooler_output (形状为 (batch_size, hidden_size) 的 torch.FloatTensor) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在通过用于辅助预训练任务的层进行进一步处理之后。例如，对于 BERT 系列模型，这会返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重通过预训练期间的下一句预测（分类）目标进行训练。
  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组 (对于嵌入的输出，如果模型有嵌入层，则为一个；对于每一层的输出，则为一个)。

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

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

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

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

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

  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — tuple(torch.FloatTensor) 的元组，长度为 config.n_layers，每个元组包含 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 输入）加速顺序解码。

模型输出的基类，也包含最后一层隐藏状态的池化。

BaseModelOutputWithPast

class transformers.modeling_outputs.BaseModelOutputWithPast

< >

( last_hidden_state: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

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

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

  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — tuple(torch.FloatTensor) 的元组，长度为 config.n_layers，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量，并且如果 config.is_encoder_decoder=True，则可选地包含 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的额外张量。

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

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

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

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

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

模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。

BaseModelOutputWithPastAndCrossAttentions

class transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions

< >

( last_hidden_state: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

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

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

  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — tuple(torch.FloatTensor) 的元组，长度为 config.n_layers，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量，并且如果 config.is_encoder_decoder=True，则可选地包含 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的额外张量。

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

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

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

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

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

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

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

模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。

Seq2SeqModelOutput

class transformers.modeling_outputs.Seq2SeqModelOutput

< >

( last_hidden_state: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

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

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

  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，其中每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的额外张量。

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

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

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

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

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

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

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

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 模型编码器最后一层的输出的隐藏状态序列。
  • 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 之后，用于计算自注意力头部的加权平均值。

模型编码器输出的基类，也包含：可加速顺序解码的预计算隐藏状态。

CausalLMOutput

class transformers.modeling_outputs.CausalLMOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 语言建模损失（用于预测下一个 token）。
  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。
  • 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 之后的注意力权重，用于计算自注意力头部的加权平均值。

因果语言模型（或自回归）输出的基类。

CausalLMOutputWithCrossAttentions

class transformers.modeling_outputs.CausalLMOutputWithCrossAttentions

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 语言建模损失（用于预测下一个 token）。
  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。
  • 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 之后的注意力权重，用于计算自注意力头部的加权平均值。

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

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

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

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

因果语言模型（或自回归）输出的基类。

CausalLMOutputWithPast

class transformers.modeling_outputs.CausalLMOutputWithPast

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 语言建模损失（用于预测下一个 token）。
  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 的元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量)

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

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

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

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

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

因果语言模型（或自回归）输出的基类。

MaskedLMOutput

class transformers.modeling_outputs.MaskedLMOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — Masked language modeling (MLM) 损失。
  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。
  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有 embedding 层，则为 embedding 的输出，加上每层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

用于 masked language model 输出的基类。

Seq2SeqLMOutput

class transformers.modeling_outputs.Seq2SeqLMOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 语言建模损失。
  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 的元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量) 和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的额外张量。

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

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

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

  • 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 (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 模型编码器最后一层的输出处的隐藏状态序列。
  • encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有 embedding 层，则为 embedding 的输出，加上每层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

用于 sequence-to-sequence language model 输出的基类。

NextSentencePredictorOutput

class transformers.modeling_outputs.NextSentencePredictorOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (torch.FloatTensor, 形状为 (1,), 可选, 当提供 next_sentence_label 时返回) — 下一句预测（分类）损失。
  • logits (torch.FloatTensor, 形状为 (batch_size, 2)) — 下一句预测（分类）头的预测分数（SoftMax 之前的 True/False 延续的分数）。
  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

用于预测两个句子是否连续的模型输出的基类。

SequenceClassifierOutput

class transformers.modeling_outputs.SequenceClassifierOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (torch.FloatTensor, 形状为 (1,), 可选, 当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。
  • logits (torch.FloatTensor, 形状为 (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）分数（SoftMax 之前）。
  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=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 之后的注意力权重，用于计算自注意力头中的加权平均值。

句子分类模型输出的基类。

Seq2SeqSequenceClassifierOutput

class transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (torch.FloatTensor, 形状为 (1,), 可选, 当提供 label 时返回) — 分类（或回归，如果 config.num_labels==1）损失。
  • logits (torch.FloatTensor, 形状为 (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）分数（SoftMax 之前）。
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor)) 元组，其中每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

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

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

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

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

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

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

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

  • encoder_last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层输出的隐藏状态序列。
  • encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型具有嵌入层，则为嵌入输出，加上每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

序列到序列句子分类模型输出的基类。

MultipleChoiceModelOutput

class transformers.modeling_outputs.MultipleChoiceModelOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (torch.FloatTensor, 形状为 (1,), 可选, 当提供 labels 时返回) — 分类损失。
  • logits (torch.FloatTensor, 形状为 (batch_size, num_choices)) — num_choices 是输入张量的第二个维度。（见上面的 input_ids）。

    分类分数（SoftMax 之前）。

  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 由形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 组成的元组（如果模型有嵌入层，则为嵌入输出；加上每个层的输出）。

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

  • attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 由形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 组成的元组（每一层一个）。

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

多项选择模型输出的基类。

TokenClassifierOutput

class transformers.modeling_outputs.TokenClassifierOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 分类损失。
  • logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类得分（SoftMax 之前）。
  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 由形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 组成的元组（如果模型有嵌入层，则为嵌入输出；加上每个层的输出）。

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

  • attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 由形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 组成的元组（每一层一个）。

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

token 分类模型输出的基类。

QuestionAnsweringModelOutput

class transformers.modeling_outputs.QuestionAnsweringModelOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None start_logits: FloatTensor = None end_logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 总跨度提取损失是起始位置和结束位置的交叉熵损失之和。
  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度起始得分（SoftMax 之前）。
  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度结束得分（SoftMax 之前）。
  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 由形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 组成的元组（如果模型有嵌入层，则为嵌入输出；加上每个层的输出）。

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

  • attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 由形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 组成的元组（每一层一个）。

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

问题回答模型输出的基类。

Seq2SeqQuestionAnsweringModelOutput

class transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None start_logits: FloatTensor = None end_logits: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 总跨度提取损失是起始位置和结束位置的交叉熵损失之和。
  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度起始得分（SoftMax 之前）。
  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度结束得分（SoftMax 之前）。
  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

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

  • decoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 由形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 组成的元组（如果模型有嵌入层，则为嵌入输出；加上每个层的输出）。

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

  • decoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 由形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 组成的元组（每一层一个）。

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

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

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

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 模型编码器最后一层的输出的隐藏状态序列。
  • 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 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组 (每个层一个)。

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

序列到序列问答模型输出的基类。

Seq2SeqSpectrogramOutput

class transformers.modeling_outputs.Seq2SeqSpectrogramOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None spectrogram: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 频谱图生成损失。
  • spectrogram (形状为 (batch_size, sequence_length, num_bins) 的 torch.FloatTensor) — 预测的频谱图。
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，其中每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量，以及 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

    包含预计算的隐藏状态 (自注意力块和交叉注意力块中的键和值)，可以用于 (参见 past_key_values 输入) 加速顺序解码。

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

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

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

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

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

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

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 模型编码器最后一层的输出的隐藏状态序列。
  • 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 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组 (每个层一个)。

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

序列到序列频谱图输出的基类。

SemanticSegmenterOutput

class transformers.modeling_outputs.SemanticSegmenterOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 分类损失 (或回归损失，如果 config.num_labels==1)。
  • logits (形状为 (batch_size, config.num_labels, logits_height, logits_width) 的 torch.FloatTensor) — 每个像素的分类得分。

    返回的 logits 不一定与作为输入传递的 pixel_values 具有相同的大小。这是为了避免进行两次插值，并在用户需要将 logits 调整为原始图像大小作为后处理时损失一些质量。您应该始终检查您的 logits 形状并在需要时调整大小。
  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组 (如果模型有嵌入层，则为嵌入输出；+ 每层输出一个)，形状为 (batch_size, patch_size, hidden_size)。

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

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

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

语义分割模型输出的基类。

ImageClassifierOutput

class transformers.modeling_outputs.ImageClassifierOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor, 可选, 当提供 labels 时返回) — 分类损失 (或回归损失，如果 config.num_labels==1)。
  • logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类得分 (或回归得分，如果 config.num_labels==1) (在 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, patch_size, sequence_length)。

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

图像分类模型输出的基本类。

ImageClassifierOutputWithNoAttention

类 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor，*可选*，当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。
  • logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（或回归，如果 config.num_labels==1）得分（SoftMax 之前）。
  • hidden_states (tuple(torch.FloatTensor)，*可选*，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有嵌入层，则为嵌入输出提供一个，加上每个阶段的输出提供一个），形状为 (batch_size, num_channels, height, width)。模型在每个阶段输出的隐藏状态（也称为特征图）。

图像分类模型输出的基本类。

DepthEstimatorOutput

类 transformers.modeling_outputs.DepthEstimatorOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None predicted_depth: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor，*可选*，当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。
  • predicted_depth (形状为 (batch_size, height, width) 的 torch.FloatTensor) — 每个像素的预测深度。
  • hidden_states (tuple(torch.FloatTensor)，*可选*，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有嵌入层，则为嵌入输出提供一个，加上每个层的输出提供一个），形状为 (batch_size, num_channels, height, width)。

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

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

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

深度估计模型输出的基本类。

Wav2Vec2BaseModelOutput

类 transformers.modeling_outputs.Wav2Vec2BaseModelOutput

< >

( last_hidden_state: FloatTensor = None extract_features: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor) — 模型最后一层输出的隐藏状态序列。
  • extract_features (形状为 (batch_size, sequence_length, conv_dim[-1]) 的 torch.FloatTensor) — 模型最后一个卷积层的提取特征向量序列。
  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

已使用 Wav2Vec2 损失目标训练的模型的基本类。

XVectorOutput

类 transformers.modeling_outputs.XVectorOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None embeddings: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )

参数

  • loss (形状为 (1,) 的 torch.FloatTensor，*可选*，当提供 labels 时返回) — 分类损失。
  • logits (形状为 (batch_size, config.xvector_output_dim) 的 torch.FloatTensor) — AMSoftmax 之前的分类隐藏状态。
  • embeddings (形状为 (batch_size, config.xvector_output_dim) 的 torch.FloatTensor) — 用于基于向量相似度检索的语句嵌入。
  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

Wav2Vec2ForXVector 的输出类型。

Seq2SeqTSModelOutput

class transformers.modeling_outputs.Seq2SeqTSModelOutput

< >

( last_hidden_state: FloatTensor = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None loc: typing.Optional[torch.FloatTensor] = None scale: typing.Optional[torch.FloatTensor] = None static_features: typing.Optional[torch.FloatTensor] = None )

参数

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

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

  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor)) 元组，其中每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

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

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

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

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

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

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

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

  • encoder_last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出的隐藏状态序列。
  • encoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有嵌入层，则为嵌入输出的元组，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

  • loc (torch.FloatTensor, 形状为 (batch_size,) 或 (batch_size, input_size), 可选) — 每个时间序列上下文窗口的平移值，用于使模型输入具有相同的大小，然后用于平移回原始大小。
  • scale (torch.FloatTensor, 形状为 (batch_size,) 或 (batch_size, input_size), 可选) — 每个时间序列上下文窗口的缩放值，用于使模型输入具有相同的大小，然后用于重新缩放回原始大小。
  • static_features (torch.FloatTensor, 形状为 (batch_size, feature size), 可选) — 批次中每个时间序列的静态特征，在推理时复制到协变量。

用于时间序列模型编码器输出的基类，该基类还包含可以加速顺序解码的预计算隐藏状态。

Seq2SeqTSPredictionOutput

class transformers.modeling_outputs.Seq2SeqTSPredictionOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None params: typing.Optional[typing.Tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None loc: typing.Optional[torch.FloatTensor] = None scale: typing.Optional[torch.FloatTensor] = None static_features: typing.Optional[torch.FloatTensor] = None )

参数

  • loss (torch.FloatTensor, 形状为 (1,), 可选, 当提供 future_values 时返回) — 分布损失。
  • params (torch.FloatTensor, 形状为 (batch_size, num_samples, num_params)) — 所选分布的参数。
  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor)) 元组，其中每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

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

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

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

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

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

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

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

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 模型编码器最后一层的输出的隐藏状态序列。
  • encoder_hidden_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 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组 (每层一个)。

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

  • loc (形状为 (batch_size,) 或 (batch_size, input_size) 的 torch.FloatTensor, 可选) — 每个时间序列上下文窗口的平移值，用于使模型输入具有相同的大小，然后用于平移回原始大小。
  • scale (形状为 (batch_size,) 或 (batch_size, input_size) 的 torch.FloatTensor, 可选) — 每个时间序列上下文窗口的缩放值，用于使模型输入具有相同的大小，然后用于重新缩放回原始大小。
  • static_features (形状为 (batch_size, feature size) 的 torch.FloatTensor, 可选) — 批次中每个时间序列的静态特征，在推理时复制到协变量。

时间序列模型解码器输出的基类，也包含损失以及所选分布的参数。

SampleTSPredictionOutput

class transformers.modeling_outputs.SampleTSPredictionOutput

< >

( sequences: FloatTensor = None )

参数

  • sequences (形状为 (batch_size, num_samples, prediction_length) 或 (batch_size, num_samples, prediction_length, input_size) 的 torch.FloatTensor) — 从所选分布中采样的值。

时间序列模型预测输出的基类，包含从所选分布中采样的值。

TFBaseModelOutput

class transformers.modeling_tf_outputs.TFBaseModelOutput

< >

( last_hidden_state: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor) — 模型最后一层的输出的隐藏状态序列。
  • hidden_states (tuple(tf.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — tf.Tensor 元组 (一个用于嵌入输出，另一个用于每层的输出)，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

模型输出的基类，具有潜在的隐藏状态和注意力。

TFBaseModelOutputWithPooling

class transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling

< >

( last_hidden_state: tf.Tensor = None pooler_output: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor) — 模型最后一层的输出的隐藏状态序列。
  • pooler_output (形状为 (batch_size, hidden_size) 的 tf.Tensor) — 序列的第一个 token (分类 token) 的最后一层隐藏状态，通过线性层和 Tanh 激活函数进一步处理。线性层权重通过预训练期间的下一句预测 (分类) 目标进行训练。

    此输出通常不是输入语义内容的良好摘要，您通常最好对整个输入序列的隐藏状态序列进行平均或池化。

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

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

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

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

模型输出的基类，也包含最后一层隐藏状态的池化。

TFBaseModelOutputWithPoolingAndCrossAttentions

class transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions

< >

( last_hidden_state: tf.Tensor = None pooler_output: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None )

参数

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor) — 模型最后一层的输出的隐藏状态序列。
  • pooler_output (形状为 (batch_size, hidden_size) 的 tf.Tensor) — 序列的第一个 token (分类 token) 的最后一层隐藏状态，通过线性层和 Tanh 激活函数进一步处理。线性层权重通过预训练期间的下一句预测 (分类) 目标进行训练。

    此输出通常不是输入语义内容的良好摘要，您通常最好对整个输入序列的隐藏状态序列进行平均或池化。

  • 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 输入) 加速顺序解码。

  • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — ``tf.Tensor`` 的元组（一个用于嵌入输出，另一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — ``tf.Tensor`` 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

  • cross_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — ``tf.Tensor`` 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

模型输出的基类，也包含最后一层隐藏状态的池化。

TFBaseModelOutputWithPast

class transformers.modeling_tf_outputs.TFBaseModelOutputWithPast

< >

( last_hidden_state: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • 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], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的 tf.Tensor 列表，其中每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

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

  • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — ``tf.Tensor`` 的元组（一个用于嵌入输出，另一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — ``tf.Tensor`` 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。

TFBaseModelOutputWithPastAndCrossAttentions

class transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions

< >

( last_hidden_state: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None )

参数

  • 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], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的 tf.Tensor 列表，其中每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

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

  • hidden_states (tuple(tf.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — ``tf.Tensor`` 的元组（一个用于嵌入输出，另一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — ``tf.Tensor`` 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

  • cross_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — ``tf.Tensor`` 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。

TFSeq2SeqModelOutput

class transformers.modeling_tf_outputs.TFSeq2SeqModelOutput

< >

( last_hidden_state: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None )

参数

  • 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], optional, returned when use_cache=True is passed or when 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), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — ``tf.Tensor`` 的元组（一个用于嵌入输出，另一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • decoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — ``tf.Tensor`` 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

  • cross_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when 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), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（每个层的输出以及初始嵌入输出各一个）。

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

  • encoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

模型编码器输出的基类，也包含：可加速顺序解码的预计算隐藏状态。

TFCausalLMOutput

class transformers.modeling_tf_outputs.TFCausalLMOutput

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (形状为 (n,) 的 tf.Tensor，可选，当提供了 labels 时返回，其中 n 是非掩码标签的数量) — 语言建模损失（用于预测下一个词元）。
  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 tf.Tensor) — 语言建模头的预测得分（SoftMax 之前的每个词汇表词元的得分）。
  • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（每个层的输出以及初始嵌入输出各一个）。

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

  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

因果语言模型（或自回归）输出的基类。

TFCausalLMOutputWithCrossAttentions

class transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (形状为 (n,) 的 tf.Tensor，可选，当提供了 labels 时返回，其中 n 是非掩码标签的数量) — 语言建模损失（用于预测下一个词元）。
  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 tf.Tensor) — 语言建模头的预测得分（SoftMax 之前的每个词汇表词元的得分）。
  • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（每个层的输出以及初始嵌入输出各一个）。

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

  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

  • cross_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

  • past_key_values (List[tf.Tensor], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的 tf.Tensor 列表，其中每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)）。

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

因果语言模型（或自回归）输出的基类。

TFCausalLMOutputWithPast

class transformers.modeling_tf_outputs.TFCausalLMOutputWithPast

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (形状为 (n,) 的 tf.Tensor，可选，当提供了 labels 时返回，其中 n 是非掩码标签的数量) — 语言建模损失（用于预测下一个词元）。
  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 tf.Tensor) — 语言建模头的预测得分（SoftMax 之前的每个词汇表词元的得分）。
  • past_key_values (List[tf.Tensor], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的 tf.Tensor 列表，其中每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)）。

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

  • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（每个层的输出以及初始嵌入输出各一个）。

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

  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

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

因果语言模型（或自回归）输出的基类。

TFMaskedLMOutput

class transformers.modeling_tf_outputs.TFMaskedLMOutput

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (形状为 (n,) 的 tf.Tensor，可选，当提供了 labels 时返回，其中 n 是非掩码标签的数量) — 掩码语言建模 (MLM) 损失。
  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测得分（每个词汇表标记在 SoftMax 之前的得分）。
  • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — tf.Tensor 的元组（每个层的输出一个，加上嵌入层的初始输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

用于 masked language model 输出的基类。

TFSeq2SeqLMOutput

class transformers.modeling_tf_outputs.TFSeq2SeqLMOutput

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (tf.Tensor of shape (n,), optional, where n is the number of non-masked labels, returned when labels is provided) — 语言建模损失。（可选，当提供 labels 时返回，其中 n 是非掩码标签的数量）
  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测得分（每个词汇表标记在 SoftMax 之前的得分）。
  • past_key_values (List[tf.Tensor], optional, returned when use_cache=True is passed or when config.use_cache=True) — tf.Tensor 的列表，长度为 config.n_layers，每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)）。

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

  • decoder_hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — tf.Tensor 的元组（每个层的输出一个，加上嵌入层的初始输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • decoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

  • cross_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

  • encoder_last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的输出隐藏状态序列。（可选）
  • encoder_hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — tf.Tensor 的元组（每个层的输出一个，加上嵌入层的初始输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • encoder_attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

用于 sequence-to-sequence language model 输出的基类。

TFNextSentencePredictorOutput

class transformers.modeling_tf_outputs.TFNextSentencePredictorOutput

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (tf.Tensor of shape (n,), optional, where n is the number of non-masked labels, returned when next_sentence_label is provided) — 下一句预测损失。（可选，当提供 next_sentence_label 时返回，其中 n 是非掩码标签的数量）
  • logits (tf.Tensor of shape (batch_size, 2)) — 下一句预测（分类）头的预测得分（SoftMax 之前 True/False 延续的得分）。
  • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — tf.Tensor 的元组（每个层输出一个，加上初始嵌入输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

用于预测两个句子是否连续的模型输出的基类。

TFSequenceClassifierOutput

class transformers.modeling_tf_outputs.TFSequenceClassifierOutput

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (tf.Tensor of shape (batch_size, ), optional, returned when labels is provided) — 分类损失（如果 config.num_labels==1，则为回归损失）。（可选，当提供 labels 时返回）
  • logits (tf.Tensor of shape (batch_size, config.num_labels)) — 分类（或如果 config.num_labels==1，则为回归）得分（SoftMax 之前）。
  • hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — tf.Tensor 的元组（每层输出一个，加上初始嵌入输出），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

句子分类模型输出的基类。

TFSeq2SeqSequenceClassifierOutput

class transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None cross_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (形状为 (1,) 的 tf.Tensor，可选, 当提供 label 时返回) — 分类 (或回归，如果 config.num_labels==1) 损失。
  • logits (形状为 (batch_size, config.num_labels) 的 tf.Tensor) — 分类 (或回归，如果 config.num_labels==1) 分数 (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 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组 (每个嵌入输出一个，每层输出一个)。

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

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

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

  • cross_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组 (每层一个)
  • 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 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组 (每个嵌入输出一个，每层输出一个)。

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

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

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

序列到序列句子分类模型输出的基类。

TFMultipleChoiceModelOutput

class transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (形状为 (batch_size, ) 的 tf.Tensor，可选, 当提供 labels 时返回) — 分类损失。
  • logits (形状为 (batch_size, num_choices) 的 tf.Tensor) — num_choices 是输入张量的第二个维度。(参见上面的 input_ids)。

    分类得分（SoftMax 之前）。

  • hidden_states (tuple(tf.Tensor), 可选, 当传递 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 后的注意力权重，用于计算自注意力头中的加权平均值。

多项选择模型输出的基类。

TFTokenClassifierOutput

class transformers.modeling_tf_outputs.TFTokenClassifierOutput

< >

( loss: tf.Tensor | None = None logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (形状为 (n,) 的 tf.Tensor，可选, 其中 n 是未掩码标签的数量，当提供 labels 时返回) — 分类损失。
  • logits (形状为 (batch_size, sequence_length, config.num_labels) 的 tf.Tensor) — 分类得分（SoftMax 之前）。
  • hidden_states (tuple(tf.Tensor), 可选, 当传递 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 后的注意力权重，用于计算自注意力头中的加权平均值。

token 分类模型输出的基类。

TFQuestionAnsweringModelOutput

class transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput

< >

( loss: tf.Tensor | None = None start_logits: tf.Tensor = None end_logits: tf.Tensor = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (tf.Tensor, 形状为 (batch_size, ), 可选, 当提供 start_positions 和 end_positions 时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。
  • start_logits (tf.Tensor, 形状为 (batch_size, sequence_length)) — 跨度起始位置分数 (SoftMax 前)。
  • end_logits (tf.Tensor, 形状为 (batch_size, sequence_length)) — 跨度结束位置分数 (SoftMax 前)。
  • hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 由 tf.Tensor 组成的元组（每层输出一个，加上初始 embedding 输出），每个 tf.Tensor 的形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

问题回答模型输出的基类。

TFSeq2SeqQuestionAnsweringModelOutput

class transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput

< >

( loss: tf.Tensor | None = None start_logits: tf.Tensor = None end_logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None decoder_hidden_states: Tuple[tf.Tensor] | None = None decoder_attentions: Tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: Tuple[tf.Tensor] | None = None encoder_attentions: Tuple[tf.Tensor] | None = None )

参数

  • loss (tf.Tensor, 形状为 (1,), 可选, 当提供 labels 时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。
  • start_logits (tf.Tensor, 形状为 (batch_size, sequence_length)) — 跨度起始位置分数（SoftMax 前）。
  • end_logits (tf.Tensor, 形状为 (batch_size, sequence_length)) — 跨度结束位置分数（SoftMax 前）。
  • past_key_values (List[tf.Tensor], 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — tf.Tensor 列表，长度为 config.n_layers，每个张量的形状为 (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 组成的元组（每层输出一个，加上初始 embedding 输出），每个 tf.Tensor 的形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

  • encoder_last_hidden_state (tf.Tensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出端的隐藏状态序列。
  • encoder_hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 由 tf.Tensor 组成的元组（每层输出一个，加上初始 embedding 输出），每个 tf.Tensor 的形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

序列到序列问答模型输出的基类。

FlaxBaseModelOutput

class transformers.modeling_flax_outputs.FlaxBaseModelOutput

< >

( last_hidden_state: Array = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • 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 时返回) — 由 jnp.ndarray 组成的元组（每层输出一个，加上初始 embedding 输出），每个 jnp.ndarray 的形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

模型输出的基类，具有潜在的隐藏状态和注意力。

replace

 < >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxBaseModelOutputWithPast

类 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast

< >

( last_hidden_state: Array = None past_key_values: typing.Optional[typing.Dict[str, jax.Array]] = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • last_hidden_state (jnp.ndarray，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出的隐藏状态序列。
  • past_key_values (Dict[str, jnp.ndarray]) — 预先计算好的隐藏状态字典（注意力模块中的键和值），可用于快速自回归解码。 预先计算好的键和值隐藏状态的形状为 [batch_size, max_length]。
  • hidden_states (tuple(jnp.ndarray), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组 (每个嵌入输出 + 每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

模型输出的基类，具有潜在的隐藏状态和注意力。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxBaseModelOutputWithPooling

类 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling

< >

( last_hidden_state: Array = None pooler_output: Array = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • last_hidden_state (jnp.ndarray，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出的隐藏状态序列。
  • pooler_output (jnp.ndarray，形状为 (batch_size, hidden_size)) — 序列的第一个 token (分类 token) 的最后一层隐藏状态，通过线性层和 Tanh 激活函数进一步处理。线性层权重通过预训练期间的下一句预测（分类）目标进行训练。
  • hidden_states (tuple(jnp.ndarray), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组 (每个嵌入输出 + 每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

模型输出的基类，也包含最后一层隐藏状态的池化。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxBaseModelOutputWithPastAndCrossAttentions

类 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions

< >

( last_hidden_state: Array = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[jax.Array]]] = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None cross_attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

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

    如果使用了 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 时返回) — jnp.ndarray 的元组 (每个嵌入输出 + 每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

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

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

模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxSeq2SeqModelOutput

类 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput

< >

( last_hidden_state: Array = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None decoder_attentions: typing.Optional[typing.Tuple[jax.Array]] = None cross_attentions: typing.Optional[typing.Tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None encoder_attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

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

    如果使用了 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(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 时返回) — jnp.ndarray 元组（每个层的输出，包括嵌入层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

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

    解码器交叉注意力层的注意力权重，在注意力 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 时返回) — jnp.ndarray 元组（每个层的输出，包括嵌入层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

模型编码器输出的基类，也包含：可加速顺序解码的预计算隐藏状态。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxCausalLMOutputWithCrossAttentions

class transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions

< >

( logits: Array = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[jax.Array]]] = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None cross_attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 语言模型头的预测得分（每个词汇表标记在 SoftMax 之前的得分）。
  • hidden_states (tuple(jnp.ndarray), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 元组（每个层的输出，包括嵌入层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出端的隐藏状态，包括初始嵌入输出。

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

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

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

    交叉注意力权重，在注意力 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 输入）加速序列解码。

因果语言模型（或自回归）输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxMaskedLMOutput

class transformers.modeling_flax_outputs.FlaxMaskedLMOutput

< >

( logits: Array = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 语言模型头的预测得分（每个词汇表标记在 SoftMax 之前的得分）。
  • hidden_states (tuple(jnp.ndarray), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 元组（每个层的输出，包括嵌入层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出端的隐藏状态，包括初始嵌入输出。

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

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

用于 masked language model 输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxSeq2SeqLMOutput

class transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput

< >

( logits: Array = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None decoder_attentions: typing.Optional[typing.Tuple[jax.Array]] = None cross_attentions: typing.Optional[typing.Tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None encoder_attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 语言模型头的预测得分（每个词汇表标记在 SoftMax 之前的得分）。
  • past_key_values (tuple(tuple(jnp.ndarray)), 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(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 时返回) — jnp.ndarray 的元组 (每个层的输出以及初始 embedding 输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

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

    解码器的交叉注意力层的注意力权重，在 attention 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 时返回) — jnp.ndarray 的元组 (每个层的输出以及初始 embedding 输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

用于 sequence-to-sequence language model 输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxNextSentencePredictorOutput

class transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput

< >

( logits: Array = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • logits (jnp.ndarray，形状为 (batch_size, 2)) — 下一句预测（分类）头的预测分数（SoftMax 之前的 True/False 延续的分数）。
  • hidden_states (tuple(jnp.ndarray), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组 (每个层的输出以及初始 embedding 输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

用于预测两个句子是否连续的模型输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxSequenceClassifierOutput

class transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput

< >

( logits: Array = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • logits (jnp.ndarray，形状为 (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）分数（SoftMax 之前）。
  • hidden_states (tuple(jnp.ndarray), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组 (每个层的输出以及初始 embedding 输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

句子分类模型输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxSeq2SeqSequenceClassifierOutput

class transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput

< >

( logits: Array = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None decoder_attentions: typing.Optional[typing.Tuple[jax.Array]] = None cross_attentions: typing.Optional[typing.Tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None encoder_attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • logits (jnp.ndarray，形状为 (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）分数（SoftMax 之前）。
  • past_key_values (tuple(tuple(jnp.ndarray)), 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(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 时返回) — jnp.ndarray 的元组 (每个层的输出以及初始 embedding 输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

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

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

  • encoder_last_hidden_state (jnp.ndarray，形状为 (batch_size, sequence_length, hidden_size), 可选) — 模型编码器的最后一层的输出端的隐藏状态序列。
  • encoder_hidden_states (tuple(jnp.ndarray), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — jnp.ndarray 元组 (每个层的输出以及初始嵌入输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

  • encoder_attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — jnp.ndarray 元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

序列到序列句子分类模型输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxMultipleChoiceModelOutput

class transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput

< >

( logits: Array = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • logits (jnp.ndarray of shape (batch_size, num_choices)) — num_choices 是输入张量的第二个维度。(参见上面的 input_ids)。

    分类得分 (SoftMax 之前)。

  • hidden_states (tuple(jnp.ndarray), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — jnp.ndarray 元组 (每个层的输出以及初始嵌入输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — jnp.ndarray 元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

多项选择模型输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxTokenClassifierOutput

class transformers.modeling_flax_outputs.FlaxTokenClassifierOutput

< >

( logits: Array = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • logits (jnp.ndarray of shape (batch_size, sequence_length, config.num_labels)) — 分类得分 (SoftMax 之前)。
  • hidden_states (tuple(jnp.ndarray), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — jnp.ndarray 元组 (每个层的输出以及初始嵌入输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — jnp.ndarray 元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

token 分类模型输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxQuestionAnsweringModelOutput

class transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput

< >

( start_logits: Array = None end_logits: Array = None hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • start_logits (jnp.ndarray of shape (batch_size, sequence_length)) — 起始跨度得分 (SoftMax 之前)。
  • end_logits (jnp.ndarray of shape (batch_size, sequence_length)) — 结束跨度得分 (SoftMax 之前)。
  • hidden_states (tuple(jnp.ndarray), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — jnp.ndarray 元组 (每个层的输出以及初始嵌入输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — jnp.ndarray 元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

问题回答模型输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

FlaxSeq2SeqQuestionAnsweringModelOutput

class transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput

< >

( start_logits: Array = None end_logits: Array = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None decoder_attentions: typing.Optional[typing.Tuple[jax.Array]] = None cross_attentions: typing.Optional[typing.Tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[typing.Tuple[jax.Array]] = None encoder_attentions: typing.Optional[typing.Tuple[jax.Array]] = None )

参数

  • start_logits (jnp.ndarray of shape (batch_size, sequence_length)) — 起始跨度得分 (SoftMax 之前)。
  • end_logits (jnp.ndarray of shape (batch_size, sequence_length)) — 结束跨度得分 (SoftMax 之前)。
  • past_key_values (tuple(tuple(jnp.ndarray)), optional, returned when use_cache=True is passed or when config.use_cache=True) — tuple(tuple(jnp.ndarray)) 元组，长度为 config.n_layers，其中每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

    包含预先计算的隐藏状态 (自注意力模块和交叉注意力模块中的键和值)，可以用于 (参见 past_key_values 输入) 加速顺序解码。

  • decoder_hidden_states (tuple(jnp.ndarray), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — jnp.ndarray 元组 (每个层的输出以及初始嵌入输出各一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

  • decoder_attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — jnp.ndarray 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

  • cross_attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — jnp.ndarray 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

  • encoder_last_hidden_state (jnp.ndarray，形状为 (batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。
  • encoder_hidden_states (tuple(jnp.ndarray), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — jnp.ndarray 的元组 (一个用于嵌入输出 + 每个层的输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

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

  • encoder_attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — jnp.ndarray 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

序列到序列问答模型输出的基类。

replace

< >

( **updates )

“返回一个新对象，用新值替换指定的字段。

< > Update on GitHub

←Optimization PEFT→