# Модели кодировщика-декодировщика для речевых данных

Модель [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/ru/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) можно использовать для инициализации модели преобразования речи в текст с любым предобученным моделью автокодирования речи в качестве энкодера (*например* [Wav2Vec2](wav2vec2), [Hubert](hubert)) и любым предобученным авторегрессионным моделью в качестве декодера.

Эффективность инициализации моделей «речевая последовательность — текстовая последовательность» с помощью предобученных контрольных точек для распознавания речи и перевода речи, *например*, была продемонстрирована в работе [Large-Scale Self- and Semi-Supervised Learning for Speech Translation](https://huggingface.co/papers/2104.06678) авторов Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli, Alexis Conneau.

Пример использования [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/ru/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) для инференса можно найти в декодере Speech2Text2.

## Случайная инициализация `SpeechEncoderDecoderModel` из конфигураций модели

[SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/ru/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) может быть инициализирован случайным образом на основе конфигураций энкодера и декодера. В примере ниже показано, как это сделать, используя конфигурацию [Wav2Vec2Model](/docs/transformers/v5.23.0/ru/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/v5.23.0/ru/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) может быть инициализирован из предобученной контрольной точки энкодера и предобученной контрольной точки декодера. Обратите внимание, что в качестве энкодера может использоваться любая предобученная речевая модель на основе Transformer, *например* [Wav2Vec2](wav2vec2), [Hubert](hubert), а в качестве декодера — как предобученные автоэнкодерные модели, *например* BERT, предобученные каузальные языковые модели, *например* GPT2, так и предобученная часть декодера моделей последовательность-в-последовательность, *например* декодер BART. В зависимости от выбранной архитектуры декодера слои кросс-внимания могут быть инициализированы случайно. Инициализация [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/ru/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/v5.23.0/ru/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/v5.23.0/ru/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) предоставляет метод `from_pretrained(...)`, как и любая другая архитектура модели в Transformers.

Для выполнения инференса используется метод `generate`, который позволяет генерировать текст авто-регрессивно. Этот метод поддерживает различные способы декодирования, такие как жадный поиск, 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 или любой другой моделью с архитектурой «кодировщик-декодировщик» на наборе данных пар (речь, текст). Как видно, для вычисления функции потерь модели требуются только два входа: `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/v5.23.0/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]`, *необязательный*) : Объект конфигурации или словарь для декодерного бэкбона.

Это класс конфигурации для хранения конфигурации модели Speech Encoder Decoder. Он используется для создания модели Speech Encoder Decoder в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [](https://huggingface.co/)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/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/v5.23.0/src/transformers/models/speech_encoder_decoder/configuration_speech_encoder_decoder.py#L72)

**Возвращает:** [SpeechEncoderDecoderConfig](/docs/transformers/v5.23.0/ru/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)

Экземпляр объекта конфигурации

Создайте экземпляр [SpeechEncoderDecoderConfig](/docs/transformers/v5.23.0/ru/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/v5.23.0/src/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py#L54)

**Параметры:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig), *optional*) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Чтобы загрузить веса модели, обратитесь к методу [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained).

encoder (`PreTrainedModel`, *необязательный*) : Модель энкодера, которую следует использовать.

decoder (`PreTrainedModel`, *необязательный*) : Модель декодера, которую следует использовать.

Модель Speech Encoder Decoder, которая выводит необработанные скрытые состояния без какого-либо специализированного слоя наверху.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации 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/v5.23.0/src/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py#L308)

**Параметры:**

inputs (`torch.Tensor` формы `(batch_size, sequence_length)` или `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Значения типа float для входной необработанной речевой волны или речевых признаков. Значения можно получить, загрузив аудиофайл `.flac` или `.wav` в массив типа `list[float]`, `numpy.ndarray` или `torch.Tensor`, *например*, с помощью библиотеки torchcodec (`pip install torchcodec`) или библиотеки soundfile (`pip install soundfile`). Для подготовки массива в `inputs` следует использовать [Wav2Vec2Processor](/docs/transformers/v5.23.0/ru/model_doc/wav2vec2#transformers.Wav2Vec2Processor) или [Speech2TextProcessor](/docs/transformers/v5.23.0/ru/model_doc/speech_to_text#transformers.Speech2TextProcessor) для дополнения нулями (padding) и преобразования в тензор типа `torch.Tensor`.

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательно*) : Индексы токенов входной последовательности декодера в словаре. Индексы можно получить с помощью [PreTrainedTokenizer](/docs/transformers/v5.23.0/ru/main_classes/tokenizer#transformers.PythonBackend). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../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` формы `(batch_size, target_sequence_length)`, *необязательный*) : Поведение по умолчанию: генерировать тензор, игнорирующий токены заполнения в `decoder_input_ids`. Маска причинности также будет использоваться по умолчанию.

encoder_outputs (`tuple[torch.Tensor]`, *необязательный*) : Кортеж состоит из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера.

past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`.

decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, target_sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `decoder_input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `decoder_input_ids` преобразуются в соответствующие векторы, чем это делает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потерь маскированного языкового моделирования для декодера. Индексы должны находиться в диапазоне `[-100, 0, ..., config.vocab_size]` (см. docstring `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` в разделе возвращаемых тензоров.

input_values (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательно*) : Значения типа float входной необработанной звуковой волны. Значения можно получить, загрузив аудиофайл *.flac* или *.wav* в массив типа *list[float]* или *numpy.ndarray*, *например*, с помощью библиотеки torchcodec (`pip install torchcodec`) или библиотеки soundfile (`pip install soundfile`). Для подготовки массива в *input_values* следует использовать [Wav2Vec2Processor](/docs/transformers/v5.23.0/ru/model_doc/wav2vec2#transformers.Wav2Vec2Processor) для выравнивания и преобразования в тензор типа *torch.Tensor*. Подробности см. в [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/ru/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__).

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью `feature_extractor_class`. Подробности см. в `feature_extractor_class.__call__` (`processor_class` использует `feature_extractor_class` для обработки аудио).

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) или `tuple(torch.Tensor)`

Объект [Seq2SeqLMOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([SpeechEncoderDecoderConfig](/docs/transformers/v5.23.0/ru/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)) и входных данных.

Метод forward модели [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/ru/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели.
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *необязательный*, возвращается при передаче `use_cache=True` или при `config.use_cache=True`) -- это экземпляр [EncoderDecoderCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.EncoderDecoderCache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния декодера на выходе каждого слоя, а также выходные значения начального слоя встраивания.
- **decoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания декодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания кросс-внимания декодера, после применения softmax к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания.
- **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния кодировщика на выходе каждого слоя, а также выходные значения начального слоя встраиваний.
- **encoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(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/v5.23.0/src/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py#L163)

**Параметры:**

encoder_pretrained_model_name_or_path (`str`, *необязательный*) : Информация, необходимая для инициализации кодировщика. Может быть:  - строкой, *model id* предобученной модели, размещенной в репозитории моделей на huggingface.co. - путем к *каталогу*, содержащему веса модели, сохраненные с помощью [save_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.save_pretrained), например, `./my_model_directory/`.

decoder_pretrained_model_name_or_path (`str`, *необязательный*, по умолчанию `None`) : Информация, необходимая для инициализации декодера. Может быть:  - строкой, *model id* предобученной модели, размещенной в репозитории моделей на huggingface.co. - путем к *каталогу*, содержащему веса модели, сохраненные с помощью [save_pretrained()](/docs/transformers/v5.23.0/ru/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")
```