Transformers 文档
模型输出
并获得增强的文档体验
开始使用
模型输出
所有模型输出都是 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
所有模型输出的基类，作为数据类。具有一个 __getitem__ 方法，允许通过整数或切片（像元组一样）或字符串（像字典一样）进行索引，这将忽略 None 属性。否则，其行为类似于常规 Python 字典。
您不能直接解包 ModelOutput。请使用 to_tuple() 方法将其转换为元组。
将自身转换为包含所有非 None 属性/键的元组。
BaseModelOutput
class transformers.modeling_outputs.BaseModelOutput
< 来源 >( last_hidden_state: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层输出的隐藏状态序列。 - 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 后的注意力权重，用于计算自注意力头中的加权平均。
模型输出的基类，可能包含隐藏状态和注意力。
BaseModelOutputWithPooling
class transformers.modeling_outputs.BaseModelOutputWithPooling
< 来源 >( last_hidden_state: typing.Optional[torch.FloatTensor] = None pooler_output: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[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 后的注意力权重，用于计算自注意力头中的加权平均。
模型输出的基类，也包含最后隐藏状态的池化。
BaseModelOutputWithCrossAttentions
class transformers.modeling_outputs.BaseModelOutputWithCrossAttentions
< 来源 >( last_hidden_state: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层输出的隐藏状态序列。 - 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 后的注意力权重，用于计算交叉注意力头中的加权平均。
模型输出的基类，可能包含隐藏状态和注意力。
BaseModelOutputWithPoolingAndCrossAttentions
class transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions
< 来源 >( last_hidden_state: typing.Optional[torch.FloatTensor] = None pooler_output: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[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 (
Cache, 可选，当传递use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多详情请参阅我们的 KV 缓存指南。包含预先计算的隐藏状态（自注意力块中的键和值，如果
config.is_encoder_decoder=True，则可选地包含交叉注意力块中的键和值），可用于（参见past_key_values输入）加速顺序解码。
模型输出的基类，也包含最后隐藏状态的池化。
BaseModelOutputWithPast
class transformers.modeling_outputs.BaseModelOutputWithPast
< 来源 >( last_hidden_state: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[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 (
Cache, 可选，当传递use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多详情请参阅我们的 KV 缓存指南。包含预先计算的隐藏状态（自注意力块中的键和值，如果
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: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[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 (
Cache, 可选，当传递use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多详情请参阅我们的 KV 缓存指南。包含预先计算的隐藏状态（自注意力块中的键和值，如果
config.is_encoder_decoder=True，则可选地包含交叉注意力块中的键和值），可用于（参见past_key_values输入）加速顺序解码。 - 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.add_cross_attention=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 后的注意力权重，用于计算交叉注意力头中的加权平均。
模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。
Seq2SeqModelOutput
class transformers.modeling_outputs.Seq2SeqModelOutput
< 源文件 >( last_hidden_state: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[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 (
EncoderDecoderCache, 可选, 当传入use_cache=True或config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。更多详情请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参阅
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 后的注意力权重，用于计算自注意力头中的加权平均。
模型编码器输出的基类，也包含：可加速顺序解码的预计算隐藏状态。
CausalLMOutput
class transformers.modeling_outputs.CausalLMOutput
< 源文件 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), 可选, 当提供labels时返回) — 语言模型损失（用于下一词预测）。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 - hidden_states (
tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —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: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), 可选, 当提供labels时返回) — 语言模型损失（用于下一词预测）。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 - hidden_states (
tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —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 (
Cache, 可选, 当传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多详情请参阅我们的 kv cache 指南。包含预计算的隐藏状态（注意力块中的键和值），可用于（参阅
past_key_values输入）加速顺序解码。
因果语言模型（或自回归模型）输出的基类。
CausalLMOutputWithPast
class transformers.modeling_outputs.CausalLMOutputWithPast
< 源文件 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), 可选, 当提供labels时返回) — 语言模型损失（用于下一词预测）。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 - past_key_values (
Cache, 可选, 当传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多详情请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块中的键和值），可用于（参阅
past_key_values输入）加速顺序解码。 - 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 后的注意力权重，用于计算自注意力头中的加权平均。
因果语言模型（或自回归模型）输出的基类。
MaskedLMOutput
class transformers.modeling_outputs.MaskedLMOutput
< 源文件 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), 可选, 当提供labels时返回) — 掩码语言模型 (MLM) 损失。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 - hidden_states (
tuple(torch.FloatTensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —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 后的注意力权重，用于计算自注意力头中的加权平均。
掩码语言模型输出的基类。
Seq2SeqLMOutput
class transformers.modeling_outputs.Seq2SeqLMOutput
< 源文件 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), 可选, 当提供labels时返回) — 语言模型损失。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 - past_key_values (
EncoderDecoderCache, 可选, 当传入use_cache=True或config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。更多详情请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参阅
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 后的注意力权重，用于计算自注意力头中的加权平均。
序列到序列语言模型输出的基类。
NextSentencePredictorOutput
class transformers.modeling_outputs.NextSentencePredictorOutput
< 源文件 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), 可选, 当提供next_sentence_label时返回) — 下一序列预测（分类）损失。 - logits (
torch.FloatTensor，形状为(batch_size, 2)) — 下一个序列预测（分类）头的预测分数（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之后的注意力权重，用于计算自注意力头中的加权平均值。
预测两个句子是否连续的模型输出的基类。
SequenceClassifierOutput
class transformers.modeling_outputs.SequenceClassifierOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[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
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[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 (
EncoderDecoderCache, 可选，当传入use_cache=True或config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层（如果模型有嵌入层）的输出，加上每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。解码器在每个层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(torch.FloatTensor), 可选，当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力softmax之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(torch.FloatTensor), 可选，当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力softmax之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层（如果模型有嵌入层）的输出，加上每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。编码器在每个层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(torch.FloatTensor), 可选，当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力softmax之后，用于计算自注意力头中的加权平均值。
序列到序列句子分类模型输出的基类。
MultipleChoiceModelOutput
class transformers.modeling_outputs.MultipleChoiceModelOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[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), 可选，当传入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之后的注意力权重，用于计算自注意力头中的加权平均值。
多项选择模型输出的基类。
TokenClassifierOutput
class transformers.modeling_outputs.TokenClassifierOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类损失。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax之前）。 - hidden_states (
tuple(torch.FloatTensor), 可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层（如果模型有嵌入层）的输出，加上每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), 可选，当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。在注意力softmax之后的注意力权重，用于计算自注意力头中的加权平均值。
Token分类模型输出的基类。
QuestionAnsweringModelOutput
class transformers.modeling_outputs.QuestionAnsweringModelOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None start_logits: typing.Optional[torch.FloatTensor] = None end_logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。 - start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度起始分数（SoftMax之前）。 - end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度结束分数（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之后的注意力权重，用于计算自注意力头中的加权平均值。
问答模型输出的基类。
Seq2SeqQuestionAnsweringModelOutput
class transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None start_logits: typing.Optional[torch.FloatTensor] = None end_logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。 - start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度起始分数（SoftMax之前）。 - end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度结束分数（SoftMax之前）。 - past_key_values (
EncoderDecoderCache, 可选，当传入use_cache=True或config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层（如果模型有嵌入层）的输出，加上每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。解码器在每个层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(torch.FloatTensor), 可选，当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力softmax之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(torch.FloatTensor), 可选，当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力softmax之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层（如果模型有嵌入层）的输出，加上每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。编码器在每个层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(torch.FloatTensor), 可选，当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力softmax之后，用于计算自注意力头中的加权平均值。
序列到序列问答模型输出的基类。
Seq2SeqSpectrogramOutput
class transformers.modeling_outputs.Seq2SeqSpectrogramOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None spectrogram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 频谱图生成损失。 - spectrogram (
torch.FloatTensor，形状为(batch_size, sequence_length, num_bins)) — 预测的频谱图。 - past_key_values (
EncoderDecoderCache，可选，当传递use_cache=True或config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则为嵌入层输出，加上每层输出）形状为(batch_size, sequence_length, hidden_size)。解码器在每层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层在注意力 softmax 之后的注意力权重，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则为嵌入层输出，加上每层输出）形状为(batch_size, sequence_length, hidden_size)。编码器在每层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
序列到序列频谱图输出的基类。
SemanticSegmenterOutput
class transformers.modeling_outputs.SemanticSegmenterOutput
< 源 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。 - logits (
torch.FloatTensor，形状为(batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。返回的 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时返回) —torch.FloatTensor的元组（每层一个）形状为(batch_size, num_heads, patch_size, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
语义分割模型的输出基类。
ImageClassifierOutput
class transformers.modeling_outputs.ImageClassifierOutput
< 源 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[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, patch_size, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
图像分类模型的输出基类。
ImageClassifierOutputWithNoAttention
class transformers.modeling_outputs.ImageClassifierOutputWithNoAttention
< 源 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[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, num_channels, height, width)。模型在每个阶段输出处的隐藏状态（也称为特征图）。
图像分类模型的输出基类。
DepthEstimatorOutput
class transformers.modeling_outputs.DepthEstimatorOutput
< 源 >( loss: typing.Optional[torch.FloatTensor] = None predicted_depth: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。 - predicted_depth (
torch.FloatTensor，形状为(batch_size, height, width)) — 每个像素的预测深度。 - 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
class transformers.modeling_outputs.Wav2Vec2BaseModelOutput
< 源 >( last_hidden_state: typing.Optional[torch.FloatTensor] = None extract_features: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - extract_features (
torch.FloatTensor，形状为(batch_size, sequence_length, conv_dim[-1])) — 模型最后一层卷积层提取的特征向量序列。 - 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
class transformers.modeling_outputs.XVectorOutput
< 源 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None embeddings: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类损失。 - logits (
torch.FloatTensor，形状为(batch_size, config.xvector_output_dim)) — AMSoftmax 之前的分类隐藏状态。 - embeddings (
torch.FloatTensor，形状为(batch_size, config.xvector_output_dim)) — 用于基于向量相似性检索的语音嵌入。 - 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: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[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 (
EncoderDecoderCache，可选，当传递use_cache=True或config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则为嵌入层输出，加上每层输出）形状为(batch_size, sequence_length, hidden_size)。解码器在每层输出处的隐藏状态，以及可选的初始嵌入输出。
- decoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个）形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则为一个用于嵌入层输出，加上一个用于每一层输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，加上可选的初始嵌入输出。
- encoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
- 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
< source >( loss: typing.Optional[torch.FloatTensor] = None params: typing.Optional[tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[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 (
EncoderDecoderCache，可选，当传递use_cache=True或config.use_cache=True时返回) — 这是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv cache 指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参阅
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)，可选) — 批次中每个时间序列的静态特征，在推理时复制到协变量。
时间序列模型解码器输出的基类，也包含损失以及所选分布的参数。
SampleTSPredictionOutput
class transformers.modeling_outputs.SampleTSPredictionOutput
< source >( sequences: typing.Optional[torch.FloatTensor] = None )
时间序列模型预测输出的基类，包含从所选分布中采样的值。
TFBaseModelOutput
class transformers.modeling_tf_outputs.TFBaseModelOutput
< source >( last_hidden_state: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )
参数
- last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。 - 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
< source >( last_hidden_state: Optional[tf.Tensor] = None pooler_output: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )
参数
- last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。 - pooler_output (
tf.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 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
< source >( last_hidden_state: Optional[tf.Tensor] = None pooler_output: Optional[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 (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。 - pooler_output (
tf.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层权重在预训练期间通过下一句预测（分类）目标进行训练。此输出通常不是输入语义内容的良好摘要，通常通过对整个输入序列的隐藏状态序列进行平均或池化来获得更好的结果。
- 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输入）加速顺序解码。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均。
- cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
模型输出的基类，也包含最后隐藏状态的池化。
TFBaseModelOutputWithPast
class transformers.modeling_tf_outputs.TFBaseModelOutputWithPast
< source >( last_hidden_state: Optional[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 (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后隐藏状态。 - 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输入）加速顺序解码。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均。
模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。
TFBaseModelOutputWithPastAndCrossAttentions
class transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions
< 源 >( last_hidden_state: Optional[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 (
tf.Tensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。如果使用
past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 - past_key_values (
list[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含预先计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - 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 后的注意力权重，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或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: Optional[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 (
tf.Tensor形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。如果使用
past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 - past_key_values (
list[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含预先计算的解码器隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor元组（一个用于嵌入输出，一个用于每层输出），形状为(batch_size, sequence_length, hidden_size)。解码器每层输出的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器在注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 后的注意力权重，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
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元组（一个用于嵌入输出，一个用于每层输出），形状为(batch_size, sequence_length, hidden_size)。编码器每层输出的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器在注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
模型编码器输出的基类，也包含：可加速顺序解码的预计算隐藏状态。
TFCausalLMOutput
class transformers.modeling_tf_outputs.TFCausalLMOutput
< 源 >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )
参数
- loss (
tf.Tensor形状为(n,)，可选，其中 n 是非掩码标签的数量，当提供labels时返回) — 语言模型损失（用于下一个 token 预测）。 - logits (
tf.Tensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数（SoftMax 之前每个词汇 token 的分数）。 - 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 后的注意力权重，用于计算自注意力头中的加权平均值。
因果语言模型（或自回归模型）输出的基类。
TFCausalLMOutputWithCrossAttentions
class transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions
< 源 >( loss: tf.Tensor | None = None logits: Optional[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 (
tf.Tensor形状为(n,)，可选，其中 n 是非掩码标签的数量，当提供labels时返回) — 语言模型损失（用于下一个 token 预测）。 - logits (
tf.Tensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数（SoftMax 之前每个词汇 token 的分数）。 - 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 后的注意力权重，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 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输入）加速顺序解码。
因果语言模型（或自回归模型）输出的基类。
TFCausalLMOutputWithPast
class transformers.modeling_tf_outputs.TFCausalLMOutputWithPast
< 源 >( loss: tf.Tensor | None = None logits: Optional[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 (
tf.Tensor形状为(n,)，可选，其中 n 是非掩码标签的数量，当提供labels时返回) — 语言模型损失（用于下一个 token 预测）。 - logits (
tf.Tensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数（SoftMax 之前每个词汇 token 的分数）。 - 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)，可选，当传递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 后的注意力权重，用于计算自注意力头中的加权平均值。
因果语言模型（或自回归模型）输出的基类。
TFMaskedLMOutput
class transformers.modeling_tf_outputs.TFMaskedLMOutput
< 源 >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )
参数
- loss (
tf.Tensor形状为(n,)，可选，其中 n 是非掩码标签的数量，当提供labels时返回) — 掩码语言模型 (MLM) 损失。 - logits (
tf.Tensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数（SoftMax 之前每个词汇 token 的分数）。 - 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 后的注意力权重，用于计算自注意力头中的加权平均值。
掩码语言模型输出的基类。
TFSeq2SeqLMOutput
class transformers.modeling_tf_outputs.TFSeq2SeqLMOutput
< 源 >( loss: tf.Tensor | None = None logits: Optional[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形状为(n,)，可选，其中 n 是非掩码标签的数量，当提供labels时返回) — 语言模型损失。 - logits (
tf.Tensor形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测分数（SoftMax 之前每个词汇 token 的分数）。 - 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元组（每个层一个）。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
- encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(tf.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(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 之后，用于计算自注意力头中的加权平均。
序列到序列语言模型输出的基类。
TFNextSentencePredictorOutput
class transformers.modeling_tf_outputs.TFNextSentencePredictorOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )
参数
- loss (形状为
(n,)的tf.Tensor, 可选, 当提供next_sentence_label时返回，其中 n 为未遮罩标签的数量) — 下一句预测损失。 - logits (形状为
(batch_size, 2)的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 之后的注意力权重，用于计算自注意力头中的加权平均。
预测两个句子是否连续的模型输出的基类。
TFSequenceClassifierOutput
class transformers.modeling_tf_outputs.TFSequenceClassifierOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )
参数
- loss (形状为
(batch_size,)的tf.Tensor, 可选, 当提供labels时返回) — 分类损失（如果 config.num_labels==1 则为回归损失）。 - logits (形状为
(batch_size, config.num_labels)的tf.Tensor) — 分类分数（SoftMax 之前）（如果 config.num_labels==1 则为回归分数）。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均。
句子分类模型输出的基类。
TFSeq2SeqSequenceClassifierOutput
class transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput
< source >( loss: tf.Tensor | None = None logits: Optional[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) — 分类分数（SoftMax 之前）（如果 config.num_labels==1 则为回归分数）。 - 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
< source >( loss: tf.Tensor | None = None logits: Optional[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
< source >( loss: tf.Tensor | None = None logits: Optional[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.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
< source >( loss: tf.Tensor | None = None start_logits: Optional[tf.Tensor] = None end_logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )
参数
- loss (形状为
(batch_size,)的tf.Tensor, 可选, 当提供start_positions和end_positions时返回) — 总跨度提取损失是起始和结束位置的交叉熵之和。 - start_logits (形状为
(batch_size, sequence_length)的tf.Tensor) — 跨度起始分数（SoftMax 之前）。 - end_logits (形状为
(batch_size, sequence_length)的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 之后的注意力权重，用于计算自注意力头中的加权平均。
问答模型输出的基类。
TFSeq2SeqQuestionAnsweringModelOutput
class transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput
< 源 >( loss: tf.Tensor | None = None start_logits: Optional[tf.Tensor] = None end_logits: Optional[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.Tensorof shape(1,), 可选, 当提供labels时返回) — 总的 span 提取损失，是开始位置和结束位置的交叉熵之和。 - start_logits (
tf.Tensorof shape(batch_size, sequence_length)) — Span 开始分数 (SoftMax 之前)。 - end_logits (
tf.Tensorof shape(batch_size, sequence_length)) — Span 结束分数 (SoftMax 之前)。 - past_key_values (
list[tf.Tensor], 可选, 当传入use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含预先计算的解码器隐藏状态 (注意力块中的键和值)，可用于加速顺序解码 (参见
past_key_values输入)。 - decoder_hidden_states (
tuple(tf.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组 (一个用于嵌入输出 + 一个用于每个层的输出)，形状为(batch_size, sequence_length, hidden_size)。解码器在每个层输出的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(tf.Tensor), 可选, 当传入output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组 (每个层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
- encoder_last_hidden_state (
tf.Tensorof shape(batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的隐藏状态序列。 - encoder_hidden_states (
tuple(tf.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组 (一个用于嵌入输出 + 一个用于每个层的输出)，形状为(batch_size, sequence_length, hidden_size)。编码器在每个层输出的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(tf.Tensor), 可选, 当传入output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组 (每个层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
序列到序列问答模型输出的基类。
FlaxBaseModelOutput
class transformers.modeling_flax_outputs.FlaxBaseModelOutput
< 源 >( last_hidden_state: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- last_hidden_state (
jnp.ndarrayof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
模型输出的基类，可能包含隐藏状态和注意力。
“返回一个新对象，用新值替换指定字段。
FlaxBaseModelOutputWithPast
class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast
< 源 >( last_hidden_state: typing.Optional[jax.Array] = None past_key_values: typing.Optional[dict[str, jax.Array]] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- last_hidden_state (
jnp.ndarrayof shape(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 之后的注意力权重，用于计算自注意力头中的加权平均值。
模型输出的基类，可能包含隐藏状态和注意力。
“返回一个新对象，用新值替换指定字段。
FlaxBaseModelOutputWithPooling
class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling
< 源 >( last_hidden_state: typing.Optional[jax.Array] = None pooler_output: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- last_hidden_state (
jnp.ndarrayof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。 - pooler_output (
jnp.ndarrayof shape(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 之后的注意力权重，用于计算自注意力头中的加权平均值。
模型输出的基类，也包含最后隐藏状态的池化。
“返回一个新对象，用新值替换指定字段。
FlaxBaseModelOutputWithPastAndCrossAttentions
class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions
< 源 >( last_hidden_state: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- last_hidden_state (
jnp.ndarrayof shape(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 之后，用于计算交叉注意力头中的加权平均值。
模型输出的基类，也可能包含过去的键/值（以加速顺序解码）。
“返回一个新对象，用新值替换指定字段。
FlaxSeq2SeqModelOutput
class transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput
< 源 >( last_hidden_state: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[tuple[jax.Array]] = None decoder_attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[tuple[jax.Array]] = None encoder_attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- last_hidden_state (
jnp.ndarrayof shape(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)的张量，以及 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), optional, 当传入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 之后的注意力权重，用于计算自注意力头中的加权平均值。
模型编码器输出的基类，也包含：可加速顺序解码的预计算隐藏状态。
“返回一个新对象，用新值替换指定字段。
FlaxCausalLMOutputWithCrossAttentions
class transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions
< 源 >( logits: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[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输入）加速顺序解码。
因果语言模型（或自回归模型）输出的基类。
“返回一个新对象，用新值替换指定字段。
FlaxMaskedLMOutput
class transformers.modeling_flax_outputs.FlaxMaskedLMOutput
< 源 >( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[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 之后的注意力权重，用于计算自注意力头中的加权平均值。
掩码语言模型输出的基类。
“返回一个新对象，用新值替换指定字段。
FlaxSeq2SeqLMOutput
class transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput
< 源 >( logits: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[tuple[jax.Array]] = None decoder_attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[tuple[jax.Array]] = None encoder_attentions: typing.Optional[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(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 之后的注意力权重，用于计算自注意力头中的加权平均值。
序列到序列语言模型输出的基类。
“返回一个新对象，用新值替换指定字段。
FlaxNextSentencePredictorOutput
class transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput
< 源 >( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- logits (形状为
(batch_size, 2)的jnp.ndarray) — 下一个序列预测（分类）头的预测分数（SoftMax 之前的 True/False 延续分数）。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
预测两个句子是否连续的模型输出的基类。
“返回一个新对象，用新值替换指定字段。
FlaxSequenceClassifierOutput
class transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput
< 源 >( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- logits (形状为
(batch_size, config.num_labels)的jnp.ndarray) — 分类（如果 config.num_labels==1 则为回归）分数（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 之后的注意力权重，用于计算自注意力头中的加权平均值。
句子分类模型输出的基类。
“返回一个新对象，用新值替换指定字段。
FlaxSeq2SeqSequenceClassifierOutput
class transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput
< 源 >( logits: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[tuple[jax.Array]] = None decoder_attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[tuple[jax.Array]] = None encoder_attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- logits (形状为
(batch_size, config.num_labels)的jnp.ndarray) — 分类（如果 config.num_labels==1 则为回归）分数（SoftMax 之前）。 - past_key_values (
tuple(tuple(jnp.ndarray)), 可选, 当传入use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)的元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(jnp.ndarray), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —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 之后的注意力权重，用于计算自注意力头中的加权平均值。
序列到序列句子分类模型输出的基类。
“返回一个新对象，用新值替换指定字段。
FlaxMultipleChoiceModelOutput
class transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput
< source >( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- logits (
jnp.ndarray，形状为(batch_size, num_choices)) — num_choices 是输入张量的第二个维度。(参见上面的 input_ids)。分类得分（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 之后，用于计算自注意力头中加权平均的注意力权重。
多项选择模型输出的基类。
“返回一个新对象，用新值替换指定字段。
FlaxTokenClassifierOutput
class transformers.modeling_flax_outputs.FlaxTokenClassifierOutput
< source >( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- logits (
jnp.ndarray，形状为(batch_size, sequence_length, config.num_labels)) — 分类得分（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 之后，用于计算自注意力头中加权平均的注意力权重。
Token分类模型输出的基类。
“返回一个新对象，用新值替换指定字段。
FlaxQuestionAnsweringModelOutput
class transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput
< source >( start_logits: typing.Optional[jax.Array] = None end_logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- start_logits (
jnp.ndarray，形状为(batch_size, sequence_length)) — 跨度起始分数（SoftMax之前）。 - end_logits (
jnp.ndarray，形状为(batch_size, sequence_length)) — 跨度结束分数（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 之后，用于计算自注意力头中加权平均的注意力权重。
问答模型输出的基类。
“返回一个新对象，用新值替换指定字段。
FlaxSeq2SeqQuestionAnsweringModelOutput
class transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput
< source >( start_logits: typing.Optional[jax.Array] = None end_logits: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[tuple[jax.Array]] = None decoder_attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[tuple[jax.Array]] = None encoder_attentions: typing.Optional[tuple[jax.Array]] = None )
参数
- start_logits (
jnp.ndarray，形状为(batch_size, sequence_length)) — 跨度起始分数（SoftMax之前）。 - end_logits (
jnp.ndarray，形状为(batch_size, sequence_length)) — 跨度结束分数（SoftMax之前）。 - past_key_values (
tuple(tuple(jnp.ndarray))，可选，当传入use_cache=True或config.use_cache=True时返回) —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)，可选，当传入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 (
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的元组（一个用于嵌入输出，一个用于每个层的输出），形状为(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 之后，用于计算自注意力头中加权平均的注意力权重。
序列到序列问答模型输出的基类。
“返回一个新对象，用新值替换指定字段。