# モデルの出力

すべてのモデルの出力は、[ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput)のサブクラスのインスタンスです。これらはモデルが返すすべての情報を含むデータ構造体ですが、タプルや辞書としても使用できます。

例を見てみましょう:

```python
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](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) であり、以下のそのクラスのドキュメントに示されているように、任意の `loss`、`logits`、任意の `hidden_states`、および任意の `attentions` 属性を持つことを意味します。ここでは `labels` を渡したため `loss` が存在しますが、`output_hidden_states=True` や `output_attentions=True` を渡していないため、`hidden_states` と `attentions` は存在しません。

> [!TIP]
> `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` の2つの要素を持つため、

```python
outputs[:2]
```

例えば、`(outputs.loss, outputs.logits)` というタプルを返します。

`outputs` オブジェクトを辞書として扱う場合、`None` 以外の値を持つ属性のみが対象となります。例えば、ここでは `loss` と `logits` という2つのキーがあります。

ここでは、複数のモデルタイプで共通して使用される汎用的なモデル出力を説明します。特定の出力タイプについては、それぞれのモデルのページで説明しています。

## ModelOutput[[transformers.utils.ModelOutput]]

#### transformers.utils.ModelOutput[[transformers.utils.ModelOutput]]

```python
transformers.utils.ModelOutput(*args, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/generic.py#L419)

すべてのモデル出力の基底クラスであり、dataclass として実装されています。`__getitem__` を備えており、整数やスライス（タプルと同様）または文字列（辞書と同様）によるインデックス指定が可能です。この際、`None` の属性は無視されます。それ以外の動作は、通常の Python 辞書と同様です。

`ModelOutput` を直接アンパックすることはできません。まず、[to_tuple()](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput.to_tuple) メソッドを使用してタプルに変換してください。

#### to_tuple[[transformers.utils.ModelOutput.to_tuple]]

```python
to_tuple()
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/generic.py#L552)

`None` 以外のすべての属性/キーを含むタプルに self を変換します。

## BaseModelOutput[[transformers.modeling_outputs.BaseModelOutput]]

#### transformers.modeling_outputs.BaseModelOutput[[transformers.modeling_outputs.BaseModelOutput]]

```python
transformers.modeling_outputs.BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L24)

**パラメータ:**

last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における隠れ状態のシーケンス。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

モデルの出力の基底クラス。潜在的な隠れ状態やアテンションを含む場合があります。

## BaseModelOutputWithPooling[[transformers.modeling_outputs.BaseModelOutputWithPooling]]

#### transformers.modeling_outputs.BaseModelOutputWithPooling[[transformers.modeling_outputs.BaseModelOutputWithPooling]]

```python
transformers.modeling_outputs.BaseModelOutputWithPooling(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L69)

**パラメータ:**

last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における隠れ状態のシーケンス。

pooler_output (`torch.Tensor`、形状 `(batch_size, hidden_size)`) : シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態。補助的な事前学習タスクに使用される層をさらに通して処理された後のものです。例えば、BERT系のモデルでは、線形層とtanh活性化関数を通過した後の分類トークンを返します。この線形層の重みは、事前学習中の次の文予測（分類）目的から学習されます。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

モデルの出力の基底クラスであり、最後の隠れ状態のプーリングも含まれます。

## BaseModelOutputWithCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithCrossAttentions]]

#### transformers.modeling_outputs.BaseModelOutputWithCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithCrossAttentions]]

```python
transformers.modeling_outputs.BaseModelOutputWithCrossAttentions(last_hidden_state: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L159)

**パラメータ:**

last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における隠れ状態のシーケンス。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` と `config.add_cross_attention=True` が渡された場合、または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンションレイヤーのアテンション重みです。

モデルの出力の基底クラス。潜在的な隠れ状態やアテンションを含む場合があります。

## BaseModelOutputWithPoolingAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions]]

#### transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions]]

```python
transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L192)

**パラメータ:**

last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における隠れ状態のシーケンス。

