Transformers documentation
模型输出
模型输出
所有模型的输出都是 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 属性。在这里，由于我们传入了 labels，所以有 loss，但由于我们没有传入 output_hidden_states=True 或 output_attentions=True，所以没有 hidden_states 和 attentions。
当
output_hidden_states=True时，outputs.hidden_states[-1]并不总是与outputs.last_hidden_state相同的张量。许多视觉和音频编码器（例如 ViT、DINOv2、CLIP 和 Wav2Vec2）会在hidden_states[-1]中返回最后一层在最终 layernorm 之前 的输出，并在last_hidden_state中返回归一化后的输出。请使用last_hidden_state作为模型的最终特征。若要使hidden_states[-1]与last_hidden_state保持一致，请在模型配置中设置tie_last_hidden_states=True。
您可以像往常一样访问每个属性，如果该属性未被模型返回，您将获得 None。例如，outputs.loss 是模型计算出的损失，而 outputs.attentions 为 None。
将 outputs 对象视为元组时，它只考虑那些值不为 None 的属性。
例如，这里它有两个元素，先是 loss，然后是 logits，因此
outputs[:2]例如，将返回元组 (outputs.loss, outputs.logits)。
将我们的 outputs 对象视为字典时，它只包含那些值不为 None 的属性。例如，这里有两个键，分别是 loss 和 logits。
此处记录的是被多种模型类型共用的通用模型输出。特定输出类型将在其对应的模型页面上进行说明。
ModelOutput
所有模型输出的基类，以 dataclass 形式实现。具有 __getitem__ 方法，支持通过整数或切片（类似元组）或字符串（类似字典）进行索引，且会忽略 None 属性。其余行为与普通 Python 字典一致。
无法直接解包
ModelOutput。请先使用 to_tuple() 方法将其转换为元组。
将 self 转换为一个元组，其中包含所有不为 None 的属性/键。
BaseModelOutput
类 transformers.modeling_outputs.BaseModelOutput
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
模型输出的基类，可能包含隐藏状态和注意力。
BaseModelOutputWithPooling
类 transformers.modeling_outputs.BaseModelOutputWithPooling
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - pooler_output (
torch.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重在预训练期间通过下一句预测（分类）目标进行训练。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
模型输出的基类，同时包含最后一个隐藏状态的池化结果。
BaseModelOutputWithCrossAttentions
类 transformers.modeling_outputs.BaseModelOutputWithCrossAttentions
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 当output_attentions=True且config.add_cross_attention=True被传入时，或当config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
模型输出的基类，可能包含隐藏状态和注意力。
BaseModelOutputWithPoolingAndCrossAttentions
class transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneattentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - pooler_output (
torch.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重在预训练期间通过下一句预测（分类）目标进行训练。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 当output_attentions=True且config.add_cross_attention=True被传入时，或当config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- past_key_values (
Cache, 可选, 在以下情况下返回use_cache=True被传入或config.use_cache=True) — 它是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含预计算的隐藏状态（自注意力块中的键和值，以及如果
config.is_encoder_decoder=True则还包括交叉注意力块中的键和值），可用于（参见past_key_values输入）加速顺序解码。
模型输出的基类，同时包含最后一个隐藏状态的池化结果。
BaseModelOutputWithPast
类 transformers.modeling_outputs.BaseModelOutputWithPast
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。如果使用了
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 - past_key_values (
Cache, 可选, 在以下情况下返回use_cache=True被传入或config.use_cache=True) — 它是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含预计算的隐藏状态（自注意力块中的键和值，以及如果
config.is_encoder_decoder=True则还包括交叉注意力块中的键和值），可用于（参见past_key_values输入）加速顺序解码。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
模型输出的基类，其中可能还包含过去的键/值（以加速顺序解码）。
BaseModelOutputWithPastAndCrossAttentions
class transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。如果使用了
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 - past_key_values (
Cache, 可选, 在以下情况下返回use_cache=True被传入或config.use_cache=True) — 它是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含预计算的隐藏状态（自注意力块中的键和值，以及如果
config.is_encoder_decoder=True则还包括交叉注意力块中的键和值），可用于（参见past_key_values输入）加速顺序解码。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 当output_attentions=True且config.add_cross_attention=True被传入时，或当config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
模型输出的基类，其中可能还包含过去的键/值（以加速顺序解码）。
Seq2SeqModelOutput
类 transformers.modeling_outputs.Seq2SeqModelOutput
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor形状为(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.Tensor), 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- decoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.Tensor), 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组，包含torch.Tensor(（如果模型有嵌入层，则包含嵌入层的输出，加上每一层的输出）(batch_size, sequence_length, hidden_size).编码器每层输出处的隐藏状态，以及可选的初始嵌入输出。
- encoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
模型编码器输出的基类，同时包含：可加速顺序解码的预计算隐藏状态。
CausalLMOutput
class transformers.modeling_outputs.CausalLMOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 语言建模损失（用于下一个词元预测）。 - logits (
torch.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
因果语言模型（或自回归）输出的基类。
CausalLMOutputWithCrossAttentions
类 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 语言建模损失（用于下一个词元预测）。 - logits (
torch.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(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
类 transformers.modeling_outputs.CausalLMOutputWithPast
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 语言建模损失（用于下一个词元预测）。 - logits (
torch.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 - past_key_values (
Cache, 可选, 在以下情况下返回use_cache=True被传入或config.use_cache=True) — 它是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
因果语言模型（或自回归）输出的基类。
MaskedLMOutput
class transformers.modeling_outputs.MaskedLMOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 掩码语言建模（MLM）损失。 - logits (
torch.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
掩码语言模型输出的基类。
Seq2SeqLMOutput
class transformers.modeling_outputs.Seq2SeqLMOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 语言建模损失。 - logits (
torch.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 - past_key_values (
EncoderDecoderCache, 可选, 在以下情况下返回use_cache=True被传入或config.use_cache=True) — 它是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.Tensor), 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.Tensor), 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
序列到序列语言模型输出的基类。
NextSentencePredictorOutput
类 transformers.modeling_outputs.NextSentencePredictorOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供next_sentence_label时返回) — 下一句预测（分类）损失。 - logits (
torch.Tensor，形状为(batch_size, 2)) — 下一个序列预测（分类）头的预测分数（SoftMax 之前 True/False 延续的分数）。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
用于预测两个句子是否连续的模型输出的基类。
SequenceClassifierOutput
类 transformers.modeling_outputs.SequenceClassifierOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 - logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
句子分类模型输出的基类。
Seq2SeqSequenceClassifierOutput
类 transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供label时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 - logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。 - past_key_values (
EncoderDecoderCache, 可选, 在以下情况下返回use_cache=True被传入或config.use_cache=True) — 它是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.Tensor), 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.Tensor), 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
序列到序列句子分类模型输出的基类。
MultipleChoiceModelOutput
class transformers.modeling_outputs.MultipleChoiceModelOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为 (1,)，可选，在提供labels时返回) — 分类损失。 - logits (
torch.Tensor形状为(batch_size, num_choices)) — num_choices 是输入张量的第二维。（参见 input_ids ）。分类分数（SoftMax 之前）。
- hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
多选模型输出的基类。
TokenClassifierOutput
class transformers.modeling_outputs.TokenClassifierOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 分类损失。 - logits（形状为
(batch_size, sequence_length, config.num_labels)的torch.Tensor）— 分类分数（SoftMax 之前）。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
用于标记分类模型输出的基类。
QuestionAnsweringModelOutput
class transformers.modeling_outputs.QuestionAnsweringModelOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonestart_logits: typing.Optional[torch.Tensor] = Noneend_logits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。 - start_logits（形状为
(batch_size, sequence_length)的torch.Tensor）— 跨度起始分数（SoftMax 之前）。 - end_logits（形状为
(batch_size, sequence_length)的torch.Tensor）— 跨度结束分数（SoftMax 之前）。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
问答模型输出的基类。
Seq2SeqQuestionAnsweringModelOutput
class transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonestart_logits: typing.Optional[torch.Tensor] = Noneend_logits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。 - start_logits（形状为
(batch_size, sequence_length)的torch.Tensor）— 跨度起始分数（SoftMax 之前）。 - end_logits（形状为
(batch_size, sequence_length)的torch.Tensor）— 跨度结束分数（SoftMax 之前）。 - past_key_values (
EncoderDecoderCache, 可选, 在以下情况下返回use_cache=True被传入或config.use_cache=True) — 它是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.Tensor), 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.Tensor), 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
序列到序列问答模型输出的基类。
Seq2SeqSpectrogramOutput
class transformers.modeling_outputs.Seq2SeqSpectrogramOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonespectrogram: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 频谱图生成损失。 - spectrogram（形状为
(batch_size, sequence_length, num_bins)的torch.Tensor）— 预测的频谱图。 - past_key_values (
EncoderDecoderCache, 可选, 在以下情况下返回use_cache=True被传入或config.use_cache=True) — 它是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.Tensor), 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.Tensor), 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
序列到序列频谱输出的基类。
SemanticSegmenterOutput
class transformers.modeling_outputs.SemanticSegmenterOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 - logits (
torch.Tensor形状为(batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。返回的 logits 不一定与作为输入传入的 pixel_values 具有相同的大小。这是为了避免进行两次插值，从而在用户需要作为后处理将 logits 调整回原始图像大小时损失一些质量。您应该始终检查 logits 的形状，并根据需要进行调整。返回的 logits 的大小不一定与作为输入传入的
pixel_values相同。这样做的目的是避免进行两次插值，从而在用户需要作为后处理将 logits 调整回原始图像大小时损失一些质量。您应始终检查 logits 的形状，并根据需要进行调整。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, patch_size, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, patch_size, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
语义分割模型输出的基类。
ImageClassifierOutput
类 transformers.modeling_outputs.ImageClassifierOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 - logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。 - hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.Tensor的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个阶段输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每个阶段输出处的隐藏状态（也称为特征图）。 - attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, patch_size, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
图像分类模型输出的基类。
ImageClassifierOutputWithNoAttention
类 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 - logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。 - hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.Tensor的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个阶段输出的一个张量），形状为(batch_size, num_channels, height, width)。模型在每个阶段输出处的隐藏状态（也称为特征图）。
图像分类模型输出的基类。
DepthEstimatorOutput
class transformers.modeling_outputs.DepthEstimatorOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonepredicted_depth: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 - predicted_depth（形状为
(batch_size, height, width)的torch.Tensor）— 每个像素的预测深度。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, num_channels, height, width).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, patch_size, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
深度估计模型输出的基类。
Wav2Vec2BaseModelOutput
class transformers.modeling_outputs.Wav2Vec2BaseModelOutput
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Noneextract_features: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - extract_features (
torch.Tensor，形状为(batch_size, sequence_length, conv_dim[-1])) — 模型最后一个卷积层提取的特征向量序列。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（嵌入层输出一个 + 每层输出各一个），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
使用 Wav2Vec2 损失目标进行训练的模型基类。
XVectorOutput
class transformers.modeling_outputs.XVectorOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Noneembeddings: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 分类损失。 - logits (
torch.Tensor，形状为(batch_size, config.xvector_output_dim)) — AMSoftmax 之前的分类隐藏状态。 - embeddings (
torch.Tensor，形状为(batch_size, config.xvector_output_dim)) — 用于基于向量相似性检索的语句嵌入。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（嵌入层输出一个 + 每层输出各一个），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
Wav2Vec2ForXVector 的输出类型。
Seq2SeqTSModelOutput
class transformers.modeling_outputs.Seq2SeqTSModelOutput
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneloc: typing.Optional[torch.Tensor] = Nonescale: typing.Optional[torch.Tensor] = Nonestatic_features: typing.Optional[torch.Tensor] = None )
参数
- last_hidden_state (
torch.Tensor形状为(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.Tensor), 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，加上每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- decoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.Tensor), 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组，包含torch.Tensor(（如果模型有嵌入层，则包含嵌入层的输出，加上每一层的输出）(batch_size, sequence_length, hidden_size).编码器每层输出处的隐藏状态，以及可选的初始嵌入输出。
- encoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- loc (
torch.Tensor，形状为(batch_size,)或(batch_size, input_size)，可选) — 平移每个时间序列上下文窗口的值，用于向模型提供具有相同量级的输入，随后再平移回原始量级。 - scale (
torch.Tensor，形状为(batch_size,)或(batch_size, input_size)，可选) — 用于缩放每个时间序列上下文窗口的值，以便为模型提供量级相同的输入，随后再将其缩放回原始量级。 - static_features (
torch.Tensor，形状为(batch_size, feature size)，可选) — 批次中每个时间序列的静态特征，在推理时会被复制到协变量中。
时间序列模型编码器输出的基类，其中还包含可加速顺序解码的预计算隐藏状态。
Seq2SeqTSPredictionOutput
类 transformers.modeling_outputs.Seq2SeqTSPredictionOutput
< source >( loss: typing.Optional[torch.Tensor] = Noneparams: tuple[torch.Tensor, ...] | None = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneloc: typing.Optional[torch.Tensor] = Nonescale: typing.Optional[torch.Tensor] = Nonestatic_features: typing.Optional[torch.Tensor] = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供future_values时返回) — 分布损失。 - params（形状为
(batch_size, num_samples, num_params)的torch.Tensor）— 所选分布的参数。 - past_key_values (
EncoderDecoderCache, 可选, 在以下情况下返回use_cache=True被传入或config.use_cache=True) — 它是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.Tensor), 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.Tensor), 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- loc (
torch.Tensor，形状为(batch_size,)或(batch_size, input_size)，可选) — 平移每个时间序列上下文窗口的值，用于向模型提供具有相同量级的输入，随后再平移回原始量级。 - scale (
torch.Tensor，形状为(batch_size,)或(batch_size, input_size)，可选) — 用于缩放每个时间序列上下文窗口的值，以便为模型提供量级相同的输入，随后再将其缩放回原始量级。 - static_features (
torch.Tensor，形状为(batch_size, feature size)，可选) — 批次中每个时间序列的静态特征，在推理时会被复制到协变量中。
时间序列模型解码器输出的基类，其中还包含损失值以及所选分布的参数。
SampleTSPredictionOutput
class transformers.modeling_outputs.SampleTSPredictionOutput
< source >( sequences: typing.Optional[torch.Tensor] = None )
时间序列模型预测输出的基类，包含从所选分布中采样的值。