# 음성 인코더 디코더 모델

[SpeechEncoderDecoderModel](/docs/transformers/main/ko/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/ko/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel)을 추론에 사용하는 예시는 Speech2Text2 디코더에서 확인할 수 있습니다.

## 모델 구성에서 `SpeechEncoderDecoderModel`을 무작위로 초기화

[SpeechEncoderDecoderModel](/docs/transformers/main/ko/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel)은 인코더와 디코더의 설정을 기반으로 무작위로 초기화할 수 있습니다. 다음 예시에서는 인코더에 [Wav2Vec2Model](/docs/transformers/main/ko/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/ko/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel)은 사전 학습된 인코더 체크포인트와 사전 학습된 디코더 체크포인트로부터 초기화할 수 있습니다. 사전 학습된 Transformer 기반 음성 모델, *예를 들어* [Wav2Vec2](wav2vec2), [Hubert](hubert)는 인코더로 사용할 수 있으며, 사전 학습된 오토인코딩 모델, *예를 들어* BERT, 사전 학습된 인과 언어 모델, *예를 들어* GPT2, 그리고 시퀀스-투-시퀀스 모델의 사전 학습된 디코더 부분, *예를 들어* BART의 디코더는 디코더로 사용할 수 있습니다. 디코더로 선택하는 아키텍처에 따라 크로스 어텐션 레이어가 무작위로 초기화될 수 있습니다. [SpeechEncoderDecoderModel](/docs/transformers/main/ko/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel)을 사전 학습된 인코더와 디코더 체크포인트로부터 초기화하려면 [*Warm-starting-encoder-decoder 블로그 게시물*에서](https://huggingface.co/blog/warm-starting-encoder-decoder) 보여준 바와 같이 다운스트림 작업으로 모델이 미세 조정되어야 합니다. 이를 위해 `SpeechEncoderDecoderModel` 클래스는 [SpeechEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/main/ko/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` 클래스의 파인튜닝된 체크포인트를 로드하려면, [SpeechEncoderDecoderModel](/docs/transformers/main/ko/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel)은 Transformers의 다른 모델 아키텍처와 마찬가지로 `from_pretrained(...)` 메서드를 제공합니다.

추론을 수행하려면 `generate` 메서드를 사용합니다. 이 메서드를 사용하면 자기회귀적으로 텍스트를 생성할 수 있습니다. 이 메서드는 greedy, beam search, multinomial sampling 등 다양한 형태의 디코딩을 지원합니다.

```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 또는 기타 인코더-디코더 모델과 유사하게 파인튜닝할 수 있습니다. 손실을 계산하기 위해 모델에는 두 개의 입력만 필요합니다: `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]`, *선택*) : 인코더 백본의 config 객체 또는 사전입니다.

decoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *선택*) : 디코더 백본의 config 객체 또는 사전입니다.

이것은 Speech Encoder DecoderModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Speech Encoder Decoder 모델을 인스턴스화하고 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [](https://huggingface.co/)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/main/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/main/ko/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/ko/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)

설정 객체의 인스턴스

[SpeechEncoderDecoderConfig](/docs/transformers/main/ko/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/ko/main_classes/configuration#transformers.PreTrainedConfig), *선택 사항*) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하면 모델에 연결된 가중치가 로드되지 않고 구성만 로드됩니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

encoder (`PreTrainedModel`, *선택 사항*) : 사용할 인코더 모델입니다.

decoder (`PreTrainedModel`, *선택 사항*) : 사용할 decoder 모델입니다.

특정 헤드가 위에 없는 상태에서 원시 hidden-states를 출력하는 기본 Speech Encoder Decoder Model입니다.

이 모델은 [PreTrainedModel](/docs/transformers/main/ko/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.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = 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.Tensor] = None, input_features: typing.Optional[torch.Tensor] = 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.Tensor`, 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.Tensor` 타입의 텐서 변환을 위해 [Wav2Vec2Processor](/docs/transformers/main/ko/model_doc/wav2vec2#transformers.Wav2Vec2Processor) 또는 [Speech2TextProcessor](/docs/transformers/main/ko/model_doc/speech_to_text#transformers.Speech2TextProcessor)를 사용해야 합니다.

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`, shape `(batch_size, target_sequence_length)`, *선택 사항*) : 어휘에서 디코더 입력 시퀀스 토큰의 인덱스입니다. [PreTrainedTokenizer](/docs/transformers/main/ko/main_classes/tokenizer#transformers.PythonBackend)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/main/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/main/ko/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.Tensor]`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state` shape가 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)로 구성된 Tuple입니다. 인코더의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스로, 디코더의 cross-attention에 사용됩니다.

past_key_values (`~cache_utils.Cache`, *선택*) : 순차적 디코딩을 가속화할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)입니다. 일반적으로 `use_cache=True` 또는 `config.use_cache=True`일 때 모델이 디코딩의 이전 단계에서 반환한 `past_key_values`로 구성됩니다. 입력으로 [Cache](/docs/transformers/main/ko/internal/generation_utils#transformers.Cache) 인스턴스만 허용되며, [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. `past_key_values`가 전달되지 않으면 기본적으로 [DynamicCache](/docs/transformers/main/ko/internal/generation_utils#transformers.DynamicCache)가 초기화됩니다. 모델은 입력으로 제공된 것과 동일한 캐시 형식을 출력합니다. `past_key_values`를 사용하는 경우, 이 모델에 과거 key value 상태가 제공되지 않은 `input_ids`(처리되지 않은 항목)만 `(batch_size, unprocessed_length)` 형식으로 입력해야 하며, `(batch_size, sequence_length)` 형식의 모든 `input_ids`를 입력하지 않습니다.

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, target_sequence_length, hidden_size)`, *선택 사항*) : 선택적으로, `decoder_input_ids`를 전달하는 대신 임베딩 표현을 직접 전달할 수 있습니다. 모델의 내부 임베딩 조회 행렬보다 `decoder_input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어를 원할 때 유용합니다.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 디코더의 masked language modeling loss를 계산하기 위한 라벨. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` docstring 참조). 인덱스가 `-100`로 설정된 토큰은 무시(마스크)되며, loss는 `[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.Tensor` of shape `(batch_size, sequence_length)`, *optional*) : 입력 원시 음성 파형의 Float 값. 값은 *.flac* 또는 *.wav* 오디오 파일을 *list[float]* 또는 *numpy.ndarray* 타입의 배열로 로드하여 얻을 수 있습니다. *예를 들어*, torchcodec 라이브러리(`pip install torchcodec`) 또는 soundfile 라이브러리(`pip install soundfile`)를 통해 가능합니다. *input_values*로 배열을 준비하려면 패딩 및 *torch.Tensor* 타입의 텐서로 변환하기 위해 [Wav2Vec2Processor](/docs/transformers/main/ko/model_doc/wav2vec2#transformers.Wav2Vec2Processor)를 사용해야 합니다. 자세한 내용은 [Wav2Vec2Processor.__call__()](/docs/transformers/main/ko/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__)를 참조하세요.

input_features (`torch.Tensor`, 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/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** [Seq2SeqLMOutput](/docs/transformers/main/ko/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 또는 `tuple(torch.Tensor)`

구성([SpeechEncoderDecoderConfig](/docs/transformers/main/ko/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig))과 입력에 따라 다양한 요소를 포함하는 [Seq2SeqLMOutput](/docs/transformers/main/ko/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[SpeechEncoderDecoderModel](/docs/transformers/main/ko/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- 언어 모델링 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
- **past_key_values** (`EncoderDecoderCache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) -- [EncoderDecoderCache](/docs/transformers/main/ko/internal/generation_utils#transformers.EncoderDecoderCache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프-어텐션 블록과 크로스-어텐션 블록의 key 및 values)를 포함합니다(입력 `past_key_values` 참조).
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **decoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플이며, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **cross_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`일 때 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 인코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **encoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

예:

```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/ko/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/ko/main_classes/model#transformers.PreTrainedModel.save_pretrained)를 사용하여 저장된 모델 가중치가 포함된 *디렉터리*의 경로, 예: `./my_model_directory/`.

model_args (나머지 위치 인자, *선택 사항*) : 모든 나머지 위치 인자는 기본 모델의 `__init__` 메서드에 전달됩니다.

kwargs (남은 키워드 인수의 사전, *선택 사항*) : 구성 객체를 로드한 후 업데이트하고 모델을 초기화하는 데 사용할 수 있습니다(예: `output_attentions=True`). - 인코더 구성을 업데이트하려면 각 구성 매개변수에 *encoder_* 접두사를 사용합니다. - 디코더 구성을 업데이트하려면 각 구성 매개변수에 *decoder_* 접두사를 사용합니다. - 상위 모델 구성을 업데이트하려면 각 구성 매개변수에 접두사를 사용하지 않습니다. `config`가 제공되었는지 자동으로 로드되었는지에 따라 동작이 다릅니다.

…

`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")
```