语音编码器-解码器模型

SpeechEncoderDecoderModel 可用于初始化语音转文本模型，其中任何预训练的语音自动编码模型（例如 Wav2Vec2, Hubert）作为编码器，任何预训练的自回归模型作为解码器。

使用预训练的检查点初始化语音序列到文本序列模型的有效性，用于语音识别和语音翻译的有效性已在 Large-Scale Self- and Semi-Supervised Learning for Speech Translation 中得到证明，作者是 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 需要在下游任务上对模型进行微调，正如 Warm-starting-encoder-decoder 博客文章 中所示。为此，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 提供了 from_pretrained(...) 方法，就像 Transformers 中的任何其他模型架构一样。

要执行推理，可以使用 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

配置对象的实例

从预训练的编码器模型配置和解码器模型配置实例化 SpeechEncoderDecoderConfig（或派生类）。

SpeechEncoderDecoderModel

class transformers.SpeechEncoderDecoderModel

< 源码 >

( 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 (SpeechEncoderDecoderConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

此类可用于初始化一个语音序列到文本序列模型，其中编码器可以是任何预训练的语音自动编码模型，解码器可以是任何预训练的文本自回归模型。编码器通过 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 表明，利用大型预训练语音模型进行语音翻译可以显著提高性能。

在训练/微调 Speech-Encoder Decoder 模型后，可以像任何其他模型一样保存/加载它（有关更多信息，请参阅示例）。

此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

此模型也是 PyTorch torch.nn.Module 子类。可以像常规 PyTorch 模块一样使用它，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

SpeechEncoderDecoderModel 是一个通用模型类，当使用 :meth~transformers.AutoModel.from_pretrained 类方法创建编码器和使用 :meth~transformers.AutoModelForCausalLM.from_pretrained 类方法创建解码器时，它将作为 Transformer 架构实例化，其中编码器和解码器分别使用库中的一个基础模型类。

前向传播

< 源码 >

( 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[typing.Tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[typing.Tuple[typing.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 or 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)，可选) — 掩码，用于避免在填充 token 索引上执行注意力机制。掩码值在 [0, 1] 中选择：
- 1 表示 未被掩码 的 token，
- 0 表示 被掩码 的 token。
什么是注意力掩码？
decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 解码器输入序列 token 在词汇表中的索引。

索引可以使用 PreTrainedTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？

如果使用 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 中的填充 token。默认情况下，也会使用因果掩码。
encoder_outputs (tuple(torch.FloatTensor)，可选) — 此元组必须由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成。last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) 是编码器最后一层的输出处的隐藏状态张量。在解码器的交叉注意力中使用。
past_key_values (tuple(tuple(torch.FloatTensor))，长度为 config.n_layers，每个元组有 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

如果使用 past_key_values，用户可以选择仅输入最后的 decoder_input_ids（那些没有将其过去的键值状态提供给此模型的），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
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 的 Token 将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的 Token 计算。
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，可选) — 如果设置为 True，模型将返回 ~utils.Seq2SeqLMOutput 而不是普通元组。
kwargs (可选) — 剩余的关键字参数字典。关键字参数有两种形式：
- 没有前缀的关键字参数将作为 **encoder_kwargs 输入到编码器前向函数。
- 带有 decoder_ 前缀的关键字参数将作为 **decoder_kwargs 输入到解码器前向函数。

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 (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组具有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），这些状态可用于（请参阅 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)。

解码器的注意力权重，在 attention softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的交叉注意力层的注意力权重，在 attention softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。
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)。

编码器的注意力权重，在 attention 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: str = None decoder_pretrained_model_name_or_path: str = None *model_args **kwargs )

参数

encoder_pretrained_model_name_or_path (str, 可选) — 初始化编码器所需的信息。可以是以下之一：
- 一个字符串，即托管在 huggingface.co 的模型仓库中的预训练模型的模型 ID。
- 一个目录的路径，其中包含使用 save_pretrained() 保存的模型权重，例如 ./my_model_directory/。
- 一个 tensorflow 索引检查点文件 的路径或 URL (例如, ./tf_model/model.ckpt.index)。在这种情况下，from_tf 应设置为 True，并且应提供配置对象作为 config 参数。此加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型并随后加载 PyTorch 模型要慢。
decoder_pretrained_model_name_or_path (str, 可选, 默认为 None) — 初始化解码器所需的信息。可以是以下之一：
- 一个字符串，即托管在 huggingface.co 的模型仓库中的预训练模型的模型 ID。
- 一个目录的路径，其中包含使用 save_pretrained() 保存的模型权重，例如 ./my_model_directory/。
- 一个 tensorflow 索引检查点文件 的路径或 URL (例如, ./tf_model/model.ckpt.index)。在这种情况下，from_tf 应设置为 True，并且应提供配置对象作为 config 参数。此加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型并随后加载 PyTorch 模型要慢。
model_args (剩余的位置参数, 可选) — 所有剩余的位置参数将传递给底层模型的 __init__ 方法。
kwargs (剩余的关键字参数字典, 可选) — 可用于更新配置对象 (加载后) 并初始化模型 (例如, output_attentions=True)。
- 要更新编码器配置，请为每个配置参数使用前缀 encoder_。
- 要更新解码器配置，请为每个配置参数使用前缀 decoder_。
- 要更新父模型配置，请不要为每个配置参数使用前缀。
根据是否提供 config 或自动加载 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[typing.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。

如果您希望更改模型参数的 dtype，请参阅 to_fp16() 和 to_bf16()。

此外，Large-Scale Self- and Semi-Supervised Learning for Speech Translation 表明，利用大型预训练语音模型进行语音翻译可以显著提高性能。

在训练/微调 Speech-Encoder Decoder 模型后，可以像任何其他模型一样保存/加载它（有关更多信息，请参阅示例）。

此模型继承自 FlaxPreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法 (例如下载或保存、调整输入嵌入大小、剪枝头等)。

此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax Module，并参考 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: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = 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, 可选) — 用于避免在 padding token 索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 未被掩盖 的 token，
- 0 表示 被掩盖 的 token。
什么是注意力掩码？
decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 jnp.ndarray, 可选) — 解码器输入序列 token 在词汇表中的索引。

