# 语音编码器-解码器模型

可以使用 [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/zh/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/v5.23.0/zh/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) 进行推理的示例，可以参考 Speech2Text2 解码器。

## 从模型配置中随机初始化`SpeechEncoderDecoderModel`

[SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/zh/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) 可以从编码器和解码器的配置中随机初始化。在下面的示例中，我们展示了如何使用编码器的默认 [Wav2Vec2Model](/docs/transformers/v5.23.0/zh/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/zh/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) 可以从预训练的编码器检查点和预训练的解码器检查点进行初始化。请注意，任何基于 Transformer 的预训练语音模型，*例如* [Wav2Vec2](wav2vec2)、[Hubert](hubert)，都可以用作编码器；而预训练的自编码模型（*例如* BERT）、预训练的因果语言模型（*例如* GPT2），以及序列到序列模型的预训练解码器部分（*例如* BART 的解码器），都可以用作解码器。根据您选择作为解码器的架构，交叉注意力层可能会被随机初始化。如[*Warm-starting-encoder-decoder 博客文章*](https://huggingface.co/blog/warm-starting-encoder-decoder)中所示，从预训练的编码器和解码器检查点初始化 [SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/zh/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) 后，需要在下游任务上对模型进行微调。为此，`SpeechEncoderDecoderModel` 类提供了 [SpeechEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/v5.23.0/zh/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/zh/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) 与 Transformers 中的其他模型架构一样，提供了 `from_pretrained(...)` 方法。

要进行推理，请使用 `generate` 方法，该方法允许你自回归地生成文本。此方法支持多种解码形式，例如贪心解码、束搜索和多项式采样。

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

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

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

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

## 训练

模型创建完成后，即可在（语音，文本）配对数据集上对其进行微调，方式与 BART、T5 或其他编码器-解码器模型类似。如您所见，模型计算损失仅需 2 个输入：`input_values`（即语音输入）和 `labels`（即编码后的目标序列的 `input_ids`）。

```python
from datasets import load_dataset

from transformers import AutoFeatureExtractor, AutoTokenizer, SpeechEncoderDecoderModel

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

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

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

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

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

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

## SpeechEncoderDecoderConfig[[transformers.SpeechEncoderDecoderConfig]]

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

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

[来源](https://github.com/huggingface/transformers/blob/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]`, *可选*) : 解码器骨干网络的配置对象或字典。

这是用于存储语音编码器-解码器模型配置的类。它根据指定的参数实例化语音编码器-解码器模型，并定义模型架构。使用默认值实例化配置将生成与 [](https://huggingface.co/) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/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/zh/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)

配置对象的实例

从预训练的编码器模型配置和解码器模型配置实例化一个 [SpeechEncoderDecoderConfig](/docs/transformers/v5.23.0/zh/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/zh/main_classes/configuration#transformers.PreTrainedConfig)，*可选*)：包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

encoder (`PreTrainedModel`，*可选*)：要使用的编码器模型。

decoder (`PreTrainedModel`，*可选*)：要使用的解码器模型。

输出原始隐藏状态、顶部未附加任何特定头部的裸语音编码器-解码器模型。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/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/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)`，*可选*) : 输入原始语音波形或语音特征的浮点值。这些值可以通过将 `.flac` 或 `.wav` 音频文件加载为 `list[float]`、`numpy.ndarray` 或 `torch.Tensor` 类型的数组来获得，*例如* 通过 torchcodec 库（`pip install torchcodec`）或 soundfile 库（`pip install soundfile`）。要将数组准备为 `inputs`，应使用 [Wav2Vec2Processor](/docs/transformers/v5.23.0/zh/model_doc/wav2vec2#transformers.Wav2Vec2Processor) 或 [Speech2TextProcessor](/docs/transformers/v5.23.0/zh/model_doc/speech_to_text#transformers.Speech2TextProcessor) 进行填充并转换为 `torch.Tensor` 类型的张量。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`，形状为 `(batch_size, target_sequence_length)`，*可选*)：解码器输入序列中各个 token 在词汇表中的索引。 可以使用 [PreTrainedTokenizer](/docs/transformers/v5.23.0/zh/main_classes/tokenizer#transformers.PythonBackend) 获取这些索引。 有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。 [什么是输入 ID？](../glossary#input-ids) 如果使用 `past_key_values`，则只需输入最后几个 `decoder_input_ids`（参见 `past_key_values`）。 在训练过程中，模型会自动通过将 `labels` 向右移位、用 `pad_token_id` 替换 -100 并在其前面添加 `decoder_start_token_id` 来创建 `decoder_input_ids`。

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/zh/internal/generation_utils#transformers.Cache) 实例作为输入，请参阅我们的 [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache)。如果未传入 `past_key_values`，则默认初始化 [DynamicCache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.DynamicCache)。 模型将输出与输入相同的缓存格式。 如果使用 `past_key_values`，则用户预期仅输入未处理的 `input_ids`（即未向此模型提供其过去键值状态的那些），其形状为 `(batch_size, unprocessed_length)`，而不是形状为 `(batch_size, sequence_length)` 的所有 `input_ids`。

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]` 范围内（参见 `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)`，*可选*) : 输入原始语音波形的浮点值。可以通过将 *.flac* 或 *.wav* 音频文件加载为 *list[float]* 或 *numpy.ndarray* 类型的数组来获取这些值，*例如* 使用 torchcodec 库（`pip install torchcodec`）或 soundfile 库（`pip install soundfile`）。要将该数组准备为 *input_values*，应使用 [Wav2Vec2Processor](/docs/transformers/v5.23.0/zh/model_doc/wav2vec2#transformers.Wav2Vec2Processor) 进行填充并转换为 *torch.Tensor* 类型的张量。有关详细信息，请参阅 [Wav2Vec2Processor.__call__()](/docs/transformers/v5.23.0/zh/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/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 或 `tuple(torch.Tensor)`

一个 [Seq2SeqLMOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[SpeechEncoderDecoderConfig](/docs/transformers/v5.23.0/zh/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig)）和输入。

[SpeechEncoderDecoderModel](/docs/transformers/v5.23.0/zh/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回) -- 语言建模损失。
- **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
- **past_key_values**（`EncoderDecoderCache`，*可选*，在传入 `use_cache=True` 或 `config.use_cache=True` 时返回）-- 它是一个 [EncoderDecoderCache](/docs/transformers/v5.23.0/zh/internal/generation_utils#transformers.EncoderDecoderCache) 实例。更多详情，请参阅我们的 [kv cache 指南](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**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`，*可选*）-- 模型编码器最后一层输出的隐藏状态序列。
- **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`, *可选*) : 启动编码器所需的信息。可以是： - 一个字符串，即托管在 huggingface.co 模型仓库中的预训练模型的 *model id*。 - 一个指向 *目录* 的路径，该目录包含使用 [save_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.save_pretrained) 保存的模型权重，例如 `./my_model_directory/`。

decoder_pretrained_model_name_or_path (`str`, *可选*, 默认为 `None`) : 启动解码器所需的信息。可以是以下之一： - 一个字符串，即托管在 huggingface.co 模型仓库中的预训练模型的 *model id*。 - 一个 *目录* 的路径，其中包含使用 [save_pretrained()](/docs/transformers/v5.23.0/zh/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")
```

