# Modelos Encoder-Decoder de Fala

O [SpeechEncoderDecoderModel](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) pode ser usado para inicializar um modelo de fala para texto com qualquer modelo pré-treinado de auto-encodificação de fala como codificador (*por exemplo* [Wav2Vec2](wav2vec2), [Hubert](hubert)) e qualquer modelo autoregressivo pré-treinado como decodificador.

A eficácia da inicialização de modelos de sequência de fala para sequência de texto com checkpoints pré-treinados para reconhecimento de fala e tradução de fala foi, *por exemplo*, demonstrada em [Large-Scale Self- and Semi-Supervised Learning for Speech Translation](https://huggingface.co/papers/2104.06678), de Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli e Alexis Conneau.

Um exemplo de como usar um [SpeechEncoderDecoderModel](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) para inferência pode ser visto com o decodificador Speech2Text2.

## Inicializando aleatoriamente `SpeechEncoderDecoderModel` a partir de configurações de modelo

[SpeechEncoderDecoderModel](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) pode ser inicializado aleatoriamente a partir de uma configuração de encoder e uma configuração de decoder. No exemplo a seguir, mostramos como fazer isso usando a configuração padrão [Wav2Vec2Model](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Model) para o encoder e a configuração padrão `BertForCausalLM` para o decoder.

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

## Inicializando `SpeechEncoderDecoderModel` a partir de um codificador pré-treinado e um decodificador pré-treinado

[SpeechEncoderDecoderModel](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) pode ser inicializado a partir de um checkpoint pré-treinado de codificador e de um checkpoint pré-treinado de decodificador. Observe que qualquer modelo de fala baseado em Transformer pré-treinado, *por exemplo* [Wav2Vec2](wav2vec2), [Hubert](hubert) pode servir como codificador e tanto os modelos de auto-codificação pré-treinados, *por exemplo* BERT, quanto os modelos de linguagem causal pré-treinados, *por exemplo* GPT2, bem como a parte de decodificador pré-treinada de modelos de sequência para sequência, *por exemplo* decodificador do BART, podem ser usados como decodificador. Dependendo da arquitetura escolhida como decodificador, as camadas de atenção cruzada podem ser inicializadas aleatoriamente. A inicialização de [SpeechEncoderDecoderModel](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) a partir de um checkpoint de codificador e decodificador pré-treinados requer que o modelo seja ajustado em uma tarefa de nível inferior, conforme demonstrado em [o *post no blog Warm-starting-encoder-decoder*](https://huggingface.co/blog/warm-starting-encoder-decoder). Para isso, a classe `SpeechEncoderDecoderModel` fornece um método [SpeechEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/main/pt/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"
)
```

## Carregando um checkpoint existente de `SpeechEncoderDecoderModel` e executando inferência

Para carregar checkpoints ajustados da classe `SpeechEncoderDecoderModel`, o [SpeechEncoderDecoderModel](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) fornece o método `from_pretrained(...)`, assim como qualquer outra arquitetura de modelo no Transformers.

Para realizar inferência, utiliza-se o método `generate`, que permite gerar texto de forma autoregressiva. Este método suporta diversas formas de decodificação, como gulosa, busca por feixe e amostragem multinomial.

```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.
```

## Treinamento

Uma vez que o modelo é criado, ele pode ser ajustado de forma semelhante a BART, T5 ou qualquer outro modelo encoder-decoder em um conjunto de dados de pares (fala, texto). Como você pode ver, apenas 2 entradas são necessárias para o modelo calcular uma perda: `input_values` (que são as entradas de fala) e `labels` (que são os `input_ids` da sequência de destino codificada).

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

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

**Parâmetros:**

is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não.

encoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *opcional*) : O objeto de configuração ou dicionário do backbone do codificador.

decoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *opcional*) : O objeto de configuração ou dicionário do backbone do decoder.

Esta é a classe de configuração para armazenar a configuração de um Speech Encoder DecoderModel. Ela é usada para instanciar um modelo Speech Encoder Decoder de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [](https://huggingface.co/)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplos:

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

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

**Retorna:** [SpeechEncoderDecoderConfig](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)

Uma instância de um objeto de configuração

Instancie um [SpeechEncoderDecoderConfig](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig) (ou uma classe derivada) a partir de uma configuração de modelo de codificador pré-treinado e uma configuração de modelo de decodificador.

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

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

**Parâmetros:**

config ([PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig), *opcional*) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

encoder (`PreTrainedModel`, *opcional*) : O modelo de codificador a ser utilizado.

decoder (`PreTrainedModel`, *opcional*) : O modelo de decodificador a ser utilizado.

O modelo Speech Encoder Decoder puro, que produz estados ocultos brutos sem nenhum head específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

inputs (`torch.Tensor` de forma `(batch_size, sequence_length)` ou `(batch_size, sequence_length, feature_dim)`, *opcional*) : Valores em ponto flutuante da forma de onda bruta de fala de entrada ou dos recursos de fala. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `inputs`, deve-se usar o [Wav2Vec2Processor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor) ou o [Speech2TextProcessor](/docs/transformers/main/pt/model_doc/speech_to_text#transformers.Speech2TextProcessor) para o padding e a conversão em um tensor do tipo `torch.Tensor`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são input IDs?](../glossary#input-ids) Se `past_key_values` for usado, opcionalmente apenas o último `decoder_input_ids` precisa ser inserido (veja `past_key_values`). Para treinamento, `decoder_input_ids` são criados automaticamente pelo modelo deslocando `labels` para a direita, substituindo -100 por `pad_token_id` e adicionando `decoder_start_token_id` no início.

decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gerar um tensor que ignora tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão.

encoder_outputs (`tuple[torch.Tensor]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada para o decodificador. Os índices devem estar em `[-100, 0, ..., config.vocab_size]` (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio *.flac* ou *.wav* em um array do tipo *list[float]* ou um *numpy.ndarray*, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para *input_values*, o [Wav2Vec2Processor](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo *torch.Tensor*. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para mais detalhes.

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando `feature_extractor_class`. Consulte `feature_extractor_class.__call__` para mais detalhes (`processor_class` usa `feature_extractor_class` para processar áudios).

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)`

Um [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([SpeechEncoderDecoderConfig](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)) e das entradas.

O método forward do [SpeechEncoderDecoderModel](/docs/transformers/main/pt/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial.
- **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial.
- **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

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

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

**Parâmetros:**

encoder_pretrained_model_name_or_path (`str`, *opcional*) : Informações necessárias para iniciar o codificador. Pode ser:  - Uma string, o *model id* de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co. - Um caminho para um *diretório* contendo pesos de modelo salvos usando [save_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.save_pretrained), por exemplo, `./my_model_directory/`.

decoder_pretrained_model_name_or_path (`str`, *opcional*, padrão `None`) : Informações necessárias para iniciar o decodificador. Pode ser:  - Uma string, o *model id* de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co. - Um caminho para um *diretório* contendo pesos de modelo salvos usando [save_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.save_pretrained), por exemplo, `./my_model_directory/`.

model_args (argumentos posicionais restantes, *opcional*) : Todos os argumentos posicionais restantes serão passados para o método `__init__` do modelo subjacente.

kwargs (dicionário restante de argumentos por palavra-chave, *opcional*) : Pode ser usado para atualizar o objeto de configuração (após ele ser carregado) e iniciar o modelo (por exemplo, `output_attentions=True`).  - Para atualizar a configuração do encoder, use o prefixo *encoder_* para cada parâmetro de configuração. - Para atualizar a configuração do decoder, use o prefixo *decoder_* para cada parâmetro de configuração. - Para atualizar a configuração do modelo principal, não use um prefixo para cada parâmetro de configuração.  O comportamento é diferente dependendo de uma `config` ser fornecida ou carregada automaticamente.

Instancie um codificador e um decodificador a partir de uma ou duas classes base da biblioteca, usando checkpoints de modelos pré-treinados.

O modelo é definido no modo de avaliação por padrão usando `model.eval()` (os módulos Dropout são desativados). Para treinar o modelo, é necessário primeiro redefinir o modo de treinamento com `model.train()`.

Exemplo:

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