Transformers 文档
语音编码器-解码器模型
并获得增强的文档体验
开始使用
语音编码器-解码器模型
`SpeechEncoderDecoderModel` 可以用于初始化一个语音到文本模型，其中任意预训练的语音自编码模型（例如 Wav2Vec2、Hubert）作为编码器，任意预训练的自回归模型作为解码器。
在 Changhan Wang、Anne Wu、Juan Pino、Alexei Baevski、Michael Auli、Alexis Conneau 的论文 《大型自监督和半监督语音翻译学习》 中，展示了使用预训练检查点初始化语音序列到文本序列模型进行语音识别和语音翻译的有效性。
有关如何使用 `SpeechEncoderDecoderModel` 进行推理的示例，请参见 Speech2Text2。
从模型配置随机初始化 SpeechEncoderDecoderModel。
`SpeechEncoderDecoderModel` 可以从编码器和解码器配置中随机初始化。在以下示例中，我们将演示如何使用编码器的默认 `Wav2Vec2Model` 配置和解码器的默认 `BertForCausalLM` 配置来完成此操作。
>>> from transformers import BertConfig, Wav2Vec2Config, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel
>>> config_encoder = Wav2Vec2Config()
>>> config_decoder = BertConfig()
>>> config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
>>> model = SpeechEncoderDecoderModel(config=config)从预训练编码器和预训练解码器初始化 SpeechEncoderDecoderModel。
`SpeechEncoderDecoderModel` 可以从预训练的编码器检查点和预训练的解码器检查点进行初始化。请注意，任何基于 Transformer 的预训练语音模型（例如 Wav2Vec2、Hubert）都可以作为编码器，而预训练的自编码模型（例如 BERT）、预训练的因果语言模型（例如 GPT2）以及序列到序列模型的预训练解码器部分（例如 BART 的解码器）都可以用作解码器。根据您选择的解码器架构，交叉注意力层可能会随机初始化。从预训练的编码器和解码器检查点初始化 `SpeechEncoderDecoderModel` 需要在下游任务上进行微调，如 《热启动编码器-解码器博客文章》 所示。为此，`SpeechEncoderDecoderModel` 类提供了 `SpeechEncoderDecoderModel.from_encoder_decoder_pretrained()` 方法。
>>> from transformers import SpeechEncoderDecoderModel
>>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
... "facebook/hubert-large-ll60k", "google-bert/bert-base-uncased"
... )加载现有 SpeechEncoderDecoderModel 检查点并执行推理。
要加载 `SpeechEncoderDecoderModel` 类的微调检查点，`SpeechEncoderDecoderModel` 提供了与 Transformers 中任何其他模型架构一样的 `from_pretrained(...)` 方法。
要执行推理，可以使用 `generate` 方法，该方法允许自回归生成文本。此方法支持各种解码形式，例如贪婪解码、束搜索和多项式采样。
>>> 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")
>>> 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").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`）。
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, SpeechEncoderDecoderModel
>>> from datasets import load_dataset
>>> 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").input_values
>>> # load its corresponding transcription and tokenize to generate labels
>>> labels = tokenizer(ds[0]["text"], return_tensors="pt").input_ids
>>> # the forward function automatically creates the correct decoder_input_ids
>>> loss = model(input_values=input_values, labels=labels).loss
>>> loss.backward()SpeechEncoderDecoderConfig
class transformers.SpeechEncoderDecoderConfig
< source >( **kwargs )
参数
- kwargs (可选) — 关键字参数字典。特别地：
- encoder (`PretrainedConfig`, 可选) — 定义编码器配置的配置对象实例。
- decoder (`PretrainedConfig`, 可选) — 定义解码器配置的配置对象实例。
`SpeechEncoderDecoderConfig` 是用于存储 `SpeechEncoderDecoderModel` 配置的配置类。它用于根据指定参数实例化编码器-解码器模型，定义编码器和解码器配置。
配置对象继承自 `PretrainedConfig`，可用于控制模型输出。有关更多信息，请阅读 `PretrainedConfig` 的文档。
示例
>>> from transformers import BertConfig, Wav2Vec2Config, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel
>>> # Initializing a Wav2Vec2 & BERT style configuration
>>> config_encoder = Wav2Vec2Config()
>>> config_decoder = BertConfig()
>>> config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, 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
< source >( encoder_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → SpeechEncoderDecoderConfig
从预训练编码器模型配置和解码器模型配置实例化 `SpeechEncoderDecoderConfig`（或派生类）。
SpeechEncoderDecoderModel
class transformers.SpeechEncoderDecoderModel
< source >( config: typing.Optional[transformers.configuration_utils.PretrainedConfig] = None encoder: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None decoder: typing.Optional[transformers.modeling_utils.PreTrainedModel] = None )
参数
- config (`PretrainedConfig`, 可选) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查阅 `from_pretrained()` 方法以加载模型权重。
- encoder (
PreTrainedModel, 可选) — 要使用的编码器模型。 - decoder (
PreTrainedModel, 可选) — 要使用的解码器模型。
纯粹的语音编码器-解码器模型，输出原始隐藏状态，不带任何特定的头部层。
该模型继承自 `PreTrainedModel`。请查阅超类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
该模型也是 PyTorch `torch.nn.Module` 的子类。请将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档中所有与通用用法和行为相关的内容。
前向传播
< source >( inputs: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None encoder_outputs: typing.Optional[tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None input_values: typing.Optional[torch.FloatTensor] = None input_features: typing.Optional[torch.FloatTensor] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- inputs (
torch.FloatTensor，形状为(batch_size, sequence_length)或(batch_size, sequence_length, feature_dim)，可选) — 输入原始语音波形或语音特征的浮点值。值可以通过加载 `.flac` 或 `.wav` 音频文件到 `list[float]` 或 `numpy.ndarray` 类型的数组中获得，例如通过 soundfile 库（`pip install soundfile`）。要将数组准备成 `inputs`，应使用 `Wav2Vec2Processor` 或 `Speech2TextProcessor` 进行填充和转换为 `torch.FloatTensor` 类型张量。 - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 遮罩以避免在填充标记索引上执行注意力。遮罩值在 `[0, 1]` 中选择：- 1 表示**未被遮罩**的标记，
- 0 表示**被遮罩**的标记。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 解码器输入序列中词汇表标记的索引。索引可以使用 `PreTrainedTokenizer` 获取。有关详细信息，请参见 `PreTrainedTokenizer.encode()` 和 `PreTrainedTokenizer.__call__()`。
如果使用了 `past_key_values`，可选地只需输入最后的 `decoder_input_ids`（那些没有将过去的键值状态传递给此模型的）形状为 `(batch_size, 1)`，而不是所有 `input_ids` 形状为 `(batch_size, sequence_length)`。
对于训练，`decoder_input_ids` 由模型通过将 `labels` 右移，用 `pad_token_id` 替换 -100，并在其前面添加 `decoder_start_token_id` 自动创建。
- decoder_attention_mask (
torch.BoolTensor，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 `decoder_input_ids` 中填充标记的张量。默认情况下也将使用因果遮罩。 - encoder_outputs (
tuple[torch.FloatTensor], 可选) — 元组由（`last_hidden_state`，可选：`hidden_states`，可选：`attentions`）组成。`last_hidden_state` 的形状为 `(batch_size, sequence_length, hidden_size)`，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - past_key_values (
tuple[tuple[torch.FloatTensor]], 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码前一阶段返回的 `past_key_values`，当 `use_cache=True` 或 `config.use_cache=True` 时。允许两种格式：
- `Cache` 实例，请参阅我们的 kv 缓存指南；
- 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组，每个元组包含 2 个形状为 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的张量）。这也被称为传统缓存格式。
模型将输出与输入相同的缓存格式。如果未传递 `past_key_values`，将返回传统缓存格式。
如果使用 `past_key_values`，用户可以选择只输入最后一个 `input_ids`（那些没有将过去的键值状态提供给此模型的），其形状为 `(batch_size, 1)`，而不是所有 `input_ids` 的形状为 `(batch_size, sequence_length)`。
- decoder_inputs_embeds (
torch.FloatTensor，形状为(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.FloatTensor，形状为(batch_size, sequence_length)，可选) — 输入原始语音波形的浮点值。这些值可以通过加载 `.flac` 或 `.wav` 音频文件到 `list[float]` 或 `numpy.ndarray` 类型的数组中获得，例如通过 soundfile 库（`pip install soundfile`）。要将数组准备成 `input_values`，应使用 `Wav2Vec2Processor` 进行填充和转换为 `torch.FloatTensor` 类型的张量。有关详细信息，请参见 `Wav2Vec2Processor.__call__()`。 - input_features (
torch.FloatTensor，形状为(batch_size, sequence_length, feature_size)，可选) — 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过加载 `.flac` 或 `.wav` 音频文件到 `list[float]` 或 `numpy.ndarray` 类型的数组中获得，例如通过 soundfile 库（`pip install soundfile`）。要将数组准备成 `input_features`，应使用 `Speech2TextFeatureExtractor` 来提取 fbank 特征、填充并转换为 `torch.FloatTensor` 类型的张量。请参阅 `__call__()` - return_dict (
bool, 可选) — 是否返回 `ModelOutput` 而不是普通元组。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 `transformers.modeling_outputs.Seq2SeqLMOutput` 或一个 `torch.FloatTensor` 元组（如果传递了 `return_dict=False` 或 `config.return_dict=False`），包含根据配置 (`SpeechEncoderDecoderConfig`) 和输入的不同元素。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
past_key_values (
EncoderDecoderCache, 可选, 当 `use_cache=True` 或 `config.use_cache=True` 时返回) — 这是一个 `EncoderDecoderCache` 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — `torch.FloatTensor` 的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为 `(batch_size, sequence_length, hidden_size)`。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可选, 当 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — `torch.FloatTensor` 的元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(torch.FloatTensor), 可选, 当 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — `torch.FloatTensor` 的元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — `torch.FloatTensor` 的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为 `(batch_size, sequence_length, hidden_size)`。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可选, 当 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — `torch.FloatTensor` 的元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
`SpeechEncoderDecoderModel` 的前向传播方法，覆盖了 `__call__` 特殊方法。
尽管前向传播的配方需要在该函数中定义，但随后应调用 `Module` 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。
示例
>>> 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
< source >( encoder_pretrained_model_name_or_path: typing.Optional[str] = None decoder_pretrained_model_name_or_path: typing.Optional[str] = None *model_args **kwargs )
参数
- encoder_pretrained_model_name_or_path (
str, 可选) — 初始化编码器所需的信息。可以是以下之一：- 一个字符串，是托管在 huggingface.co 上模型仓库中的预训练模型的模型 ID。
- 一个目录的路径，其中包含使用 `save_pretrained()` 保存的模型权重，例如 `./my_model_directory/`。
- 一个tensorflow 索引检查点文件（例如 `./tf_model/model.ckpt.index`）的路径或 URL。在这种情况下，`from_tf` 应设置为 `True`，并且应提供一个配置对象作为 `config` 参数。这种加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型，然后再加载 PyTorch 模型要慢。
- decoder_pretrained_model_name_or_path (
str, 可选, 默认为 `None`) — 初始化解码器所需的信息。可以是以下之一：- 一个字符串，是托管在 huggingface.co 上模型仓库中的预训练模型的模型 ID。
- 一个目录的路径，其中包含使用 `save_pretrained()` 保存的模型权重，例如 `./my_model_directory/`。
- 一个tensorflow 索引检查点文件（例如 `./tf_model/model.ckpt.index`）的路径或 URL。在这种情况下，`from_tf` 应设置为 `True`，并且应提供一个配置对象作为 `config` 参数。这种加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型，然后再加载 PyTorch 模型要慢。
- model_args (剩余位置参数，可选) — 所有剩余位置参数将传递给底层模型的 `__init__` 方法。
- kwargs (剩余关键字参数字典，可选) — 可用于更新配置对象（加载后）并初始化模型（例如，`output_attentions=True`）。
- 要更新编码器配置，请为每个配置参数使用前缀 encoder_。
- 要更新解码器配置，请为每个配置参数使用前缀 decoder_。
- 要更新父模型配置，请不要为每个配置参数使用前缀。
根据是否提供 `config` 或自动加载而行为不同。
从库的一个或两个基类实例化一个编码器和一个解码器，这些基类来自预训练的模型检查点。
模型默认使用 model.eval() 设置为评估模式（Dropout 模块已停用）。要训练模型，您需要首先使用 model.train() 将其设置回训练模式。
示例
>>> 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")FlaxSpeechEncoderDecoderModel
class transformers.FlaxSpeechEncoderDecoderModel
< source >( config: SpeechEncoderDecoderConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (SpeechEncoderDecoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。请查阅 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype, 可选, 默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16(在 GPU 上) 和jax.numpy.bfloat16(在 TPU 上) 之一。这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算将以给定的
dtype执行。请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。
此类可用于初始化语音序列到文本序列的模型，其中任何预训练的语音自编码模型作为编码器，任何预训练的文本自回归模型作为解码器。编码器通过 from_pretrained() 函数加载，解码器通过 from_pretrained() 函数加载。交叉注意力层会自动添加到解码器中，并且应该在下游生成任务（如摘要）上进行微调。
Sascha Rothe、Shashi Narayan、Aliaksei Severyn、Michael Matena、Yanqi Zhou、Wei Li、Peter J. Liu 在 Leveraging Pre-trained Checkpoints for Sequence Generation Tasks 中展示了使用预训练检查点初始化序列到序列模型在序列生成任务中的有效性。
此外，在 Large-Scale Self- and Semi-Supervised Learning for Speech Translation 中展示了如何利用大型预训练语音模型进行语音翻译可以显著提高性能。
此类语音编码器-解码器模型经过训练/微调后，可以像任何其他模型一样保存/加载（更多信息请参阅示例）。
该模型继承自 FlaxPreTrainedModel。查阅超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）
该模型也是 Flax Linen flax.nn.Module 的子类。将其作为常规 Flax 模块使用，并参考 Flax 文档了解所有与一般用法和行为相关的事项。
FlaxSpeechEncoderDecoderModel 是一个通用模型类，当使用 :meth~transformers.FlaxAutoModel.from_pretrained 类方法用于编码器和 :meth~transformers.FlaxAutoModelForCausalLM.from_pretrained 类方法用于解码器创建时，它将被实例化为一个 Transformer 架构，其中包含库中一个基础模型类的模块 (flax.nn.Module) 作为编码器模块，另一个作为解码器模块。
__call__
< source >( inputs: Array attention_mask: typing.Optional[jax.Array] = None decoder_input_ids: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False freeze_feature_encoder: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- inputs (形状为
(batch_size, sequence_length)或(batch_size, sequence_length, feature_dim)的jnp.ndarray, 可选) — 输入原始语音波形或语音特征的浮点值。可以通过将.flac或.wav音频文件加载到list[float]类型的数组或numpy.ndarray中来获取这些值，例如通过 soundfile 库（pip install soundfile）。为了将数组准备到inputs中，应使用 Wav2Vec2Processor 或 Speech2TextProcessor 进行填充和转换为torch.FloatTensor类型的张量。 - attention_mask (形状为
(batch_size, sequence_length)的jnp.ndarray, 可选) — 避免对填充标记索引执行注意力的掩码。掩码值选择在[0, 1]之间：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的jnp.ndarray, 可选) — 解码器输入序列标记在词汇表中的索引。索引可以使用 PreTrainedTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，可以选择只输入最后一个decoder_input_ids（请参阅past_key_values）。对于序列到序列训练，应提供
decoder_input_ids。decoder_input_ids应在模型外部创建，方法是将labels右移，将 -100 替换为pad_token_id，并在其前面添加decoder_start_token_id。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的jnp.ndarray, 可选) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认情况下也将使用因果掩码。 - decoder_position_ids (形状为
(batch_size, sequence_length)的numpy.ndarray, 可选) — 每个解码器输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.decoder.max_position_embeddings - 1]。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 如果设置为True，模型将返回一个~utils.FlaxSeq2SeqLMOutput而不是一个普通的元组。
返回
transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（SpeechEncoderDecoderConfig）和输入而异的各种元素。
-
logits (形状为
(batch_size, sequence_length, config.vocab_size)的jnp.ndarray) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组包含两个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和两个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的额外张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出 + 一个用于每层输出）。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的jnp.ndarray，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出 + 一个用于每层输出）。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
FlaxSpeechEncoderDecoderModel 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的配方需要在该函数中定义，但随后应调用 `Module` 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。
示例
>>> from transformers import FlaxSpeechEncoderDecoderModel, AutoTokenizer
>>> # load a fine-tuned wav2vec2-2-bart model
>>> model = FlaxSpeechEncoderDecoderModel.from_pretrained("patrickvonplaten/wav2vec2-2-bart-large")
>>> # load output tokenizer
>>> tokenizer_output = AutoTokenizer.from_pretrained("facebook/bart-large")
>>> inputs = jnp.ones((2, 5000), dtype=jnp.float32)
>>> # use bart's special bos, pad and eos tokens
>>> model.config.decoder_start_token_id = model.decoder.config.bos_token_id
>>> model.config.pad_token_id = model.decoder.config.pad_token_id
>>> model.config.eos_token_id = model.decoder.config.eos_token_id
>>> outputs = model.generate(inputs)
# Assert something? More interesting input? dtype correct?from_encoder_decoder_pretrained
< source >( encoder_pretrained_model_name_or_path: typing.Union[str, os.PathLike, NoneType] = None decoder_pretrained_model_name_or_path: typing.Union[str, os.PathLike, NoneType] = None *model_args **kwargs )
参数
- encoder_pretrained_model_name_or_path (
Union[str, os.PathLike], 可选) — 初始化编码器所需的信息。可以是以下之一：- 一个字符串，huggingface.co 上模型仓库中预训练模型的*模型 ID*。
- 一个目录的路径，该目录包含使用 save_pretrained() 保存的模型权重，例如
./my_model_directory/。
- decoder_pretrained_model_name_or_path (
Union[str, os.PathLike], 可选, 默认为None) — 初始化解码器所需的信息。可以是以下之一：- 一个字符串，huggingface.co 上模型仓库中预训练模型的*模型 ID*。
- 一个目录的路径，该目录包含使用 save_pretrained() 保存的模型权重，例如
./my_model_directory/。
- model_args (剩余位置参数，可选) — 所有剩余的位置参数将传递给底层模型的
__init__方法。 - kwargs (剩余的关键字参数字典，可选) — 可用于更新配置对象（加载后）并初始化模型（例如，
output_attentions=True）。- 要更新编码器配置，请为每个配置参数使用前缀 encoder_。
- 要更新解码器配置，请为每个配置参数使用前缀 decoder_。
- 要更新父模型配置，请不要为每个配置参数使用前缀。
行为因是否提供了
config或自动加载而异。
从库的一个或两个基类实例化一个编码器和一个解码器，这些基类来自预训练的模型检查点。
示例
>>> from transformers import FlaxSpeechEncoderDecoderModel
>>> # initialize a wav2vec2-2-bart from pretrained wav2vec2 and bart models. Note that the cross-attention layers will be randomly initialized
>>> model = FlaxSpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
... "facebook/wav2vec2-large-lv60", "facebook/bart-large"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./wav2vec2-2-bart-large")
>>> # load fine-tuned model
>>> model = FlaxSpeechEncoderDecoderModel.from_pretrained("./wav2vec2-2-bart-large")