# Modelos de codificador-decodificador de voz

El [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) se puede utilizar para inicializar un modelo de voz a texto con cualquier modelo de autoencoding de voz preentrenado como codificador (*p. ej.* [Wav2Vec2](wav2vec2), [Hubert](hubert)) y cualquier modelo autoregresivo preentrenado como decodificador.

La eficacia de la inicialización de modelos de secuencia de voz a secuencia de texto con puntos de control preentrenados para el reconocimiento de voz y la traducción de voz se ha demostrado, *por ejemplo*, en [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 y Alexis Conneau.

Un ejemplo de cómo usar un [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) para la inferencia se puede ver con el decodificador de Speech2Text2.

## Inicialización aleatoria de `SpeechEncoderDecoderModel` a partir de configuraciones de modelo

[SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) se puede inicializar aleatoriamente a partir de la configuración de un codificador y un decodificador. En el siguiente ejemplo, se muestra cómo hacerlo utilizando la configuración predeterminada de [Wav2Vec2Model](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Model) para el codificador y la configuración predeterminada de `BertForCausalLM` para el decodificador.

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

## Inicialización de `SpeechEncoderDecoderModel` a partir de un codificador preentrenado y un decodificador preentrenado

[SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) se puede inicializar a partir de un checkpoint preentrenado del codificador y un checkpoint preentrenado del decodificador. Tenga en cuenta que cualquier modelo de voz basado en Transformers preentrenado, *por ejemplo* [Wav2Vec2](wav2vec2) o [Hubert](hubert), puede servir como codificador, y tanto los modelos auto-encoding preentrenados, *por ejemplo* BERT, como los modelos de lenguaje causales preentrenados, *por ejemplo* GPT2, así como la parte de decodificador preentrenada de los modelos de secuencia a secuencia, *por ejemplo* el decodificador de BART, pueden usarse como decodificador. Dependiendo de la arquitectura que elija como decodificador, las capas de atención cruzada podrían inicializarse aleatoriamente. Inicializar [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) a partir de un checkpoint preentrenado del codificador y del decodificador requiere que el modelo se ajuste fino en una tarea descendente, como se muestra en [la *publicación de blog Warm-starting-encoder-decoder*](https://huggingface.co/blog/warm-starting-encoder-decoder). Para ello, la clase `SpeechEncoderDecoderModel` proporciona el método [SpeechEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/v5.23.0/es/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"
)
```

## Cargar un punto de control existente de `SpeechEncoderDecoderModel` y realizar inferencia

Para cargar puntos de control afinados de la clase `SpeechEncoderDecoderModel`, [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) proporciona el método `from_pretrained(...)` al igual que cualquier otra arquitectura de modelo en Transformers.

Para realizar la inferencia, se utiliza el método `generate`, que permite generar texto de forma autoregresiva. Este método admite diversas formas de decodificación, como la búsqueda codiciosa, la búsqueda por haces y la muestreo 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.
```

## Entrenamiento

Una vez que se crea el modelo, se puede ajustar de forma similar a BART, T5 o cualquier otro modelo encoder-decoder en un conjunto de datos de pares (voz, texto). Como puede ver, el modelo solo requiere 2 entradas para calcular una pérdida: `input_values` (que son las entradas de voz) y `labels` (que son los `input_ids` de la secuencia objetivo 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)
```

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

**Parámetros:**

is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no.

encoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *opcional*) : El objeto de configuración o el diccionario del backbone del codificador.

decoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *opcional*) : El objeto de configuración o el diccionario del backbone del decodificador.

Esta es la clase de configuración para almacenar la configuración de un modelo Speech Encoder Decoder. Se utiliza para instanciar un modelo Speech Encoder Decoder según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [](https://huggingface.co/)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplos:

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

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

**Devuelve:** [SpeechEncoderDecoderConfig](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)

Una instancia de un objeto de configuración

Instancie una [SpeechEncoderDecoderConfig](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig) (o una clase derivada) a partir de la configuración de un modelo codificador preentrenado y la configuración de un modelo 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)
```

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

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig), *opcional*) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