pooler_output (`torch.Tensor`、形状 `(batch_size, hidden_size)`) : シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態。補助的な事前学習タスクに使用される層をさらに通して処理された後のものです。例えば、BERT系のモデルでは、線形層とtanh活性化関数を通過した後の分類トークンを返します。この線形層の重みは、事前学習中の次の文予測（分類）目的から学習されます。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` と `config.add_cross_attention=True` が渡された場合、または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンションレイヤーのアテンション重みです。

past_key_values (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [Cache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックの key と value、および `config.is_encoder_decoder=True` の場合の cross-attention ブロックの key と value）が含まれます。

モデルの出力の基底クラスであり、最後の隠れ状態のプーリングも含まれます。

## BaseModelOutputWithPast[[transformers.modeling_outputs.BaseModelOutputWithPast]]

#### transformers.modeling_outputs.BaseModelOutputWithPast[[transformers.modeling_outputs.BaseModelOutputWithPast]]

```python
transformers.modeling_outputs.BaseModelOutputWithPast(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L123)

**パラメータ:**

last_hidden_state (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における hidden-states のシーケンスです。 `past_key_values` が使用されている場合、シーケンスの最後の hidden-state のみ、shape `(batch_size, 1, hidden_size)` で出力されます。

past_key_values (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [Cache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックの key と value、および `config.is_encoder_decoder=True` の場合の cross-attention ブロックの key と value）が含まれます。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

シーケンシャルデコーディングを高速化するために、過去のキー/値を含む場合もあるモデルの出力の基底クラス。

## BaseModelOutputWithPastAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions]]

#### transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions]]

```python
transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L238)

**パラメータ:**

last_hidden_state (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`) : モデルの最終層の出力における hidden-states のシーケンスです。 `past_key_values` が使用されている場合、シーケンスの最後の hidden-state のみ、shape `(batch_size, 1, hidden_size)` で出力されます。

past_key_values (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [Cache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックの key と value、および `config.is_encoder_decoder=True` の場合の cross-attention ブロックの key と value）が含まれます。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` と `config.add_cross_attention=True` が渡された場合、または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンションレイヤーのアテンション重みです。

シーケンシャルデコーディングを高速化するために、過去のキー/値を含む場合もあるモデルの出力の基底クラス。

## Seq2SeqModelOutput[[transformers.modeling_outputs.Seq2SeqModelOutput]]

#### transformers.modeling_outputs.Seq2SeqModelOutput[[transformers.modeling_outputs.Seq2SeqModelOutput]]

```python
transformers.modeling_outputs.Seq2SeqModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L454)

**パラメータ:**

last_hidden_state (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`) : モデルのデコーダーの最終層の出力における、hidden-states のシーケンスです。 `past_key_values` が使用されている場合、シーケンスの最後の hidden-state のみ、shape `(batch_size, 1, hidden_size)` で出力されます。

past_key_values (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロックの key と value）が含まれます。

decoder_hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるデコーダーの隠れ状態と、任意の初期埋め込み出力です。

decoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、自己アテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(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)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力時の隠れ状態と、任意の初期埋め込み出力です。

encoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のもので、セルフアテンションヘッドにおける加重平均の計算に使用されます。

モデルエンコーダーの出力の基底クラスであり、シーケンシャルデコーディングを高速化できる事前計算済みヒドゥンステートも含まれます。

## CausalLMOutput[[transformers.modeling_outputs.CausalLMOutput]]

#### transformers.modeling_outputs.CausalLMOutput[[transformers.modeling_outputs.CausalLMOutput]]

```python
transformers.modeling_outputs.CausalLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L583)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : 言語モデリングの損失（次のトークンの予測用）。

logits (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) : 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

因果言語モデル（または自己回帰型）の出力の基底クラス。

## CausalLMOutputWithCrossAttentions[[transformers.modeling_outputs.CausalLMOutputWithCrossAttentions]]

#### transformers.modeling_outputs.CausalLMOutputWithCrossAttentions[[transformers.modeling_outputs.CausalLMOutputWithCrossAttentions]]

```python
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L647)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : 言語モデリングの損失（次のトークンの予測用）。

logits (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) : 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のクロスアテンションの重みで、クロスアテンションヘッドにおける加重平均の計算に使用されます。

past_key_values (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [Cache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（attention ブロックの key と value）が含まれます。

因果言語モデル（または自己回帰型）の出力の基底クラス。

## CausalLMOutputWithPast[[transformers.modeling_outputs.CausalLMOutputWithPast]]

#### transformers.modeling_outputs.CausalLMOutputWithPast[[transformers.modeling_outputs.CausalLMOutputWithPast]]

```python
transformers.modeling_outputs.CausalLMOutputWithPast(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L612)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : 言語モデリングの損失（次のトークンの予測用）。

logits (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) : 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。

past_key_values (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [Cache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックの key と value）が含まれます。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

因果言語モデル（または自己回帰型）の出力の基底クラス。

## MaskedLMOutput[[transformers.modeling_outputs.MaskedLMOutput]]

#### transformers.modeling_outputs.MaskedLMOutput[[transformers.modeling_outputs.MaskedLMOutput]]

```python
transformers.modeling_outputs.MaskedLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L724)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : マスクド言語モデリング (MLM) の損失。

logits (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) : 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

マスク付き言語モデルの出力の基底クラス。

## Seq2SeqLMOutput[[transformers.modeling_outputs.Seq2SeqLMOutput]]

#### transformers.modeling_outputs.Seq2SeqLMOutput[[transformers.modeling_outputs.Seq2SeqLMOutput]]

```python
transformers.modeling_outputs.Seq2SeqLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L753)

**パラメータ:**

loss (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) : 言語モデリング損失。

logits (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) : 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。

past_key_values (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロックの key と value）が含まれます。

decoder_hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合はその出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、自己アテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(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)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のもので、セルフアテンションヘッドにおける加重平均の計算に使用されます。

シーケンスツーシーケンス言語モデルの出力の基底クラス。

## NextSentencePredictorOutput[[transformers.modeling_outputs.NextSentencePredictorOutput]]

#### transformers.modeling_outputs.NextSentencePredictorOutput[[transformers.modeling_outputs.NextSentencePredictorOutput]]

```python
transformers.modeling_outputs.NextSentencePredictorOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L884)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`next_sentence_label` が提供された場合に返されます) : 次のシーケンス予測（分類）損失。

logits (`torch.Tensor`、形状 `(batch_size, 2)`) : 次のシーケンス予測（分類）ヘッドの予測スコア（SoftMax 前の True/False 継続のスコア）。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

2つの文が連続しているかどうかを予測するモデルの出力の基底クラス。

## SequenceClassifierOutput[[transformers.modeling_outputs.SequenceClassifierOutput]]

#### transformers.modeling_outputs.SequenceClassifierOutput[[transformers.modeling_outputs.SequenceClassifierOutput]]

```python
transformers.modeling_outputs.SequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L914)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : 分類（または config.num_labels==1 の場合は回帰）の損失。

logits (`torch.Tensor`、shape `(batch_size, config.num_labels)`) : SoftMax 適用前の分類スコア（config.num_labels==1 の場合は回帰スコア）。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

文分類モデルの出力の基底クラス。

## Seq2SeqSequenceClassifierOutput[[transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput]]

#### transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput[[transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput]]

```python
transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L943)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`label` が指定された場合に返されます) : 分類（または config.num_labels==1 の場合は回帰）の損失。

logits (`torch.Tensor`、shape `(batch_size, config.num_labels)`) : SoftMax 適用前の分類スコア（config.num_labels==1 の場合は回帰スコア）。

past_key_values (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロックの key と value）が含まれます。

decoder_hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合はその出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、自己アテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(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)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のもので、セルフアテンションヘッドにおける加重平均の計算に使用されます。

シーケンスツーシーケンス文分類モデルの出力の基底クラス。

## MultipleChoiceModelOutput[[transformers.modeling_outputs.MultipleChoiceModelOutput]]

#### transformers.modeling_outputs.MultipleChoiceModelOutput[[transformers.modeling_outputs.MultipleChoiceModelOutput]]

```python
transformers.modeling_outputs.MultipleChoiceModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1001)

**パラメータ:**

loss (`torch.Tensor`、形状 *(1,)*、*任意*、`labels` が指定された場合に返されます) : 分類損失。

logits (`torch.Tensor`、shape `(batch_size, num_choices)`) : *num_choices*は入力テンソルの2番目の次元です（上記の*input_ids*を参照）。SoftMax適用前の分類スコア。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

複数選択モデルの出力の基底クラス。

## TokenClassifierOutput[[transformers.modeling_outputs.TokenClassifierOutput]]

#### transformers.modeling_outputs.TokenClassifierOutput[[transformers.modeling_outputs.TokenClassifierOutput]]

```python
transformers.modeling_outputs.TokenClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1032)

**パラメータ:**

loss (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) : 分類損失。

logits (`torch.Tensor`、形状 `(batch_size, sequence_length, config.num_labels)`) : SoftMax 適用前の分類スコア。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

トークン分類モデルの出力の基底クラス。

## QuestionAnsweringModelOutput[[transformers.modeling_outputs.QuestionAnsweringModelOutput]]

#### transformers.modeling_outputs.QuestionAnsweringModelOutput[[transformers.modeling_outputs.QuestionAnsweringModelOutput]]

```python
transformers.modeling_outputs.QuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1061)

**パラメータ:**

loss (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) : 総スパン抽出損失は、開始位置と終了位置の Cross-Entropy の和です。

start_logits (`torch.Tensor`、形状 `(batch_size, sequence_length)`) : スパン開始スコア（SoftMax 適用前）。

end_logits (`torch.Tensor`、形状 `(batch_size, sequence_length)`) : スパン終了スコア（SoftMax 適用前）。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

質問応答モデルの出力の基底クラス。

## Seq2SeqQuestionAnsweringModelOutput[[transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput]]

#### transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput[[transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput]]

```python
transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1093)

**パラメータ:**

loss (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) : 総スパン抽出損失は、開始位置と終了位置の Cross-Entropy の和です。

start_logits (`torch.Tensor`、形状 `(batch_size, sequence_length)`) : スパン開始スコア（SoftMax 適用前）。

end_logits (`torch.Tensor`、形状 `(batch_size, sequence_length)`) : スパン終了スコア（SoftMax 適用前）。

past_key_values (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロックの key と value）が含まれます。

decoder_hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合はその出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、自己アテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(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)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のもので、セルフアテンションヘッドにおける加重平均の計算に使用されます。

シーケンスツーシーケンスの質問応答モデルの出力の基底クラス。

## Seq2SeqSpectrogramOutput[[transformers.modeling_outputs.Seq2SeqSpectrogramOutput]]

#### transformers.modeling_outputs.Seq2SeqSpectrogramOutput[[transformers.modeling_outputs.Seq2SeqSpectrogramOutput]]

```python
transformers.modeling_outputs.Seq2SeqSpectrogramOutput(loss: typing.Optional[torch.Tensor] = None, spectrogram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1424)

**パラメータ:**

loss (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が提供された場合に返されます) : スペクトログラム生成の損失。

spectrogram (`torch.Tensor`、形状 `(batch_size, sequence_length, num_bins)`) : 予測されたスペクトログラム。

past_key_values (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロックの key と value）が含まれます。

decoder_hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合はその出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、自己アテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(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)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のもので、セルフアテンションヘッドにおける加重平均の計算に使用されます。

シーケンスツーシーケンスのスペクトログラム出力の基底クラス。

## SemanticSegmenterOutput[[transformers.modeling_outputs.SemanticSegmenterOutput]]

#### transformers.modeling_outputs.SemanticSegmenterOutput[[transformers.modeling_outputs.SemanticSegmenterOutput]]

```python
transformers.modeling_outputs.SemanticSegmenterOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1154)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : 分類（または config.num_labels==1 の場合は回帰）の損失。

logits (`torch.Tensor`、shape は `(batch_size, config.num_labels, logits_height, logits_width)`) : 各ピクセルの分類スコア。    返される logits は、入力として渡された `pixel_values` と同じサイズとは限りません。これは、ユーザーが後処理として logits を元の画像サイズにリサイズする際に、2 回の補間処理を行って品質を失うことを避けるためです。logits の shape を常に確認し、必要に応じてリサイズしてください。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, patch_size, hidden_size)` です。 各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, patch_size, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

セマンティックセグメンテーションモデルの出力の基底クラス。

## ImageClassifierOutput[[transformers.modeling_outputs.ImageClassifierOutput]]

#### transformers.modeling_outputs.ImageClassifierOutput[[transformers.modeling_outputs.ImageClassifierOutput]]

```python
transformers.modeling_outputs.ImageClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1192)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : 分類（または config.num_labels==1 の場合は回帰）の損失。

logits (`torch.Tensor`、shape `(batch_size, config.num_labels)`) : SoftMax 適用前の分類スコア（config.num_labels==1 の場合は回帰スコア）。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各ステージの出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各ステージの出力におけるモデルの隠れ状態 (フィーチャマップとも呼ばれます)。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, patch_size, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

画像分類モデルの出力の基底クラス。

## ImageClassifierOutputWithNoAttention[[transformers.modeling_outputs.ImageClassifierOutputWithNoAttention]]

#### transformers.modeling_outputs.ImageClassifierOutputWithNoAttention[[transformers.modeling_outputs.ImageClassifierOutputWithNoAttention]]

```python
transformers.modeling_outputs.ImageClassifierOutputWithNoAttention(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1220)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : 分類（または config.num_labels==1 の場合は回帰）の損失。

logits (`torch.Tensor`、shape `(batch_size, config.num_labels)`) : SoftMax 適用前の分類スコア（config.num_labels==1 の場合は回帰スコア）。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各ステージの出力用 1 つ) で、形状は `(batch_size, num_channels, height, width)` です。各ステージの出力におけるモデルの隠れ状態 (feature maps とも呼ばれます)。

画像分類モデルの出力の基底クラス。

## DepthEstimatorOutput[[transformers.modeling_outputs.DepthEstimatorOutput]]

#### transformers.modeling_outputs.DepthEstimatorOutput[[transformers.modeling_outputs.DepthEstimatorOutput]]

```python
transformers.modeling_outputs.DepthEstimatorOutput(loss: typing.Optional[torch.Tensor] = None, predicted_depth: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1241)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます) : 分類（または config.num_labels==1 の場合は回帰）の損失。

predicted_depth (`torch.Tensor`、形状 `(batch_size, height, width)`) : 各ピクセルの予測深度。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, num_channels, height, width)` です。 各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, patch_size, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

深度推定モデルの出力の基底クラス。

## Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]

#### transformers.modeling_outputs.Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]

```python
transformers.modeling_outputs.Wav2Vec2BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, extract_features: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1299)

**パラメータ:**

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)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルの隠れ状態と、初期の埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

Wav2Vec2 の損失関数で訓練されたモデルの基底クラスです。

## XVectorOutput[[transformers.modeling_outputs.XVectorOutput]]

#### transformers.modeling_outputs.XVectorOutput[[transformers.modeling_outputs.XVectorOutput]]

```python
transformers.modeling_outputs.XVectorOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, embeddings: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1328)

**パラメータ:**

loss (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) : 分類損失。

logits (`torch.Tensor`、shape `(batch_size, config.xvector_output_dim)`) : AMSoftmax 適用前の分類用隠れ状態。

embeddings (`torch.Tensor`、形状 `(batch_size, config.xvector_output_dim)`) : ベクトル類似度ベースの検索に使用される発話埋め込みです。

hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル（埋め込みの出力用 1 つ + 各層の出力用 1 つ）、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルの隠れ状態と、初期の埋め込み出力です。

attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

[Wav2Vec2ForXVector](/docs/transformers/v5.23.0/ja/model_doc/wav2vec2#transformers.Wav2Vec2ForXVector)の出力型。

## Seq2SeqTSModelOutput[[transformers.modeling_outputs.Seq2SeqTSModelOutput]]

#### transformers.modeling_outputs.Seq2SeqTSModelOutput[[transformers.modeling_outputs.Seq2SeqTSModelOutput]]

```python
transformers.modeling_outputs.Seq2SeqTSModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, loc: typing.Optional[torch.Tensor] = None, scale: typing.Optional[torch.Tensor] = None, static_features: typing.Optional[torch.Tensor] = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1482)

**パラメータ:**

last_hidden_state (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`) : モデルのデコーダーの最終層の出力における、hidden-states のシーケンスです。 `past_key_values` が使用されている場合、シーケンスの最後の hidden-state のみ、shape `(batch_size, 1, hidden_size)` で出力されます。

past_key_values (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロックの key と value）が含まれます。

decoder_hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるデコーダーの隠れ状態と、任意の初期埋め込み出力です。

decoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、自己アテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(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)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力時の隠れ状態と、任意の初期埋め込み出力です。

encoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(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)`、*任意*) : 各時系列のコンテキストウィンドウのスケーリング値。モデルへの入力値を同じ大きさ（magnitude）に揃えるために使用され、その後、元の大きさに戻すために使用されます。

static_features (`torch.Tensor`、形状 `(batch_size, feature size)`、*任意*) : バッチ内の各時系列の静的特徴量。推論時に共変量にコピーされます。

時系列モデルのエンコーダー出力の基底クラスであり、シーケンシャルデコーディングを高速化できる事前計算済みヒドゥンステートも含まれます。

## Seq2SeqTSPredictionOutput[[transformers.modeling_outputs.Seq2SeqTSPredictionOutput]]

#### transformers.modeling_outputs.Seq2SeqTSPredictionOutput[[transformers.modeling_outputs.Seq2SeqTSPredictionOutput]]

```python
transformers.modeling_outputs.Seq2SeqTSPredictionOutput(loss: typing.Optional[torch.Tensor] = None, params: tuple[torch.Tensor, ...] | None = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, loc: typing.Optional[torch.Tensor] = None, scale: typing.Optional[torch.Tensor] = None, static_features: typing.Optional[torch.Tensor] = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1552)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*任意*、`future_values` が提供された場合に返されます) : 分布的損失。

params (`torch.Tensor`、形状 `(batch_size, num_samples, num_params)`) : 選択された分布のパラメータ。

past_key_values (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロックの key と value）が含まれます。

decoder_hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合はその出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、自己アテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(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)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(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)`、*任意*) : 各時系列のコンテキストウィンドウのスケーリング値。モデルへの入力値を同じ大きさ（magnitude）に揃えるために使用され、その後、元の大きさに戻すために使用されます。

static_features (`torch.Tensor`、形状 `(batch_size, feature size)`、*任意*) : バッチ内の各時系列の静的特徴量。推論時に共変量にコピーされます。

選択した分布のパラメータと損失も含まれる、時系列モデルのデコーダー出力の基底クラスです。

## SampleTSPredictionOutput[[transformers.modeling_outputs.SampleTSPredictionOutput]]

#### transformers.modeling_outputs.SampleTSPredictionOutput[[transformers.modeling_outputs.SampleTSPredictionOutput]]

```python
transformers.modeling_outputs.SampleTSPredictionOutput(sequences: typing.Optional[torch.Tensor] = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_outputs.py#L1622)

**パラメータ:**

sequences (`torch.Tensor`、shape `(batch_size, num_samples, prediction_length)` または `(batch_size, num_samples, prediction_length, input_size)`) : 選択した分布からサンプリングされた値。

選択した分布からサンプリングされた値を含む、時系列モデルの予測出力の基底クラスです。