索引可以使用 PreTrainedTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 IDs？

如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids (请参阅 past_key_values)。

对于序列到序列的训练，应提供 decoder_input_ids。 decoder_input_ids 应该在模型外部创建，方法是将 labels 向右移动，用 pad_token_id 替换 -100，并在它们前面加上 decoder_start_token_id。
decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 jnp.ndarray, 可选) — 默认行为：生成一个张量，该张量忽略 decoder_input_ids 中的 padding token。默认情况下，也将使用因果掩码。
decoder_position_ids (形状为 (batch_size, sequence_length) 的 numpy.ndarray, 可选) — 每个解码器输入序列 token 在位置嵌入中的位置索引。在范围 [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(tuple(jnp.ndarray)) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (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 时返回) — jnp.ndarray 的元组 (一个用于嵌入的输出 + 一个用于每一层的输出)，形状为 (batch_size, sequence_length, hidden_size)。

解码器在每一层输出以及初始嵌入输出的隐藏状态。
decoder_attentions (tuple(jnp.ndarray), 可选, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的注意力权重，在 attention softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(jnp.ndarray), 可选, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的交叉注意力层的注意力权重，在 attention 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 时返回) — jnp.ndarray 的元组 (一个用于嵌入的输出 + 一个用于每一层的输出)，形状为 (batch_size, sequence_length, hidden_size)。

编码器在每一层输出以及初始嵌入输出的隐藏状态。
encoder_attentions (tuple(jnp.ndarray), 可选, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

编码器的注意力权重，在 attention softmax 之后，用于计算自注意力头中的加权平均值。

FlaxSpeechEncoderDecoderModel 前向传播方法，覆盖了 __call__ 特殊方法。

示例

>>> 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 或自动加载了 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")

< > 在 GitHub 上更新