# 音声エンコーダーデコーダーモデル

[SpeechEncoderDecoderModel](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) は、事前学習済みの音声オートエンコーディングモデル（*例:* [Wav2Vec2](wav2vec2)、[Hubert](hubert) など）をエンコーダーとして、事前学習済みの自己回帰モデルをデコーダーとして使用して、音声からテキストへの変換モデルを初期化するために使用できます。

音声認識および音声翻訳において、事前学習済みチェックポイントで音声シーケンスからテキストシーケンスへのモデルを初期化する有効性は、Changhan Wang、Anne Wu、Juan Pino、Alexei Baevski、Michael Auli、Alexis Conneau による [Large-Scale Self- and Semi-Supervised Learning for Speech Translation](https://huggingface.co/papers/2104.06678) で *例えば* 示されています。

[SpeechEncoderDecoderModel](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) を推論に使用する例として、Speech2Text2 デコーダーを挙げることができます。

## モデル設定から`SpeechEncoderDecoderModel`をランダムに初期化

[SpeechEncoderDecoderModel](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) は、エンコーダーとデコーダーの設定からランダムに初期化できます。以下の例では、エンコーダーにデフォルトの [Wav2Vec2Model](/docs/transformers/main/ja/model_doc/wav2vec2#transformers.Wav2Vec2Model) 設定、デコーダーにデフォルトの `BertForCausalLM` 設定を使用して、これを行う方法を示します。

```python
from transformers import BertConfig, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel, Wav2Vec2Config

config_encoder = Wav2Vec2Config()
config_decoder = BertConfig()

config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
model = SpeechEncoderDecoderModel(config=config)
```

## 事前学習済みエンコーダーと事前学習済みデコーダーから`SpeechEncoderDecoderModel`を初期化

[SpeechEncoderDecoderModel](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) は、事前学習済みのエンコーダチェックポイントと事前学習済みのデコーダチェックポイントから初期化できます。事前学習済みの Transformer ベースの音声モデル、*例えば* [Wav2Vec2](wav2vec2) や [Hubert](hubert) はエンコーダとして使用でき、事前学習済みのオートエンコーディングモデル、*例えば* BERT、事前学習済みの因果言語モデル、*例えば* GPT2、およびシーケンスツーシーケンスモデルの事前学習済みのデコーダ部分、*例えば* BART のデコーダは、デコーダとして使用できます。デコーダとしてどのアーキテクチャを選択するかによって、クロスアテンション層がランダムに初期化される場合があります。[*Warm-starting-encoder-decoder ブログ記事*](https://huggingface.co/blog/warm-starting-encoder-decoder) に示されているように、[SpeechEncoderDecoderModel](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) を事前学習済みのエンコーダとデコーダのチェックポイントから初期化するには、下流タスクでのファインチューニングが必要です。これを行うために、`SpeechEncoderDecoderModel` クラスは [SpeechEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel.from_encoder_decoder_pretrained) メソッドを提供しています。

```python
from transformers import SpeechEncoderDecoderModel

model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
    "facebook/hubert-large-ll60k", "google-bert/bert-base-uncased"
)
```

## 既存の`SpeechEncoderDecoderModel`チェックポイントを読み込み、推論を実行する

`SpeechEncoderDecoderModel` クラスのファインチューニング済みチェックポイントを読み込むには、Transformers の他のモデルアーキテクチャと同様に、[SpeechEncoderDecoderModel](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) が `from_pretrained(...)` メソッドを提供しています。

推論を実行するには、`generate`メソッドを使用します。このメソッドにより、自己回帰的にテキストを生成できます。greedy、beam search、多項分布サンプリングなど、さまざまなデコーディング形式に対応しています。

```python
from transformers import Wav2Vec2Processor, SpeechEncoderDecoderModel
from datasets import load_dataset
import torch

# load a fine-tuned speech translation model and corresponding processor
model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15", device_map="auto")
processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")

# let's perform inference on a piece of English speech (which we'll translate to German)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").to(model.device).input_values

# autoregressively generate transcription (uses greedy decoding by default)
generated_ids = model.generate(input_values)
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(generated_text)
Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heißen zu können.
```

## トレーニング

モデルが作成されると、(音声, テキスト) のペアからなるデータセット上で、BART や T5 など他のエンコーダー・デコーダーモデルと同様にファインチューニングを行うことができます。ご覧のとおり、損失を計算するには、モデルには 2 つの入力のみが必要です: `input_values` (音声入力) と `labels` (エンコードされたターゲットシーケンスの `input_ids`) です。

```python
from datasets import load_dataset

from transformers import AutoFeatureExtractor, AutoTokenizer, SpeechEncoderDecoderModel

encoder_id = "facebook/wav2vec2-base-960h"  # acoustic model encoder
decoder_id = "google-bert/bert-base-uncased"  # text decoder

feature_extractor = AutoFeatureExtractor.from_pretrained(encoder_id)
tokenizer = AutoTokenizer.from_pretrained(decoder_id)
# Combine pre-trained encoder and pre-trained decoder to form a Seq2Seq model
model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(encoder_id, decoder_id)

model.config.decoder_start_token_id = tokenizer.cls_token_id
model.config.pad_token_id = tokenizer.pad_token_id

# load an audio input and pre-process (normalise mean/std to 0/1)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").to(model.device).input_values

# load its corresponding transcription and tokenize to generate labels
labels = tokenizer(ds[0]["text"], return_tensors="pt").to(model.device).input_ids

# the forward function automatically creates the correct decoder_input_ids
loss = model(input_values=input_values, labels=labels).loss
loss.backward()
```

## SpeechEncoderDecoderConfig[[transformers.SpeechEncoderDecoderConfig]]

#### transformers.SpeechEncoderDecoderConfig[[transformers.SpeechEncoderDecoderConfig]]

```python
transformers.SpeechEncoderDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool | None = True, encoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None, decoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speech_encoder_decoder/configuration_speech_encoder_decoder.py#L29)

**パラメータ:**

is_encoder_decoder (`bool`、*任意*、デフォルトは`True`) : モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。

encoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *省略可*) : エンコーダーのバックボーンの設定オブジェクトまたは辞書。

decoder (`Union[~configuration_utils.PreTrainedConfig, dict]`、*optional*) : デコーダーのバックボーンの設定オブジェクトまたは辞書。

これは、Speech Encoder DecoderModel の設定を保存するための設定クラスです。指定された引数に基づいて Speech Encoder Decoder モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[](https://huggingface.co/) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:

```python
>>> from transformers import BertConfig, Wav2Vec2Config, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel

>>> # Initializing a Wav2Vec2 & BERT style configuration
>>> config_encoder = Wav2Vec2Config()
>>> config_decoder = BertConfig()

>>> config = SpeechEncoderDecoderConfig(encoder=config_encoder, decoder=config_decoder)

>>> # Initializing a Wav2Vec2Bert model from a Wav2Vec2 & google-bert/bert-base-uncased style configurations
>>> model = SpeechEncoderDecoderModel(config=config)

>>> # Accessing the model configuration
>>> config_encoder = model.config.encoder
>>> config_decoder = model.config.decoder
>>> # set decoder config to causal lm
>>> config_decoder.is_decoder = True
>>> config_decoder.add_cross_attention = True

>>> # Saving the model, including its configuration
>>> model.save_pretrained("my-model")

>>> # loading model and config from pretrained folder
>>> encoder_decoder_config = SpeechEncoderDecoderConfig.from_pretrained("my-model")
>>> model = SpeechEncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)
```

#### from_encoder_decoder_configs[[transformers.SpeechEncoderDecoderConfig.from_encoder_decoder_configs]]

```python
from_encoder_decoder_configs(encoder_config: PreTrainedConfig, decoder_config: PreTrainedConfig, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speech_encoder_decoder/configuration_speech_encoder_decoder.py#L72)

**戻り値:** [SpeechEncoderDecoderConfig](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)

設定オブジェクトのインスタンス

事前学習済みエンコーダーモデルの設定とデコーダーモデルの設定から、[SpeechEncoderDecoderConfig](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)（または派生クラス）をインスタンス化します。

## SpeechEncoderDecoderModel[[transformers.SpeechEncoderDecoderModel]]

#### transformers.SpeechEncoderDecoderModel[[transformers.SpeechEncoderDecoderModel]]

```python
transformers.SpeechEncoderDecoderModel(config: transformers.configuration_utils.PreTrainedConfig | None = None, encoder: transformers.modeling_utils.PreTrainedModel | None = None, decoder: transformers.modeling_utils.PreTrainedModel | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py#L54)

**パラメータ:**

config ([PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig)、*任意*) : モデルのパラメータをすべて含むモデル設定クラス。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

encoder (`PreTrainedModel`、*任意*) : 使用するエンコーダーモデル。

decoder (`PreTrainedModel`、*任意*) : 使用するデコーダーモデル。

特定のヘッドを付加せずに生の隠れ状態を出力する、素のSpeech Encoder Decoder Model。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### forward[[transformers.SpeechEncoderDecoderModel.forward]]

```python
forward(inputs: typing.Optional[torch.FloatTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[torch.FloatTensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, input_values: typing.Optional[torch.FloatTensor] = None, input_features: typing.Optional[torch.FloatTensor] = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py#L308)

**パラメータ:**

inputs (`torch.FloatTensor`、shape `(batch_size, sequence_length)` または `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力となる生の音声波形または音声特徴量の浮動小数点値。値は、`.flac` または `.wav` のオーディオファイルを `list[float]`、`numpy.ndarray`、または `torch.Tensor` 型の配列として読み込むことで取得できます。*例えば*、torchcodec ライブラリ（`pip install torchcodec`）や soundfile ライブラリ（`pip install soundfile`）を通じて取得できます。`inputs` として配列を準備するには、パディングと `torch.FloatTensor` 型への変換のために、[Wav2Vec2Processor](/docs/transformers/main/ja/model_doc/wav2vec2#transformers.Wav2Vec2Processor) または [Speech2TextProcessor](/docs/transformers/main/ja/model_doc/speech_to_text#transformers.Speech2TextProcessor) を使用してください。

attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値:  - **マスクされない**トークンは 1、**マスクされる**トークンは 0。  [アテンションマスクとは?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : 語彙におけるデコーダー入力シーケンスのトークンインデックス。インデックスは [PreTrainedTokenizer](/docs/transformers/main/ja/main_classes/tokenizer#transformers.PythonBackend) を使用して取得できます。詳細は [PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[入力 ID とは何か？](../glossary#input-ids) `past_key_values` を使用する場合、最後の `decoder_input_ids` のみを任意で入力すれば十分です（`past_key_values` を参照）。学習時には、モデルが自動的に `decoder_input_ids` を作成します。具体的には、`labels` を右にシフトし、-100 を `pad_token_id` に置き換え、先頭に `decoder_start_token_id` を付加します。

decoder_attention_mask (`torch.BoolTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : デフォルトの動作: `decoder_input_ids`内のpadトークンを無視するテンソルを生成します。デフォルトでは、causal maskも使用されます。

encoder_outputs (`tuple[torch.FloatTensor]`, *任意*) : (`last_hidden_state`、*任意*: `hidden_states`、*任意*: `attentions`) のタプル。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、*任意* です。エンコーダーの最終層の出力における隠れ状態のシーケンスです。デコーダーのクロスアテンションで使用されます。

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

decoder_inputs_embeds (`torch.FloatTensor`、shape `(batch_size, target_sequence_length, hidden_size)`、*任意*) : `decoder_input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、`decoder_input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*optional*) : デコーダーのマスク言語モデリング損失を計算するためのラベル。インデックスは `[-100, 0, ..., config.vocab_size]` の範囲である必要があります（`input_ids` のドキュメント文字列を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲のラベルを持つトークンに対してのみ計算されます。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

input_values (`torch.FloatTensor`、shape `(batch_size, sequence_length)`、*任意*) : 入力生の音声波形の浮動小数点数値。値は、*.flac* または *.wav* 音声ファイルを *list[float]* または *numpy.ndarray* 型の配列として読み込むことで取得できます。*例えば*、torchcodec ライブラリ (`pip install torchcodec`) または soundfile ライブラリ (`pip install soundfile`) を使用します。*input_values* として配列を準備するには、パディングと *torch.FloatTensor* 型への変換のために [Wav2Vec2Processor](/docs/transformers/main/ja/model_doc/wav2vec2#transformers.Wav2Vec2Processor) を使用してください。詳細は [Wav2Vec2Processor.__call__()](/docs/transformers/main/ja/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) を参照してください。

input_features (`torch.FloatTensor`、shape `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は`feature_extractor_class`を使用して取得できます。詳細は`feature_extractor_class.__call__`を参照してください（`processor_class`は音声の処理に`feature_extractor_class`を使用します）。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [Seq2SeqLMOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) または `tuple(torch.FloatTensor)`

設定（[SpeechEncoderDecoderConfig](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)）や入力に応じて、さまざまな要素で構成される、[Seq2SeqLMOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[SpeechEncoderDecoderModel](/docs/transformers/main/ja/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失。
- **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **past_key_values** (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [EncoderDecoderCache](/docs/transformers/main/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己アテンションブロックおよびクロスアテンションブロックのキーとバリュー）が含まれます。
- **decoder_hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返される) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力における、デコーダーの隠れ状態。
- **decoder_attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

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

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*optional*) -- モデルのエンコーダーの最終層の出力における、隠れ状態のシーケンス。
- **encoder_hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力におけるエンコーダーの隠れ状態。
- **encoder_attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。

例:

```python
>>> from transformers import SpeechEncoderDecoderModel, AutoProcessor
>>> from datasets import load_dataset
>>> import torch

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
>>> model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").input_values
>>> # Inference: Translate English speech to German
>>> generated = model.generate(input_values)
>>> decoded = processor.batch_decode(generated, skip_special_tokens=True)[0]
>>> decoded
'Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heißen zu können.'

>>> # Training: Train model on English transcription
>>> labels = processor(text=ds[0]["text"], return_tensors="pt").input_ids

>>> loss = model(input_values, labels=labels).loss
>>> loss.backward()
```

#### from_encoder_decoder_pretrained[[transformers.SpeechEncoderDecoderModel.from_encoder_decoder_pretrained]]

```python
from_encoder_decoder_pretrained(encoder_pretrained_model_name_or_path: str | None = None, decoder_pretrained_model_name_or_path: str | None = None, *model_args, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py#L163)

**パラメータ:**

encoder_pretrained_model_name_or_path (`str`, *任意*) : エンコーダーを開始するために必要な情報。以下のいずれかです。 - huggingface.co のモデルリポジトリにホストされている事前学習済みモデルの *モデル ID* を示す文字列。 - [save_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.save_pretrained) を使用して保存されたモデルの重みを含む *ディレクトリ* へのパス。例: `./my_model_directory/`。

decoder_pretrained_model_name_or_path (`str`、*任意*、デフォルトは `None`) : デコーダーを開始するために必要な情報。以下のいずれかです。 - huggingface.co のモデルリポジトリにホストされている事前学習済みモデルの *モデル ID* を示す文字列。 - [save_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.save_pretrained) を使用して保存されたモデルの重みを含む *ディレクトリ* へのパス。例: `./my_model_directory/`。

model_args (残りの位置引数、*任意*) : 残りのすべての位置引数は、基盤となるモデルの `__init__` メソッドに渡されます。

kwargs （残りのキーワード引数の辞書、*任意*）: 設定オブジェクト（読み込み後）の更新とモデルの初期化に使用できます（例: `output_attentions=True`）。 - エンコーダーの設定を更新するには、各設定パラメータにプレフィックス *encoder_* を使用します。 - デコーダーの設定を更新するには、各設定パラメータにプレフィックス *decoder_* を使用します。 - 親モデルの設定を更新するには、各設定パラメータにプレフィックスを使用しません。 `config` が提供されるか、自動的に読み込まれるかによって動作が異なります。

Transformers ライブラリの1つまたは2つのベースクラスから、事前学習済みモデルのチェックポイントを使用してエンコーダーとデコーダーをインスタンス化します。

モデルはデフォルトで`model.eval()`によって評価モードに設定されています（Dropoutモジュールは無効化されます）。モデルを学習するには、まず`model.train()`で学習モードに戻す必要があります。

例:

```python
>>> from transformers import SpeechEncoderDecoderModel

>>> # initialize a wav2vec2bert from a pretrained Wav2Vec2 and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
>>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "facebook/wav2vec2-base-960h", "google-bert/bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./wav2vec2bert")
>>> # load fine-tuned model
>>> model = SpeechEncoderDecoderModel.from_pretrained("./wav2vec2bert")
```