encoder (`PreTrainedModel`, *opcional*) : El modelo codificador a utilizar.

decoder (`PreTrainedModel`, *opcional*) : El modelo decodificador a utilizar.

El modelo Speech Encoder Decoder básico que genera estados ocultos sin ningún cabezal específico en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

**Parámetros:**

inputs (`torch.Tensor` de forma `(batch_size, sequence_length)` o `(batch_size, sequence_length, feature_dim)`, *opcional*) : Valores en coma flotante de la forma de onda de voz cruda de entrada o de las características de voz. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array en `inputs`, se debe utilizar [Wav2Vec2Processor](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor) o [Speech2TextProcessor](/docs/transformers/v5.23.0/es/model_doc/speech_to_text#transformers.Speech2TextProcessor) para el relleno y la conversión en un tensor de tipo `torch.Tensor`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener mediante [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los input IDs?](../glossary#input-ids) Si se utiliza `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_input_ids` (consulte `past_key_values`). Para el entrenamiento, `decoder_input_ids` se crean automáticamente por el modelo desplazando `labels` hacia la derecha, reemplazando -100 por `pad_token_id` y añadiendo `decoder_start_token_id` al principio.

decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada.

encoder_outputs (`tuple[torch.Tensor]`, *opcional*) : La tupla consiste en (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la cross-attention del decodificador.

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `decoder_input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `decoder_input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado del decodificador. Los índices deben estar en `[-100, 0, ..., config.vocab_size]` (ver la docstring de `input_ids`). Los tokens con índices establecidos en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores en coma flotante de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio *.flac* o *.wav* en un array de tipo *list[float]* o un *numpy.ndarray*, *por ejemplo*, mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como *input_values*, se debe utilizar [Wav2Vec2Processor](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor) para el relleno y la conversión a un tensor de tipo *torch.Tensor*. Consulte [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) para más detalles.

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando `feature_extractor_class`. Consulte `feature_extractor_class.__call__` para más detalles (`processor_class` utiliza `feature_extractor_class` para procesar audios).

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) o `tuple(torch.Tensor)`

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([SpeechEncoderDecoderConfig](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)) y las entradas.

El método forward de [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/es/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del decodificador en la salida de cada capa más las salidas de la incrustación inicial.
- **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial.
- **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

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

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

**Parámetros:**

encoder_pretrained_model_name_or_path (`str`, *opcional*) : Información necesaria para iniciar el codificador. Puede ser:  - Una cadena de texto, el *model id* de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co. - Una ruta a un *directorio* que contiene los pesos del modelo guardados con [save_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.save_pretrained), por ejemplo, `./my_model_directory/`.

decoder_pretrained_model_name_or_path (`str`, *opcional*, valor predeterminado `None`) : Información necesaria para iniciar el decodificador. Puede ser:  - Una cadena de texto, el *model id* de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co. - Una ruta a un *directorio* que contiene los pesos del modelo guardados con [save_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.save_pretrained), por ejemplo, `./my_model_directory/`.

model_args (argumentos posicionales restantes, *opcional*) : Todos los argumentos posicionales restantes se pasarán al método `__init__` del modelo subyacente.

kwargs (resto del diccionario de argumentos de palabras clave, *opcional*) : Se puede utilizar para actualizar el objeto de configuración (después de ser cargado) e iniciar el modelo (p. ej., `output_attentions=True`).  - Para actualizar la configuración del codificador, use el prefijo *encoder_* para cada parámetro de configuración. - Para actualizar la configuración del decodificador, use el prefijo *decoder_* para cada parámetro de configuración. - Para actualizar la configuración del modelo principal, no use un prefijo para cada parámetro de configuración.  Se comporta de manera diferente dependiendo de si se proporciona un `config` o se carga automáticamente.

Instancia un codificador y un decodificador a partir de una o dos clases base de la biblioteca desde puntos de control de modelos preentrenados.

El modelo se establece en modo de evaluación de forma predeterminada mediante `model.eval()` (los módulos Dropout se desactivan). Para entrenar el modelo, primero debe volver a establecerlo en modo de entrenamiento con `model.train()`.

Ejemplo:

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

