Transformers 4.37 中文文档（七十七）

原文：huggingface.co/docs/transformers

SeamlessM4T-v2

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/seamless_m4t_v2

概述

SeamlessM4T-v2 模型是由 Meta AI 的 Seamless Communication 团队在Seamless: Multilingual Expressive and Streaming Speech Translation中提出的。

SeamlessM4T-v2 是一系列旨在提供高质量翻译的模型，使来自不同语言社区的人们能够通过语音和文本轻松交流。这是对先前版本的改进。有关 v1 和 v2 之间的差异的更多详细信息，请参阅与 SeamlessM4T-v1 的差异部分。

SeamlessM4T-v2 实现多个任务，无需依赖单独的模型：

• 语音到语音翻译（S2ST）
• 语音到文本翻译（S2TT）
• 文本到语音翻译（T2ST）
• 文本到文本翻译（T2TT）
• 自动语音识别（ASR）

SeamlessM4Tv2Model 可以执行上述所有任务，但每个任务也有自己专用的子模型。

论文摘要如下：

自动语音翻译的最新进展已经大大扩展了语言覆盖范围，改进了多模态功能，并实现了广泛的任务和功能。尽管如此，今天的大规模自动语音翻译系统缺乏与人与人对话相比帮助机器中介通信感觉无缝的关键功能。在这项工作中，我们介绍了一系列模型，这些模型能够以流式方式实现端到端的表达和多语言翻译。首先，我们贡献了一个改进版本的大规模多语言和多模态 SeamlessM4T 模型—SeamlessM4T v2。这个更新的模型采用了更新的 UnitY2 框架，训练了更多的低资源语言数据。扩展版本的 SeamlessAlign 增加了 114,800 小时的自动对齐数据，涵盖了 76 种语言。SeamlessM4T v2 为我们的两个最新模型 SeamlessExpressive 和 SeamlessStreaming 提供了基础。SeamlessExpressive 实现了保留语音风格和韵律的翻译。与以往在表达性语音研究中的努力相比，我们的工作解决了一些未充分探索的韵律方面，如语速和停顿，同时也保留了个人声音的风格。至于 SeamlessStreaming，我们的模型利用了高效单调多头注意力（EMMA）机制，生成低延迟的目标翻译，无需等待完整的源话语。作为首创，SeamlessStreaming 实现了多源和目标语言的同时语音到语音/文本翻译。为了了解这些模型的性能，我们结合了新颖和修改过的现有自动度量标准的版本，以评估韵律、延迟和稳健性。对于人类评估，我们改编了现有的旨在衡量保留意义、自然性和表现力最相关属性的协议。为了确保我们的模型可以安全和负责任地使用，我们实施了已知的第一个多模态机器翻译红队行动，一个用于检测和减轻添加毒性的系统，一个系统性评估性别偏见，以及一个设计用于减轻深度伪造影响的不可听见的本地化水印机制。因此，我们将 SeamlessExpressive 和 SeamlessStreaming 的主要组件结合起来，形成了 Seamless，这是第一个公开可用的系统，可以实时解锁具有表现力的跨语言交流。总的来说，Seamless 为我们提供了将通用语音翻译器从科幻概念变成现实技术所需的技术基础的关键视角。最后，这项工作中的贡献，包括模型、代码和水印检测器，已经公开发布并可在下面的链接中访问。

用法

在以下示例中，我们将加载一个阿拉伯语音样本和一个英文文本样本，并将它们转换为俄语语音和法语文本。

首先，加载处理器和模型的检查点：

代码语言：javascript复制

>>> from transformers import AutoProcessor, SeamlessM4Tv2Model

>>> processor = AutoProcessor.from_pretrained("facebook/seamless-m4t-v2-large")
>>> model = SeamlessM4Tv2Model.from_pretrained("facebook/seamless-m4t-v2-large")

您可以无缝地在文本或音频上使用这个模型，生成翻译文本或翻译音频。

以下是如何使用处理器处理文本和音频的方法：

代码语言：javascript复制

>>> # let's load an audio sample from an Arabic speech corpus
>>> from datasets import load_dataset
>>> dataset = load_dataset("arabic_speech_corpus", split="test", streaming=True)
>>> audio_sample = next(iter(dataset))["audio"]

>>> # now, process it
>>> audio_inputs = processor(audios=audio_sample["array"], return_tensors="pt")

>>> # now, process some English text as well
>>> text_inputs = processor(text = "Hello, my dog is cute", src_lang="eng", return_tensors="pt")

语音

SeamlessM4Tv2Model 可以无缝地生成文本或语音，几乎没有或没有任何变化。让我们以俄语语音翻译为目标：

代码语言：javascript复制

>>> audio_array_from_text = model.generate(**text_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()
>>> audio_array_from_audio = model.generate(**audio_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()

使用基本相同的代码，我已经将英文文本和阿拉伯语音翻译成了俄语语音样本。

文本

同样，您可以使用相同的模型从音频文件或文本生成翻译文本。您只需要将generate_speech=False传递给 SeamlessM4Tv2Model.generate()。这次，让我们翻译成法语。

代码语言：javascript复制

>>> # from audio
>>> output_tokens = model.generate(**audio_inputs, tgt_lang="fra", generate_speech=False)
>>> translated_text_from_audio = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)

>>> # from text
>>> output_tokens = model.generate(**text_inputs, tgt_lang="fra", generate_speech=False)
>>> translated_text_from_text = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)

提示

1. 使用专用模型

SeamlessM4Tv2Model 是 transformers 的顶级模型，用于生成语音和文本，但您也可以使用专用模型执行任务而不需要额外组件，从而减少内存占用。例如，您可以用专门用于 S2ST 任务的模型替换音频到音频生成片段，其余代码完全相同：

代码语言：javascript复制

>>> from transformers import SeamlessM4Tv2ForSpeechToSpeech
>>> model = SeamlessM4Tv2ForSpeechToSpeech.from_pretrained("facebook/seamless-m4t-v2-large")

或者您可以用专门用于 T2TT 任务的模型替换文本到文本生成片段，只需删除generate_speech=False。

代码语言：javascript复制

>>> from transformers import SeamlessM4Tv2ForTextToText
>>> model = SeamlessM4Tv2ForTextToText.from_pretrained("facebook/seamless-m4t-v2-large")

随时尝试 SeamlessM4Tv2ForSpeechToText 和 SeamlessM4Tv2ForTextToSpeech。

更改说话者身份

您可以使用speaker_id参数更改用于语音合成的说话者。一些speaker_id对某些语言效果更好！

更改生成策略

您可以为文本生成使用不同的生成策略，例如.generate(input_ids=input_ids, text_num_beams=4, text_do_sample=True)，它将在文本模型上执行多项式波束搜索解码。请注意，语音生成只支持贪婪 - 默认情况下 - 或多项式采样，可以使用例如.generate(..., speech_do_sample=True, speech_temperature=0.6)。

生成语音和文本同时进行

使用return_intermediate_token_ids=True与 SeamlessM4Tv2Model 来返回语音和文本！

模型架构

SeamlessM4T-v2 具有一个多功能的架构，可以平稳处理文本和语音的顺序生成。这个设置包括两个序列到序列（seq2seq）模型。第一个模型将输入模态转换为翻译文本，而第二个模型从翻译文本生成语音单元标记，称为“单元标记”。

每种模态都有自己独特的架构的专用编码器。此外，对于语音输出，一个受HiFi-GAN架构启发的声码器被放置在第二个 seq2seq 模型的顶部。

与 SeamlessM4T-v1 的不同之处

这个新版本的架构在几个方面与第一个版本不同：

第二次模型的改进

第二个 seq2seq 模型，称为文本到单元模型，现在是非自回归的，这意味着它在单次前向传递中计算单元。这一成就得以实现是因为：

• 使用字符级嵌入，这意味着预测的翻译文本的每个字符都有自己的嵌入，然后用于预测单元标记。
• 使用中间持续预测器，在预测的翻译文本上以字符级预测语音持续时间。
• 使用一个新的文本到单元解码器，混合卷积和自注意力来处理更长的上下文。

语音编码器的不同之处

在第一次生成过程中用于预测翻译文本的语音编码器，主要通过以下机制与以前的语音编码器不同：

• 使用分块注意力掩码来防止跨块的注意力，确保每个位置只关注其自己块内的位置和固定数量的先前块。
• 使用相对位置嵌入，它只考虑序列元素之间的距离，而不是绝对位置。更多细节请参考Self-Attentionwith Relative Position Representations (Shaw et al.)。
• 使用因果深度卷积而不是非因果卷积。

生成过程

生成过程如下：

• 输入文本或语音通过其特定编码器处理。
• 解码器以所需语言创建文本标记。
• 如果需要生成语音，第二个 seq2seq 模型以非自回归方式生成单元标记。
• 然后，这些单元标记通过最终的声码器传递，以产生实际的语音。

此模型由ylacombe贡献。原始代码可以在这里找到。

SeamlessM4Tv2Model

class transformers.SeamlessM4Tv2Model

<来源>

代码语言：javascript复制

( config current_modality = 'text' )

参数

• config (~SeamlessM4Tv2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。
• current_modality (str, optional, 默认为"text") — 默认模态。仅用于初始化模型。可以设置为"text"或"speech"。这将根据传递给前向和生成传递的模态（文本的input_ids和音频的input_features）自动更新。

原始的 SeamlessM4Tv2 模型变压器，可用于所有可用任务（S2ST、S2TT、T2TT、T2ST）。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

generate

<来源>

代码语言：javascript复制

( input_ids: Optional = None input_features: Optional = None return_intermediate_token_ids: Optional = None tgt_lang: Optional = None speaker_id: Optional = 0 generate_speech: Optional = True **kwargs ) → export const metadata = 'undefined';Union[SeamlessM4Tv2GenerationOutput, Tuple[Tensor], ModelOutput]

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 词汇表中输入序列标记的索引。 可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• input_features (torch.FloatTensor，形状为(batch_size, sequence_length, num_banks)，optional) — 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。有关详细信息，请参阅 SeamlessM4TFeatureExtractor.call()。
• return_intermediate_token_ids (bool, optional) — 如果设置为True，还会返回生成的中间文本和单元标记。如果您还想获取音频旁边的翻译文本，请将其设置为True。请注意，如果generate_speech=True，则此参数将被忽略。
• tgt_lang (str, optional) — 用作翻译目标语言的语言。
• speaker_id (int, optional, 默认为 0) — 用于语音合成的说话者的 ID。必须小于config.vocoder_num_spkrs。
• generate_speech (bool, optional, 默认为True) — 如果设置为False，将仅返回文本标记，不会生成语音。
• kwargs（可选）—将传递给 GenerationMixin.generate()的剩余关键字参数字典。关键字参数有两种类型：
  • 没有前缀，它们将作为每个子模型的generate方法的**kwargs输入，除了decoder_input_ids将仅通过文本组件传递。
  • 使用*text_或speech_*前缀，它们将分别作为文本模型和语音模型的generate方法的输入。它优先于没有前缀的关键字。

  这意味着您可以为一个生成策略指定一个生成策略，但不能为另一个生成策略指定生成策略。

返回

Union[SeamlessM4Tv2GenerationOutput, Tuple[Tensor], ModelOutput]

• 如果generate_speech和return_intermediate_token_ids，则返回SeamlessM4Tv2GenerationOutput。
• 如果generate_speech且不是return_intermediate_token_ids，则返回一个由形状为(batch_size, sequence_length)的波形和给出每个样本长度的waveform_lengths组成的元组。
• 如果generate_speech=False，它将返回ModelOutput。

生成翻译的标记 ID 和/或翻译的音频波形。

此方法连续调用两个不同子模型的.generate函数。您可以在两个不同级别指定关键字参数：将传递给两个模型的通用参数，或将传递给其中一个模型的带前缀的参数。

例如，调用.generate(input_ids=input_ids, num_beams=4, speech_do_sample=True)将在文本模型上连续执行波束搜索解码，并在语音模型上执行多项式波束搜索采样。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4Tv2ForTextToSpeech

class transformers.SeamlessM4Tv2ForTextToSpeech

<来源>

代码语言：javascript复制

( config: SeamlessM4Tv2Config )

参数

• config（~SeamlessM4Tv2Config](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。

文本到语音 SeamlessM4Tv2 模型转换器，可用于 T2ST。该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

generate

<来源>

代码语言：javascript复制

( input_ids: Optional = None return_intermediate_token_ids: Optional = None tgt_lang: Optional = None speaker_id: Optional = 0 **kwargs ) → export const metadata = 'undefined';Union[SeamlessM4Tv2GenerationOutput, Tuple[Tensor]]

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）—词汇表中输入序列标记的索引。 可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• return_intermediate_token_ids（bool，可选）—如果为True，还返回中间生成的文本和单元标记。如果您还想在音频旁边获取翻译文本，请将其设置为True。
• tgt_lang（str，可选）- 用作翻译目标语言的语言。
• speaker_id（int，可选，默认为 0）- 用于语音合成的说话者 ID。必须小于config.vocoder_num_spkrs。
• kwargs（可选）- 剩余的关键字参数字典将传递给 GenerationMixin.generate()。关键字参数有两种类型：
  • 没有前缀，它们将作为每个子模型的generate方法的**kwargs输入，除了decoder_input_ids将仅通过文本组件传递。
  • 使用*text_或speech_*前缀，它们将分别作为文本模型和语音模型的generate方法的输入。它优先于没有前缀的关键字。

  这意味着您可以为一个生成指定一种生成策略，但对另一个生成不指定。

返回

Union[SeamlessM4Tv2GenerationOutput, Tuple[Tensor]]

• 如果return_intermediate_token_ids，则返回SeamlessM4Tv2GenerationOutput。
• 如果不是return_intermediate_token_ids，则返回一个由形状为(batch_size, sequence_length)的波形和waveform_lengths组成的元组，其中给出了每个样本的长度。

生成翻译后的音频波形。

此方法连续调用两个不同子模型的.generate函数。您可以在两个不同级别指定关键字参数：将传递给两个模型的一般参数，或者将传递给其中一个模型的带前缀的参数。

例如，调用.generate(input_ids, num_beams=4, speech_do_sample=True)将在文本模型上连续执行波束搜索解码，并在语音模型上执行多项式波束搜索采样。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4Tv2ForSpeechToSpeech

class transformers.SeamlessM4Tv2ForSpeechToSpeech

<来源>

代码语言：javascript复制

( config )

参数

• config（~SeamlessM4Tv2Config）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

这是一个用于 S2ST 的语音到语音 SeamlessM4Tv2 模型转换器。该模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

generate

<来源>

代码语言：javascript复制

( input_features: Optional = None return_intermediate_token_ids: Optional = None tgt_lang: Optional = None speaker_id: Optional = 0 **kwargs ) → export const metadata = 'undefined';Union[SeamlessM4Tv2GenerationOutput, Tuple[Tensor]]

参数

• input_features（形状为(batch_size, sequence_length, num_banks)的torch.FloatTensor）- 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。有关详细信息，请参阅 SeamlessM4TFeatureExtractor.call()。
• return_intermediate_token_ids（bool，可选）- 如果为True，还会返回中间生成的文本和单元标记。如果您还想在音频旁边获取翻译文本，则设置为True。
• tgt_lang（str，可选）- 用作翻译目标语言的语言。
• speaker_id（int，可选，默认为 0）— 用于语音合成的说话者 ID。必须小于config.vocoder_num_spkrs。
• kwargs（可选）— 将传递给 GenerationMixin.generate()的剩余关键字参数字典。关键字参数有两种类型：
  • 没有前缀，它们将作为**kwargs输入到每个子模型的generate方法中，除了decoder_input_ids只会通过文本组件传递。
  • 使用*text_或speech_*前缀，它们将分别作为文本模型和语音模型的generate方法的输入。它优先于没有前缀的关键字。

  这意味着您可以为一个生成指定一种生成策略，但对另一个生成不指定。

返回

Union[SeamlessM4Tv2GenerationOutput, Tuple[Tensor]]

• 如果return_intermediate_token_ids，则返回SeamlessM4Tv2GenerationOutput。
• 如果不是return_intermediate_token_ids，则返回一个由形状为(batch_size, sequence_length)的波形和waveform_lengths组成的元组，其中给出每个样本的长度。

生成翻译的音频波形。

此方法连续调用两个不同子模型的.generate函数。您可以在两个不同级别指定关键字参数：将传递给两个模型的通用参数，或者将传递给其中一个模型的前缀参数。

例如，调用.generate(input_features, num_beams=4, speech_do_sample=True)将在文本模型上连续执行波束搜索解码，并在语音模型上执行多项式波束搜索采样。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4Tv2ForTextToText

class transformers.SeamlessM4Tv2ForTextToText

<来源>

代码语言：javascript复制

( config: SeamlessM4Tv2Config )

参数

• config（~SeamlessM4Tv2Config）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

文本到文本 SeamlessM4Tv2 模型变压器，可用于 T2TT。该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

代码语言：javascript复制

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs )

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 词汇表中输入序列标记的索引。 可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：
  • 对于“未屏蔽”的标记，
  • 对于“屏蔽”的标记为 0。

  什么是注意力掩码？

• decoder_input_ids (torch.LongTensor的形状为(batch_size, target_sequence_length)，optional) — 解码器输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ Bart 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，则只需输入最后的decoder_input_ids（参见past_key_values）。 对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，用于去噪预训练，遵循论文。
• decoder_attention_mask (torch.LongTensor的形状为(batch_size, target_sequence_length)，optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。 如果要更改填充行为，应阅读modeling_bart._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。
• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括(last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，optional) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的元组，每个元组有 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，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（这些没有将其过去的键值状态提供给此模型）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• inputs_embeds (torch.FloatTensor的形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果要更好地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• decoder_inputs_embeds (torch.FloatTensor的形状为(batch_size, target_sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递decoder_input_ids。如果使用了past_key_values，则只需输入最后的decoder_inputs_embeds（参见past_key_values）。如果要更好地控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。 如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。
• use_cache (bool，optional) — 如果设置为True，将返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

SeamlessM4Tv2ForTextToText 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

generate

<来源>

代码语言：javascript复制

( input_ids = None tgt_lang = None generation_config = None logits_processor = None stopping_criteria = None prefix_allowed_tokens_fn = None synced_gpus = False **kwargs ) → export const metadata = 'undefined';ModelOutput or torch.LongTensor

参数

• input_ids (torch.Tensor，根据模态性质的不同形状，optional) — 词汇表中输入序列标记的索引。 可以使用 SeamlessM4TTokenizer 或 SeamlessM4TProcessor 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• tgt_lang (str，optional) — 用作翻译目标语言的语言。
• generation_config (~generation.GenerationConfig，optional) — 用作生成调用的基本参数化的生成配置。传递给生成的**kwargs与generation_config的属性匹配将覆盖它们。如果未提供generation_config，将使用默认值，其加载优先级如下：1）从generation_config.json模型文件中获取；2）从模型配置中获取。请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查文档以参数化生成。
• logits_processor (LogitsProcessorList，optional) — 自定义对数处理器，补充了从参数和生成配置构建的默认对数处理器。如果传递的对数处理器已经使用参数或生成配置创建，则会抛出错误。此功能适用于高级用户。
• stopping_criteria (StoppingCriteriaList, optional) — 自定义停止标准，补充了从参数和生成配置构建的默认停止标准。如果传递的停止标准已经使用参数或生成配置创建，则会抛出错误。此功能适用于高级用户。
• prefix_allowed_tokens_fn（Callable[[int, torch.Tensor], List[int]]，可选）- 如果提供，此函数将在每个步骤中将束搜索限制为仅允许的令牌。如果未提供，则不应用约束。此函数接受 2 个参数：批次 IDbatch_id和input_ids。它必须返回一个列表，其中包含下一代步骤的允许令牌，条件是批次 IDbatch_id和先前生成的令牌inputs_ids。此参数对于受前缀约束的生成很有用，如自回归实体检索中所述。
• synced_gpus（bool，可选，默认为False）- 是否继续运行 while 循环直到 max_length（ZeRO 阶段 3 所需）
• kwargs（Dict[str, Any]，可选）- generate_config的特定参数化和/或将转发到模型的forward函数的其他模型特定 kwargs 的临时参数化。

返回

ModelOutput 或torch.LongTensor

一个 ModelOutput（如果return_dict_in_generate=True或当config.return_dict_in_generate=True时）或一个torch.FloatTensor。可能的 ModelOutput 类型为：

• GenerateEncoderDecoderOutput，
• GenerateBeamEncoderDecoderOutput

生成令牌 id 序列。

大多数生成控制参数都在generation_config中设置，如果未传递，则将设置为模型的默认生成配置。您可以通过将相应的参数传递给 generate()来覆盖任何generation_config，例如.generate(inputs, num_beams=4, do_sample=True)。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4Tv2ForSpeechToText

class transformers.SeamlessM4Tv2ForSpeechToText

<来源>

代码语言：javascript复制

( config: SeamlessM4Tv2Config )

参数

• config（~SeamlessM4Tv2Config）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

可用于 S2TT 的语音到文本 SeamlessM4Tv2 模型变压器。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_features: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs )

参数

• input_features（形状为(batch_size, sequence_length, num_banks)的torch.FloatTensor）- 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。有关详细信息，请参阅 SeamlessM4TFeatureExtractor.call()。
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]：
  • 1 表示未被掩码的标记，
  • 0 表示被掩码的标记。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 词汇表中解码器输入序列标记的索引。 可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ Bart 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，可以选择仅输入最后的decoder_input_ids（参见past_key_values）。 对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文中的方法。
• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。 如果要更改填充行为，应阅读modeling_bart._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。
• encoder_outputs（形状为tuple(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))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的元组，每个元组有 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输入）。 如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（即未将其过去键值状态提供给此模型的那些）的形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更好地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，则可选择仅输入最后的decoder_inputs_embeds（请参阅past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。 如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于计算掩码语言建模损失的标签。索引应在[-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。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

SeamlessM4Tv2ForSpeechToText 的前向方法覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行前处理和后处理步骤，而后者会默默地忽略它们。

generate

<来源>

代码语言：javascript复制

( input_features = None tgt_lang = None generation_config = None logits_processor = None stopping_criteria = None prefix_allowed_tokens_fn = None synced_gpus = False **kwargs ) → export const metadata = 'undefined';ModelOutput or torch.LongTensor

参数

• input_features（形状为(batch_size, sequence_length, num_banks)的torch.FloatTensor）- 输入音频特征。这应该由 SeamlessM4TFeatureExtractor 类或 SeamlessM4TProcessor 类返回。有关详细信息，请参阅 SeamlessM4TFeatureExtractor.call()。
• tgt_lang（str，可选）- 用作翻译目标语言的语言。
• generation_config（~generation.GenerationConfig，可选）- 用作生成调用的基本参数化的生成配置。传递给生成匹配generation_config属性的**kwargs将覆盖它们。如果未提供generation_config，将使用默认值，其加载优先级如下：1）从generation_config.json模型文件中获取，如果存在；2）从模型配置中获取。请注意，未指定的参数将继承 GenerationConfig 的默认值，其文档应该被检查以参数化生成。
• logits_processor（LogitsProcessorList，可选）—自定义 logits 处理器，补充从参数和生成配置构建的默认 logits 处理器。如果传递的 logit 处理器已经使用参数或生成配置创建，则会抛出错误。此功能适用于高级用户。
• stopping_criteria（StoppingCriteriaList，可选）—自定义停止标准，补充从参数和生成配置构建的默认停止标准。如果传递的停止标准已经使用参数或生成配置创建，则会抛出错误。此功能适用于高级用户。
• prefix_allowed_tokens_fn（Callable[[int, torch.Tensor], List[int]]，可选）—如果提供，此函数将在每个步骤将束搜索限制为仅允许的令牌。如果未提供，则不应用约束。此函数接受 2 个参数：批次 IDbatch_id和input_ids。它必须返回一个列表，其中包含下一代步骤的允许令牌，条件是批次 IDbatch_id和先前生成的令牌inputs_ids。此参数对于基于前缀的约束生成非常有用，如自回归实体检索中所述。
• synced_gpus（bool，可选，默认为False）—是否继续运行 while 循环直到 max_length（需要 ZeRO 阶段 3）
• kwargs（Dict[str, Any]，可选）—generate_config的特殊参数化和/或将转发到模型的forward函数的其他模型特定 kwargs。

返回

ModelOutput 或torch.LongTensor

ModelOutput（如果return_dict_in_generate=True或config.return_dict_in_generate=True）或torch.FloatTensor。可能的 ModelOutput 类型为：

• GenerateEncoderDecoderOutput
• GenerateBeamEncoderDecoderOutput

生成令牌 id 序列。

大多数生成控制参数都在generation_config中设置，如果未传递，则将设置为模型的默认生成配置。您可以通过将相应的参数传递给 generate()来覆盖任何generation_config，例如.generate(inputs, num_beams=4, do_sample=True)。

有关生成策略和代码示例的概述，请查看以下指南。

SeamlessM4Tv2Config

class transformers.SeamlessM4Tv2Config

<来源>

代码语言：javascript复制

( vocab_size = 256102 t2u_vocab_size = 10082 char_vocab_size = 10943 hidden_size = 1024 initializer_range = 0.02 layer_norm_eps = 1e-05 use_cache = True max_position_embeddings = 4096 is_encoder_decoder = True encoder_layerdrop = 0.05 decoder_layerdrop = 0.05 activation_function = 'relu' dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.0 scale_embedding = True encoder_layers = 24 encoder_ffn_dim = 8192 encoder_attention_heads = 16 decoder_layers = 24 decoder_ffn_dim = 8192 decoder_attention_heads = 16 decoder_start_token_id = 3 max_new_tokens = 256 pad_token_id = 0 bos_token_id = 2 eos_token_id = 3 speech_encoder_layers = 24 speech_encoder_attention_heads = 16 speech_encoder_intermediate_size = 4096 speech_encoder_hidden_act = 'swish' speech_encoder_dropout = 0.0 add_adapter = True speech_encoder_layerdrop = 0.1 feature_projection_input_dim = 160 adaptor_kernel_size = 8 adaptor_stride = 8 adaptor_dropout = 0.1 num_adapter_layers = 1 position_embeddings_type = 'relative_key' conv_depthwise_kernel_size = 31 left_max_position_embeddings = 64 right_max_position_embeddings = 8 speech_encoder_chunk_size = 20000 speech_encoder_left_chunk_num = 128 t2u_bos_token_id = 0 t2u_pad_token_id = 1 t2u_eos_token_id = 2 t2u_encoder_layers = 6 t2u_encoder_ffn_dim = 8192 t2u_encoder_attention_heads = 16 t2u_decoder_layers = 6 t2u_decoder_ffn_dim = 8192 t2u_decoder_attention_heads = 16 t2u_max_position_embeddings = 4096 t2u_variance_predictor_embed_dim = 1024 t2u_variance_predictor_hidden_dim = 256 t2u_variance_predictor_kernel_size = 3 t2u_variance_pred_dropout = 0.5 sampling_rate = 16000 upsample_initial_channel = 512 upsample_rates = [5, 4, 4, 2, 2] upsample_kernel_sizes = [11, 8, 8, 4, 4] resblock_kernel_sizes = [3, 7, 11] resblock_dilation_sizes = [[1, 3, 5], [1, 3, 5], [1, 3, 5]] leaky_relu_slope = 0.1 unit_hifi_gan_vocab_size = 10000 unit_embed_dim = 1280 lang_embed_dim = 256 spkr_embed_dim = 256 vocoder_num_langs = 36 vocoder_num_spkrs = 200 variance_predictor_kernel_size = 3 var_pred_dropout = 0.5 vocoder_offset = 4 **kwargs )

参数

• vocab_size（int，可选，默认为 256102）—SeamlessM4Tv2 模型文本模态的词汇大小。定义了在调用SeamlessM4Tv2Model、SeamlessM4Tv2ForTextToSpeech 或~SeamlessM4Tv2ForTextToText 时传递的不同令牌数量。inputs_ids。
• t2u_vocab_size (int, optional, 默认为 10082) — SeamlessM4Tv2 模型的单元词汇量。定义了在调用~SeamlessM4Tv2Model 的 Text-To-Units 子模型时可以表示的不同“单元标记”的数量。
• char_vocab_size (int, optional, 默认为 10943) — SeamlessM4Tv2 模型的字符词汇量。定义了在调用~SeamlessM4Tv2Model 的 Text-To-Units 子模型时可以表示的不同字符标记的数量。

在子模型之间共享的参数

• hidden_size (int, optional, 默认为 1024) — 架构中“中间”层的维度。
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, 默认为 1e-05) — 层归一化层使用的 epsilon。
• use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
• max_position_embeddings (int, optional, 默认为 4096) — 此模型文本编码器和解码器可能会使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
• is_encoder_decoder (bool, optional, 默认为True) — 模型是否用作编码器/解码器。
• encoder_layerdrop (float, optional, 默认为 0.05) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文)。
• decoder_layerdrop (float, optional, 默认为 0.05) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文)。
• activation_function (str或function, optional, 默认为"relu") — 解码器和前馈层中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"、"swish"和"gelu_new"。
• dropout (float, optional, 默认为 0.1) — 嵌入层、编码器、解码器和池化器中所有全连接层的 dropout 概率。
• attention_dropout (float, optional, 默认为 0.1) — 所有注意力层的 dropout 概率。
• activation_dropout (float, optional, 默认为 0.0) — 模型中所有激活层的 dropout 概率。
• scale_embedding (bool, optional, 默认为True) — 通过将 d_model 开方来缩放嵌入。

文本编码器和文本解码器特定参数

• encoder_layers (int, optional, 默认为 24) — Transformer 文本编码器中的隐藏层数。
• encoder_ffn_dim (int, optional, 默认为 8192) — Transformer 文本编码器中“中间”（即前馈）层的维度。
• encoder_attention_heads (int, optional, 默认为 16) — Transformer 文本编码器中每个注意力层的注意力头数。
• decoder_layers (int, optional, 默认为 24) — Transformer 文本解码器中的隐藏层数。
• decoder_ffn_dim (int, optional, defaults to 8192) — Transformer 文本解码器中“中间”（即前馈）层的维度。
• decoder_attention_heads (int, optional, defaults to 16) — Transformer 文本解码器中每个注意力层的注意力头数。
• decoder_start_token_id (int, optional, defaults to 3) — 如果编码器-解码器模型以与 bos 不同的标记开始解码，则该标记的 id。仅适用于文本解码器。
• max_new_tokens (int, optional, defaults to 256) — 要生成的文本标记的最大数量，忽略提示中的标记数量。
• pad_token_id (int, optional, defaults to 0) — padding 文本标记的 id。仅适用于文本解码器模型。
• bos_token_id (int, optional, defaults to 2) — 流开始 文本标记的 id。仅适用于文本解码器模型。
• eos_token_id (int, optional, defaults to 3) — 流结束 文本标记的 id。仅适用于文本解码器模型。

语音编码器特定参数

• speech_encoder_layers (int, optional, defaults to 24) — Transformer 语音编码器中的隐藏层数量。
• speech_encoder_attention_heads (int, optional, defaults to 16) — Transformer 语音编码器中每个注意力层的注意力头数。
• speech_encoder_intermediate_size (int, optional, defaults to 4096) — Transformer 语音编码器中“中间”（即前馈）层的维度。
• speech_encoder_hidden_act (str 或 function, optional, defaults to "swish") — 语音编码器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "selu", "swish" 和 "gelu_new"。
• speech_encoder_dropout (float, optional, defaults to 0.0) — 语音编码器中所有层的 dropout 概率。
• add_adapter (bool, optional, defaults to True) — 在语音编码器顶部添加一个适配器层。
• speech_encoder_layerdrop (float, optional, defaults to 0.1) — 语音编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文)。
• feature_projection_input_dim (int, optional, defaults to 160) — 语音编码器输入特征投影的维度，即使用 SeamlessM4TFeatureExtractor 处理输入音频后的维度。
• adaptor_kernel_size (int, optional, defaults to 8) — 适配器网络中卷积层的核大小。仅在 add_adapter 为 True 时相关。
• adaptor_stride (int, optional, defaults to 8) — 适配器网络中卷积层的步幅。仅在 add_adapter 为 True 时相关。
• adaptor_dropout (float, optional, defaults to 0.1) — 语音适配器中所有层的 dropout 概率。
• num_adapter_layers (int, optional, defaults to 1) — 适配器网络中应使用的卷积层数量。仅在 add_adapter 为 True 时相关。
• position_embeddings_type (str, optional, defaults to "relative_key") — 可指定为 relative_key。如果保持为 None，则不应用相对位置嵌入。仅适用于语音编码器。有关 "relative_key" 的更多信息，请参阅 Self-Attention with Relative Position Representations (Shaw et al.)。
• conv_depthwise_kernel_size (int, optional, defaults to 31) — Conformer 块中深度可分离 1D 卷积层的核大小。仅适用于语音编码器。
• left_max_position_embeddings (int, optional, defaults to 64) — 相对位置的左裁剪值。
• right_max_position_embeddings (int, optional, defaults to 8) — 相对位置的右裁剪值。
• speech_encoder_chunk_size (int, optional, 默认为 20000) — 每个注意力块的大小。
• speech_encoder_left_chunk_num (int, optional, 默认为 128) — 允许向左查看的块数。

文本到单元（t2u）模型特定参数

• t2u_bos_token_id (int, optional, 默认为 0) — 流开始 单元标记的 id。仅适用于文本到单元的 seq2seq 模型。
• t2u_pad_token_id (int, optional, 默认为 1) — 填充 单元标记的 id。仅适用于文本到单元的 seq2seq 模型。
• t2u_eos_token_id (int, optional, 默认为 2) — 流结束 单元标记的 id。仅适用于文本到单元的 seq2seq 模型。
• t2u_encoder_layers (int, optional, 默认为 6) — Transformer 文本到单元编码器中的隐藏层数量。
• t2u_encoder_ffn_dim (int, optional, 默认为 8192) — Transformer 文本到单元编码器中“中间”（即前馈）层的维度。
• t2u_encoder_attention_heads (int, optional, 默认为 16) — Transformer 文本到单元编码器中每个注意力层的注意力头数量。
• t2u_decoder_layers (int, optional, 默认为 6) — Transformer 文本到单元解码器中的隐藏层数量。
• t2u_decoder_ffn_dim (int, optional, 默认为 8192) — Transformer 文本到单元解码器中“中间”（即前馈）层的维度。
• t2u_decoder_attention_heads (int, optional, 默认为 16) — Transformer 文本到单元解码器中每个注意力层的注意力头数量。
• t2u_max_position_embeddings (int, optional, 默认为 4096) — 该模型文本到单元组件可能被使用的最大序列长度。通常设置为较大的值以防万一（例如 512、1024 或 2048）。
• t2u_variance_predictor_embed_dim (int, optional, 默认为 1024) — 文本到单元的持续时间预测器的投影维度。
• t2u_variance_predictor_hidden_dim (int, optional, 默认为 256) — 文本到单元的持续时间预测器的内部维度。
• t2u_variance_predictor_kernel_size (int, optional, 默认为 3) — 文本到单元的持续时间预测器的卷积层的内核大小。
• t2u_variance_pred_dropout (float, optional, 默认为 0.5) — 文本到单元的持续时间预测器的 dropout 概率。 Hifi-Gan 声码器特定参数
• sampling_rate (int, optional, 默认为 16000) — 生成输出音频的采样率，以赫兹（Hz）表示。
• upsample_initial_channel (int, optional, 默认为 512) — hifi-gan 上采样网络的输入通道数。仅适用于声码器。
• upsample_rates (Tuple[int] 或 List[int], optional, 默认为[5, 4, 4, 2, 2]) — 一个整数元组，定义声码器上采样网络中每个 1D 卷积层的步幅。upsample_rates的长度定义了卷积层的数量，并且必须与upsample_kernel_sizes的长度匹配。仅适用于声码器。
• upsample_kernel_sizes (Tuple[int] 或 List[int], optional, 默认为[11, 8, 8, 4, 4]) — 一个整数元组，定义声码器上采样网络中每个 1D 卷积层的内核大小。upsample_kernel_sizes的长度定义了卷积层的数量，并且必须与upsample_rates的长度匹配。仅适用于声码器。
• resblock_kernel_sizes (Tuple[int] 或 List[int], optional, 默认为[3, 7, 11]) — 一个整数元组，定义多接受域融合（MRF）模块中声码器 1D 卷积层的内核大小。仅适用于声码器。
• resblock_dilation_sizes (Tuple[Tuple[int]] 或 List[List[int]], optional, 默认为 [[1, 3, 5], [1, 3, 5], [1, 3, 5]]) — 一个嵌套的整数元组，定义了多接受域融合（MRF）模块中语音编码器膨胀 1D 卷积层的扩张率。仅适用于语音编码器。
• leaky_relu_slope (float, optional, 默认为 0.1) — 语音编码器中 leaky ReLU 激活使用的负斜率的角度。仅适用于语音编码器。
• unit_hifi_gan_vocab_size (int, optional, 默认为 10000) — SeamlessM4Tv2 语音编码器的词汇表大小。定义了在调用 SeamlessM4Tv2Model、SeamlessM4Tv2ForSpeechToSpeech 或 ~SeamlessM4Tv2ForTextToSpeech 时可以表示的不同单元标记数量。
• unit_embed_dim (int, optional, 默认为 1280) — 给予 hifi-gan 语音编码器的输入 id 的投影维度。仅适用于语音编码器。
• lang_embed_dim (int, optional, 默认为 256) — 给予 hifi-gan 语音编码器的目标语言的投影维度。仅适用于语音编码器。
• spkr_embed_dim (int, optional, 默认为 256) — 给予 hifi-gan 语音编码器的说话者 id 的投影维度。仅适用于语音编码器。
• vocoder_num_langs (int, optional, 默认为 36) — 语音编码器支持的语言数量。可能与 t2u_num_langs 不同。
• vocoder_num_spkrs (int, optional, 默认为 200) — 语音编码器支持的说话者数量。
• variance_predictor_kernel_size (int, optional, 默认为 3) — 持续时间预测器的核大小。仅适用于语音编码器。
• var_pred_dropout (float, optional, 默认为 0.5) — 持续时间预测器的 dropout 概率。仅适用于语音编码器。
• vocoder_offset (int, optional, 默认为 4) — 将单元标记的 id 偏移此数字以考虑符号标记。仅适用于语音编码器。

这是用于存储 ~SeamlessM4Tv2Model 配置的配置类。根据指定的参数实例化一个 SeamlessM4Tv2 模型，定义模型架构。使用默认值实例化配置将产生类似于 SeamlessM4Tv2 “” 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

代码语言：javascript复制

>>> from transformers import SeamlessM4Tv2Model, SeamlessM4Tv2Config

>>> # Initializing a SeamlessM4Tv2 "" style configuration
>>> configuration = SeamlessM4Tv2Config()

>>> # Initializing a model from the "" style configuration
>>> model = SeamlessM4Tv2Model(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

SEW

原文链接: huggingface.co/docs/transformers/v4.37.2/en/model_doc/sew

概述

SEW（Squeezed and Efficient Wav2Vec）是由 Felix Wu, Kwangyoun Kim, Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi 在Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition中提出的。

该论文的摘要如下：

这篇论文研究了预训练模型在自动语音识别（ASR）中的性能效率权衡。我们关注 wav2vec 2.0，并形式化了几种影响模型性能和效率的架构设计。综合我们所有的观察，我们引入了 SEW（Squeezed and Efficient Wav2vec），这是一个预训练模型架构，在各种训练设置中在性能和效率两个维度上都有显著改进。例如，在 LibriSpeech 的 100h-960h 半监督设置下，SEW 相对于 wav2vec 2.0 实现了 1.9 倍的推理加速，词错误率相对减少了 13.5%。在类似的推理时间下，SEW 在不同模型大小上将词错误率降低了 25-50%。

这个模型是由anton-l贡献的。

使用提示

• SEW 是一个接受与语音信号的原始波形对应的浮点数组的语音模型。
• SEWForCTC 是使用连接主义时间分类（CTC）进行微调的，因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。

资源

• 音频分类任务指南
• 自动语音识别任务指南

SEWConfig

class transformers.SEWConfig

<来源>

代码语言：javascript复制

( vocab_size = 32 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 squeeze_factor = 2 hidden_act = 'gelu' hidden_dropout = 0.1 activation_dropout = 0.1 attention_dropout = 0.1 feat_proj_dropout = 0.0 final_dropout = 0.1 layerdrop = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 feat_extract_norm = 'group' feat_extract_activation = 'gelu' conv_dim = (64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512) conv_stride = (5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) conv_kernel = (10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) conv_bias = False num_conv_pos_embeddings = 128 num_conv_pos_embedding_groups = 16 apply_spec_augment = True mask_time_prob = 0.05 mask_time_length = 10 mask_time_min_masks = 2 mask_feature_prob = 0.0 mask_feature_length = 10 mask_feature_min_masks = 0 ctc_loss_reduction = 'mean' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 **kwargs )

参数

• vocab_size (int, 可选, 默认为 32) — SEW 模型的词汇表大小。定义了在调用SEW时可以表示的不同标记的数量。
• hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
• num_hidden_layers (int, 可选, 默认为 12) — 变压器编码器中的隐藏层数量。
• num_attention_heads (int, 可选, 默认为 12) — 变压器编码器中每个注意力层的注意力头数。
• intermediate_size (int, 可选, 默认为 3072) — 变压器编码器中“中间”（即前馈）层的维度。
• squeeze_factor (int, 可选, 默认为 2) — 编码器后的序列长度下采样因子和变压器后的上采样因子。
• hidden_act (str或function, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu", "relu", "selu"和"gelu_new"。
• hidden_dropout (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
• activation_dropout (float, 可选, 默认为 0.1) — 全连接层内部激活的丢弃比率。
• attention_dropout (float, 可选, 默认为 0.1) — 注意力概率的丢弃比率。
• final_dropout (float, 可选, 默认为 0.1) — SEWForCTC 的最终投影层的丢弃概率。
• layerdrop (float, 可选, 默认为 0.1) — LayerDrop 概率。更多细节请参阅 LayerDrop paper)。
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
• feat_extract_norm (str, optional, 默认为"group") — 应用于特征编码器中 1D 卷积层的规范化方式。"group"表示仅对第一个 1D 卷积层进行组归一化，"layer"表示对所有 1D 卷积层进行层归一化。
• feat_proj_dropout (float, optional, 默认为 0.0) — 特征编码器输出的丢弃概率。
• feat_extract_activation (str, optional, 默认为“gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数（函数或字符串）。如果是字符串，支持“gelu”、“relu”、“selu”和“gelu_new”`。
• conv_dim (Tuple[int] 或 List[int], optional, 默认为(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512)) — 一个整数元组，定义了特征编码器中每个 1D 卷积层的输入和输出通道数。conv_dim的长度定义了 1D 卷积层的数量。
• conv_stride (Tuple[int] 或 List[int], optional, 默认为(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)) — 一个整数元组，定义了特征编码器中每个 1D 卷积层的步幅。conv_stride的长度定义了卷积层的数量，并且必须与conv_dim的长度匹配。
• conv_kernel (Tuple[int] 或 List[int], optional, 默认为(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)) — 一个整数元组，定义了特征编码器中每个 1D 卷积层的内核大小。conv_kernel的长度定义了卷积层的数量，并且必须与conv_dim的长度匹配。
• conv_bias (bool, optional, 默认为False) — 1D 卷积层是否具有偏置。
• num_conv_pos_embeddings (int, optional, 默认为 128) — 卷积位置嵌入的数量。定义了 1D 卷积位置嵌入层的内核大小。
• num_conv_pos_embedding_groups (int, optional, 默认为 16) — 1D 卷积位置嵌入层的组数。
• apply_spec_augment (bool, optional, 默认为True) — 是否对特征编码器的输出应用SpecAugment数据增强。参考SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。
• mask_time_prob (float, optional, 默认为 0.05) — 沿时间轴的所有特征向量中将被掩盖的百分比（介于 0 和 1 之间）。掩盖过程在该轴上生成”mask_time_prob*len(time_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选择为掩盖向量跨度起始的概率推理，mask_time_prob应该是prob_vector_start*mask_time_length。请注意，重叠可能会降低掩盖向量的实际百分比。只有在apply_spec_augment 为 True时才相关。
• mask_time_length (int, optional, 默认为 10) — 沿时间轴的向量跨度长度。
• mask_time_min_masks (int, optional, 默认为 2) — 沿时间轴生成的长度为mask_feature_length的掩码的最小数量，每个时间步，与mask_feature_prob无关。只有在”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”时才相关。
• mask_feature_prob (float, optional, defaults to 0.0) — 沿特征轴的所有特征向量中将被掩码的百分比（介于 0 和 1 之间）。掩码过程在轴上生成”mask_feature_problen(feature_axis)/mask_time_length”个独立掩码。如果从每个特征向量被选择为要掩码的向量跨度的起始的概率推理， mask_feature_prob *应为prob_vector_start*mask_feature_length。请注意，重叠可能会降低实际掩码向量的百分比。仅在apply_spec_augment为 True 时相关。
• mask_feature_length (int, optional, defaults to 10) — 沿特征轴的向量跨度长度。
• mask_feature_min_masks (int, optional, defaults to 0), — 沿特征轴生成的长度为mask_feature_length的最小掩码数量，每个时间步，与mask_feature_prob无关。仅在”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”时相关
• ctc_loss_reduction (str, optional, defaults to "sum") — 指定应用于torch.nn.CTCLoss输出的减少。仅在训练 SEWForCTC 的实例时相关。
• ctc_zero_infinity (bool, optional, defaults to False) — 是否将torch.nn.CTCLoss的无限损失和相关梯度置零。当输入太短无法与目标对齐时，主要会出现无限损失。仅在训练 SEWForCTC 的实例时相关。
• use_weighted_layer_sum (bool, optional, defaults to False) — 是否使用学习权重的层输出的加权平均。仅在使用 Wav2Vec2ForSequenceClassification 的实例时相关。
• classifier_proj_size (int, optional, defaults to 256) — 分类前的投影维度。

这是用于存储 SEWModel 配置的配置类。根据指定的参数实例化 SEW 模型，定义模型架构。使用默认值实例化配置将产生类似于 SEW asapp/sew-tiny-100k架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

代码语言：javascript复制

>>> from transformers import SEWConfig, SEWModel

>>> # Initializing a SEW asapp/sew-tiny-100k style configuration
>>> configuration = SEWConfig()

>>> # Initializing a model (with random weights) from the asapp/sew-tiny-100k style configuration
>>> model = SEWModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

SEWModel

class transformers.SEWModel

<来源>

代码语言：javascript复制

( config: SEWConfig )

参数

• config (SEWConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

裸 SEW 模型变压器输出原始隐藏状态，没有特定的顶部头。SEW 是由 Felix Wu、Kwangyoun Kim、Jing Pan、Kyu Han、Kilian Q. Weinberger、Yoav Artzi 在Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition中提出的。

该模型继承自 PreTrainedModel。查看超类文档以了解库实现的通用方法（如下载或保存等）。

该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。

forward

<来源>

代码语言：javascript复制

( input_values: Optional attention_mask: Optional = None mask_time_indices: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

• input_values (torch.FloatTensor of shape (batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。为了准备input_values数组，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2Processor.call()。
• attention_mask (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行卷积和注意力的掩码。选择的掩码值在[0, 1]中：
  • 1 代表未被掩盖的标记，
  • 0 代表被掩盖的标记。

  什么是注意力掩码？

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（SEWConfig）和输入。

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

SEWModel 的前向方法，覆盖了__call__特殊方法。

尽管需要在此函数内定义前向传递的配方，但应该在之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoProcessor, SEWModel
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("asapp/sew-tiny-100k-ft-ls100h")
>>> model = SEWModel.from_pretrained("asapp/sew-tiny-100k-ft-ls100h")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 292, 512]

SEWForCTC

class transformers.SEWForCTC

<来源>

代码语言：javascript复制

( config target_lang: Optional = None )

参数

• config（SEWConfig）- 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，只加载配置。 请查看 from_pretrained()方法以加载模型权重。

SEW 模型在连接主义时间分类（CTC）顶部具有语言建模头。 SEW 是由 Felix Wu，Kwangyoun Kim，Jing Pan，Kyu Han，Kilian Q. Weinberger，Yoav Artzi 在Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition中提出的。

此模型继承自 PreTrainedModel。 请查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存等）。

此模型是 PyTorch torch.nn.Module子类。 将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutput or tuple(torch.FloatTensor)

参数

• input_values（形状为(batch_size, sequence_length)的torch.FloatTensor）- 输入原始语音波形的浮点值。 值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。 要将数组准备成input_values，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。 有关详细信息，请参阅 Wav2Vec2Processor.call()。
• attention_mask（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于避免在填充标记索引上执行卷积和注意力的掩码。 选择的掩码值在[0, 1]中：
  • 1 表示未掩码的标记，
  • 0 表示掩码的标记。

  什么是注意力掩码？

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size, target_length)的torch.LongTensor，可选）- 用于连接主义时间分类的标签。 请注意，target_length必须小于或等于输出 logits 的序列长度。 索引在[-100, 0, ..., config.vocab_size - 1]中选择。 所有设置为-100的标签都被忽略（掩码），仅对[0, ..., config.vocab_size - 1]中的标签计算损失。

返回

transformers.modeling_outputs.CausalLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（SEWConfig）和输入的各种元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 语言建模损失（用于下一个标记预测）。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个 每层输出的一个）。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力权重在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。

SEWForCTC 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoProcessor, SEWForCTC
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("asapp/sew-tiny-100k-ft-ls100h")
>>> model = SEWForCTC.from_pretrained("asapp/sew-tiny-100k-ft-ls100h")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
'MISTER QUILTER IS THE APPOSTILE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPOLLE'

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
0.42

SEWForSequenceClassification

class transformers.SEWForSequenceClassification

<来源>

代码语言：javascript复制

( config )

参数

• config（SEWConfig）- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部带有序列分类头的 SEW 模型（一个线性层在池化输出上）用于类似 SUPERB 关键词检测的任务。

SEW 是由 Felix Wu、Kwangyoun Kim、Jing Pan、Kyu Han、Kilian Q. Weinberger、Yoav Artzi 在Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition中提出的。

这个模型继承自 PreTrainedModel。查看超类文档以了解库实现的通用方法（如下载或保存等）。

这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_values (torch.FloatTensor，形状为(batch_size, sequence_length)） — 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过声音文件库（pip install soundfile）。为了准备数组为input_values，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2Processor.call()。
• attention_mask (torch.LongTensor，形状为(batch_size, sequence_length)，可选） — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选在[0, 1]范围内：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• output_attentions (bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool，可选） — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor，形状为(batch_size,)，可选） — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（SEWConfig）和输入。

• 损失 (torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)） — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出， 每层的输出）。 模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

SEWForSequenceClassification 前向方法，覆盖了__call__特殊方法。

尽管前向传播的配方需要在这个函数内定义，但应该在此之后调用Module实例，而不是这个函数，因为前者负责运行预处理和后处理步骤，而后者则会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoFeatureExtractor, SEWForSequenceClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("anton-l/sew-mid-100k-ft-keyword-spotting")
>>> model = SEWForSequenceClassification.from_pretrained("anton-l/sew-mid-100k-ft-keyword-spotting")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.argmax(logits, dim=-1).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'_unknown_'

>>> # compute loss - target_label is e.g. "down"
>>> target_label = model.config.id2label[0]
>>> inputs["labels"] = torch.tensor([model.config.label2id[target_label]])
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
9.52

SEW-D

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/sew-d

概述

SEW-D（具有解耦注意力的压缩和高效 Wav2Vec）由 Felix Wu、Kwangyoun Kim、Jing Pan、Kyu Han、Kilian Q. Weinberger、Yoav Artzi 在无监督预训练语音识别中的性能效率权衡中提出。

该论文的摘要如下：

本文研究了预训练模型在自动语音识别（ASR）中的性能效率权衡。我们关注 wav2vec 2.0，并形式化了几种影响模型性能和效率的架构设计。综合我们所有的观察，我们引入了 SEW（压缩和高效 Wav2vec），这是一个预训练模型架构，在各种训练设置中在性能和效率两个维度上都有显著改进。例如，在 LibriSpeech 的 100h-960h 半监督设置下，SEW 相对于 wav2vec 2.0 实现了 1.9 倍的推理加速，词错误率相对减少了 13.5%。在类似的推理时间下，SEW 在不同模型大小下将词错误率降低了 25-50%。

此模型由anton-l贡献。

使用提示

• SEW-D 是一个接受与语音信号的原始波形对应的浮点数组的语音模型。
• SEWDForCTC 经过连接主义时间分类（CTC）微调，因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。

资源

• 音频分类任务指南
• 自动语音识别任务指南

SEWDConfig

class transformers.SEWDConfig

<来源>

代码语言：javascript复制

( vocab_size = 32 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 squeeze_factor = 2 max_position_embeddings = 512 position_buckets = 256 share_att_key = True relative_attention = True pos_att_type = ('p2c', 'c2p') norm_rel_ebd = 'layer_norm' hidden_act = 'gelu_python' hidden_dropout = 0.1 activation_dropout = 0.1 attention_dropout = 0.1 feat_proj_dropout = 0.0 final_dropout = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-07 feature_layer_norm_eps = 1e-05 feat_extract_norm = 'group' feat_extract_activation = 'gelu' conv_dim = (64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512) conv_stride = (5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) conv_kernel = (10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) conv_bias = False num_conv_pos_embeddings = 128 num_conv_pos_embedding_groups = 16 apply_spec_augment = True mask_time_prob = 0.05 mask_time_length = 10 mask_time_min_masks = 2 mask_feature_prob = 0.0 mask_feature_length = 10 mask_feature_min_masks = 0 ctc_loss_reduction = 'mean' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 **kwargs )

参数

• vocab_size (int, optional, defaults to 32) — SEW-D 模型的词汇量。定义了在调用SEWD时可以表示的不同标记数量。
• hidden_size (int, optional, defaults to 768) — 编码器层和池化层的维度。
• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
• squeeze_factor (int, optional, defaults to 2) — 编码器后的序列长度下采样因子和变压器后的上采样因子。
• max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
• position_buckets (int, optional, defaults to 256) — 相对位置嵌入的最大大小。
• share_att_key (bool, optional, defaults to True) — 是否与 c2p 和 p2c 共享注意力键。
• relative_attention (bool, optional, defaults to True) — 是否使用相对位置编码。
• pos_att_type (Tuple[str], optional, defaults to ("p2c", "c2p")) — 相对位置注意力的类型，可以是("p2c", "c2p")的组合，例如("p2c")，("p2c", "c2p")，("p2c", "c2p")。
• norm_rel_ebd (str, optional, defaults to "layer_norm") — 是否在相对嵌入中使用层归一化（如果是，则为"layer_norm"）
• hidden_act (str or function, optional, defaults to "gelu_python") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"、"gelu_python"和"gelu_new"。
• hidden_dropout (float, optional, defaults to 0.1) — 已弃用。模型不使用，将在未来版本中移除。
• activation_dropout (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
• attention_dropout (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
• final_dropout (float, optional, defaults to 0.1) — SEWDForCTC 最终投影层的 dropout 概率。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, defaults to 1e-7) — 变压器编码器中层归一化层使用的 epsilon。
• feature_layer_norm_eps (float, optional, defaults to 1e-5) — 特征编码器后的层归一化使用的 epsilon。
• feat_extract_norm (str, optional, defaults to "group") — 应用于特征编码器中 1D 卷积层的规范化。"group"表示仅对第一个 1D 卷积层进行组归一化，"layer"表示对所有 1D 卷积层进行层归一化。
• feat_proj_dropout (float, optional, defaults to 0.0) — 特征编码器输出的 dropout 概率。
• feat_extract_activation (str, optional, defaults to “gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数（函数或字符串）。如果是字符串，支持“gelu”、“relu”、“selu”和“gelu_new”`。
• conv_dim (Tuple[int] or List[int], optional, defaults to (64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512)) — 定义特征编码器中每个 1D 卷积层的输入和输出通道数的整数元组。conv_dim的长度定义了 1D 卷积层的数量。
• conv_stride (Tuple[int] or List[int], optional, defaults to (5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)) — 定义特征编码器中每个 1D 卷积层的步幅的整数元组。conv_stride的长度定义了卷积层的数量，并且必须与conv_dim的长度匹配。
• conv_kernel (Tuple[int] or List[int], optional, defaults to (10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)) — 定义特征编码器中每个 1D 卷积层的卷积核大小的整数元组。conv_kernel的长度定义了卷积层的数量，并且必须与conv_dim的长度匹配。
• conv_bias (bool, optional, defaults to False) — 1D 卷积层是否具有偏置。
• num_conv_pos_embeddings (int, optional, defaults to 128) — 卷积位置嵌入的数量。定义了 1D 卷积位置嵌入层的卷积核大小。
• num_conv_pos_embedding_groups (int, optional, defaults to 16) — 1D 卷积位置嵌入层的组数。
• apply_spec_augment (bool, optional, defaults to True) — 是否对特征编码器的输出应用SpecAugment数据增强。参考SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。
• mask_time_prob (float, 可选, 默认为 0.05) — 沿时间轴的所有特征向量的百分比（介于 0 和 1 之间），将被掩盖。掩盖过程在该轴上生成”mask_time_problen(time_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选择为要掩盖的向量跨度的起始的概率推理， mask_time_prob *应为prob_vector_start*mask_time_length。请注意，重叠可能会降低掩盖向量的实际百分比。只有在apply_spec_augment为 True 时才相关。
• mask_time_length (int, 可选, 默认为 10) — 沿时间轴的向量跨度长度。
• mask_time_min_masks (int, 可选, 默认为 2) — 沿时间轴生成的长度为mask_feature_length的掩码的最小数量，每个时间步，与mask_feature_prob无关。只有在”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”时才相关。
• mask_feature_prob (float, 可选, 默认为 0.0) — 沿特征轴的所有特征向量的百分比（介于 0 和 1 之间），将被掩盖。掩盖过程在该轴上生成”mask_feature_problen(feature_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选择为要掩盖的向量跨度的起始的概率推理， mask_feature_prob *应为prob_vector_start*mask_feature_length。请注意，重叠可能会降低掩盖向量的实际百分比。只有在apply_spec_augment为 True 时才相关。
• mask_feature_length (int, 可选, 默认为 10) — 沿特征轴的向量跨度长度。
• mask_feature_min_masks (int, 可选, 默认为 0) — 沿特征轴生成的长度为mask_feature_length的掩码的最小数量，每个时间步，与mask_feature_prob无关。只有在”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”时才相关。
• diversity_loss_weight (int, 可选, 默认为 0.1) — 代码本多样性损失组件的权重。
• ctc_loss_reduction (str, 可选, 默认为"sum") — 指定应用于torch.nn.CTCLoss输出的减少方式。只有在训练 SEWDForCTC 实例时才相关。
• ctc_zero_infinity (bool, 可选, 默认为False) — 是否将torch.nn.CTCLoss的无限损失和相关梯度置零。当输入太短无法与目标对齐时，主要会发生无限损失。只有在训练 SEWDForCTC 实例时才相关。
• use_weighted_layer_sum (bool, 可选, 默认为False) — 是否使用具有学习权重的层输出的加权平均。只有在使用 Wav2Vec2ForSequenceClassification 实例时才相关。
• classifier_proj_size (int, 可选, 默认为 256) — 分类前的投影维度，用于标记均值池化。

这是用于存储 SEWDModel 配置的配置类。它用于根据指定的参数实例化一个 SEW-D 模型，定义模型架构。使用默认值实例化配置将产生类似于 SEW-D asapp/sew-d-tiny-100k架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

代码语言：javascript复制

>>> from transformers import SEWDConfig, SEWDModel

>>> # Initializing a SEW-D asapp/sew-d-tiny-100k style configuration
>>> configuration = SEWDConfig()

>>> # Initializing a model (with random weights) from the asapp/sew-d-tiny-100k style configuration
>>> model = SEWDModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

to_dict

<来源>

代码语言：javascript复制

( )

将此实例序列化为 Python 字典。

SEWDModel

class transformers.SEWDModel

<来源>

代码语言：javascript复制

( config: SEWDConfig )

参数

• config (SEWDConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

裸 SEW-D 模型变压器输出原始隐藏状态，没有特定的顶部头。SEW-D 是由 Felix Wu、Kwangyoun Kim、Jing Pan、Kyu Han、Kilian Q. Weinberger、Yoav Artzi 在Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition中提出的。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存等）。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_values: Optional attention_mask: Optional = None mask_time_indices: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

• input_values (torch.FloatTensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得值，例如通过 soundfile 库（pip install soundfile）。要将数组准备为input_values，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参见 Wav2Vec2Processor.call()。
• attention_mask (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]之间：
  • 对于未被掩码的标记为1，
  • 对于被掩码的标记为0。

  什么是注意力掩码？

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置(SEWDConfig)和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出 每一层的输出）。 模型在每一层的输出的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

SEWDModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoProcessor, SEWDModel
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("asapp/sew-d-tiny-100k-ft-ls100h")
>>> model = SEWDModel.from_pretrained("asapp/sew-d-tiny-100k-ft-ls100h")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 292, 384]

SEWDForCTC

class transformers.SEWDForCTC

<来源>

代码语言：javascript复制

( config target_lang: Optional = None )

参数

• config（SEWDConfig）- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

带有顶部语言建模头部的 SEW-D 模型，用于连接主义时间分类（CTC）。SEW-D 是由 Felix Wu、Kwangyoun Kim、Jing Pan、Kyu Han、Kilian Q. Weinberger、Yoav Artzi 在无监督预训练在语音识别中的性能效率权衡中提出的。

这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存等）。

这个模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

前进

<来源>

代码语言：javascript复制

( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutput or tuple(torch.FloatTensor)

参数

• input_values（形状为(batch_size, sequence_length)的torch.FloatTensor）- 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_values，应该使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2Processor.call()。
• attention_mask（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于避免在填充令牌索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]中：
  • 对于未被掩码的标记为 1，
  • 对于被掩码的标记为 0。

  什么是注意力掩码？

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor，形状为(batch_size, target_length)，optional) — 连接主义时间分类的标签。注意target_length必须小于或等于输出 logits 的序列长度。索引在[-100, 0, ..., config.vocab_size - 1]中选择。所有设置为-100的标签都被忽略（掩码），损失仅计算在[0, ..., config.vocab_size - 1]中的标签。

返回

transformers.modeling_outputs.CausalLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（SEWDConfig）和输入的各种元素。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回） — 语言建模损失（用于下一个标记预测）。
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出和每一层的输出）。 模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

SEWDForCTC 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoProcessor, SEWDForCTC
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("asapp/sew-d-tiny-100k-ft-ls100h")
>>> model = SEWDForCTC.from_pretrained("asapp/sew-d-tiny-100k-ft-ls100h")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
'MISTER QUILTER IS THE APOSTIL OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL'

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
0.21

SEWDForSequenceClassification

class transformers.SEWDForSequenceClassification

<来源>

代码语言：javascript复制

( config )

参数

• config（SEWDConfig） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部具有序列分类头（池化输出上的线性层）的 SEWD 模型，用于类似 SUPERB 关键词识别的任务。

SEW-D 是由 Felix Wu、Kwangyoun Kim、Jing Pan、Kyu Han、Kilian Q. Weinberger、Yoav Artzi 在Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition中提出的。

该模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如下载或保存等）。

该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_values (torch.FloatTensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库(pip install soundfile)。要将数组准备成input_values，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2Processor.call()。
• attention_mask (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 用于避免在填充标记索引上执行卷积和注意力的遮罩。遮罩值选择在[0, 1]范围内：
  • 1 表示未被遮蔽的标记，
  • 0 表示被遮蔽的标记。

  什么是注意力遮罩？

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含各种元素，具体取决于配置（SEWDConfig）和输入。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 分类（或如果config.num_labels==1则为回归）损失。
• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（或如果config.num_labels==1则为回归）得分（SoftMax 之前）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有一个嵌入层， 一个用于每个层的输出）。 模型在每个层的输出的隐藏状态加上可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

SEWDForSequenceClassification 的前向方法重写了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoFeatureExtractor, SEWDForSequenceClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("anton-l/sew-d-mid-400k-ft-keyword-spotting")
>>> model = SEWDForSequenceClassification.from_pretrained("anton-l/sew-d-mid-400k-ft-keyword-spotting")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.argmax(logits, dim=-1).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'_unknown_'

>>> # compute loss - target_label is e.g. "down"
>>> target_label = model.config.id2label[0]
>>> inputs["labels"] = torch.tensor([model.config.label2id[target_label]])
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
3.16

Speech2Text

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/speech_to_text

概述

Speech2Text 模型是由 Changhan Wang、Yun Tang、Xutai Ma、Anne Wu、Dmytro Okhonko、Juan Pino 在fairseq S2T: Fast Speech-to-Text Modeling with fairseq中提出的。这是一个基于 transformer 的 seq2seq（编码器-解码器）模型，专为端到端的自动语音识别（ASR）和语音翻译（ST）而设计。它使用卷积下采样器将语音输入的长度减少 3/4，然后将其馈送到编码器中。该模型使用标准的自回归交叉熵损失进行训练，并自回归生成转录/翻译。Speech2Text 已经在多个数据集上进行了 ASR 和 ST 的微调：LibriSpeech、CoVoST 2、MuST-C。

这个模型是由valhalla贡献的。原始代码可以在这里找到。

推断

Speech2Text 是一个接受从语音信号中提取的对数梅尔滤波器组特征的浮点张量的语音模型。它是一个基于 transformer 的 seq2seq 模型，因此转录/翻译是自回归生成的。generate()方法可用于推断。

Speech2TextFeatureExtractor 类负责提取对数梅尔滤波器组特征。Speech2TextProcessor 将 Speech2TextFeatureExtractor 和 Speech2TextTokenizer 封装成一个单一实例，用于提取输入特征和解码预测的标记 id。

特征提取器依赖于torchaudio，分词器依赖于sentencepiece，因此在运行示例之前，请确保安装这些软件包。您可以使用pip install transformers"[speech, sentencepiece]"将它们作为额外的语音依赖项安装，或者使用pip install torchaudio sentencepiece分别安装这些软件包。此外，torchaudio需要libsndfile软件包的开发版本，可以通过系统软件包管理器安装。在 Ubuntu 上，可以按照以下方式安装：apt install libsndfile1-dev

• ASR 和语音翻译

代码语言：javascript复制

>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset

>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")

>>> inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt")
>>> generated_ids = model.generate(inputs["input_features"], attention_mask=inputs["attention_mask"])

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription
['mister quilter is the apostle of the middle classes and we are glad to welcome his gospel']

• 多语言语音翻译 对于多语言语音翻译模型，eos_token_id被用作decoder_start_token_id，目标语言 id 被强制作为第一个生成的标记。要将目标语言 id 强制作为第一个生成的标记，请将forced_bos_token_id参数传递给generate()方法。以下示例展示了如何使用facebook/s2t-medium-mustc-multilingual-st检查点将英语语音翻译为法语文本。

代码语言：javascript复制

>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset

>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-medium-mustc-multilingual-st")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-medium-mustc-multilingual-st")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")

>>> inputs = processor(ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt")
>>> generated_ids = model.generate(
...     inputs["input_features"],
...     attention_mask=inputs["attention_mask"],
...     forced_bos_token_id=processor.tokenizer.lang_code_to_id["fr"],
... )

>>> translation = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> translation
["(Vidéo) Si M. Kilder est l'apossible des classes moyennes, et nous sommes heureux d'être accueillis dans son évangile."]

查看model hub以查找 Speech2Text 检查点。

Speech2TextConfig

class transformers.Speech2TextConfig

< source >

代码语言：javascript复制

( vocab_size = 10000 encoder_layers = 12 encoder_ffn_dim = 2048 encoder_attention_heads = 4 decoder_layers = 6 decoder_ffn_dim = 2048 decoder_attention_heads = 4 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 scale_embedding = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 max_source_positions = 6000 max_target_positions = 1024 num_conv_layers = 2 conv_kernel_sizes = (5, 5) conv_channels = 1024 input_feat_per_channel = 80 input_channels = 1 **kwargs )

参数

• vocab_size (int, 可选, 默认为 10000) — Speech2Text 模型的词汇量。定义了在调用 Speech2TextModel 时可以表示的不同标记数量。
• encoder_layers (int, 可选, 默认为 12) — 编码器层数。
• encoder_ffn_dim (int, optional, defaults to 2048) — 编码器中“中间”（通常称为前馈）层的维度。
• encoder_attention_heads (int, optional, defaults to 4) — Transformer 编码器中每个注意力层的注意力头数。
• decoder_layers (int, optional, defaults to 6) — 解码器层数。
• decoder_ffn_dim (int, optional, defaults to 2048) — 解码器中“中间”（通常称为前馈）层的维度。
• decoder_attention_heads (int, optional, defaults to 4) — Transformer 解码器中每个注意力层的注意力头数。
• encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。更多细节请参阅LayerDrop paper。
• decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。更多细节请参阅LayerDrop paper。
• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
• is_encoder_decoder (bool, optional, defaults to True) — 模型是否设置为编码器-解码器架构，用于序列到序列任务。
• activation_function (str or function, optional, defaults to "relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• d_model (int, optional, defaults to 256) — 层和池化层的维度。
• dropout (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。
• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢弃比率。
• activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的丢弃比率。
• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• decoder_start_token_id (int, optional, defaults to 2) — 解码器在解码序列时的初始标记 ID。
• scale_embedding (bool, optional, defaults to True) — 是否通过d_model的平方根对嵌入进行缩放。
• pad_token_id (int, optional, defaults to 1) — 填充标记 ID。
• bos_token_id (int, optional, defaults to 0) — 序列开始标记的 ID。
• eos_token_id (int, optional, defaults to 2) — 终止序列标记的 ID。
• max_source_positions (int, optional, defaults to 6000) — 该模型可能使用的对数梅尔滤波器组特征的最大序列长度。
• max_target_positions (int, optional, defaults to 1024) — 该模型可能使用的最大序列长度。通常，设置为较大的值以防万一（例如，512 或 1024 或 2048）。
• num_conv_layers (int, optional, defaults to 2) — 卷积模块中的 1D 卷积层数。
• conv_kernel_sizes (Tuple[int], optional, defaults to (5, 5)) — 定义卷积模块中每个 1D 卷积层的内核大小的整数元组。conv_kernel_sizes的长度必须与num_conv_layers匹配。
• conv_channels (int, optional, defaults to 1024) — 定义卷积模块中除最后一个卷积层外每个卷积层的输出通道数的整数。
• input_feat_per_channel (int, optional, defaults to 80) — 指定特征向量大小的整数。这也是对数梅尔滤波器组特征的维度。
• input_channels (int, optional, defaults to 1) — 指定输入特征向量的输入通道数的整数。

这是用于存储 Speech2TextModel 配置的配置类。它用于根据指定的参数实例化一个 Speech2Text 模型，定义模型架构。使用默认值实例化配置将产生类似于 Speech2Text facebook/s2t-small-librispeech-asr 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

代码语言：javascript复制

>>> from transformers import Speech2TextConfig, Speech2TextModel

>>> # Initializing a Speech2Text s2t_transformer_s style configuration
>>> configuration = Speech2TextConfig()

>>> # Initializing a model (with random weights) from the s2t_transformer_s style configuration
>>> model = Speech2TextModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

Speech2TextTokenizer

class transformers.Speech2TextTokenizer

< source >

代码语言：javascript复制

( vocab_file spm_file bos_token = '<s>' eos_token = '</s>' pad_token = '<pad>' unk_token = '<unk>' do_upper_case = False do_lower_case = False tgt_lang = None lang_codes = None additional_special_tokens = None sp_model_kwargs: Optional = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。
• spm_file (str) — SentencePiece模型文件的路径
• bos_token (str, optional, 默认为 "<s>") — 句子开头标记。
• eos_token (str, optional, 默认为 "</s>") — 句子结束标记。
• unk_token (str, optional, 默认为 "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
• pad_token (str, optional, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• do_upper_case (bool, optional, 默认为 False) — 解码时是否将输出大写。
• do_lower_case (bool, optional, 默认为 False) — 分词时是否将输入转换为小写。
• tgt_lang (str, optional) — 表示目标语言的字符串。
• sp_model_kwargs (dict, optional) — 将传递给SentencePieceProcessor.__init__()方法。SentencePiece 的 Python 包装器可用于设置：
  • enable_sampling: 启用子词正则化。
  • nbest_size: 用于 unigram 抽样的抽样参数。对于 BPE-Dropout 无效。
    • nbest_size = {0,1}: 不执行抽样。
    • nbest_size > 1: 从 nbest_size 结果中抽样。
    • nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤和后向抽样算法从所有假设（格子）中抽样。
  • alpha: unigram 抽样的平滑参数，以及 BPE-dropout 合并操作的丢失概率。

  **kwargs — 传递给 PreTrainedTokenizer 的其他关键字参数

构建一个 Speech2Text 分词器。

这个分词器继承自 PreTrainedTokenizer，其中包含一些主要方法。用户应参考超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

< source >

代码语言：javascript复制

( token_ids_0 token_ids_1 = None )

通过附加 eos_token_id 从序列构建模型输入。

get_special_tokens_mask

< source >

代码语言：javascript复制

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
• token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。
• already_has_special_tokens (bool, optional, 默认为 False) — 标记列表是否已经使用特殊标记格式化为模型。

返回

List[int]

一个整数列表，范围为[0, 1]：1 表示特殊令牌，0 表示序列令牌。

从没有添加特殊令牌的令牌列表中检索序列 ID。当使用 tokenizer 的prepare_for_model方法添加特殊令牌时，会调用此方法。

create_token_type_ids_from_sequences

<来源>

代码语言：javascript复制

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— 第一个标记化序列。
• token_ids_1（List[int]，可选）— 第二个标记化序列。

返回

List[int]

令牌类型 ID。

创建与传递的序列对应的令牌类型 ID。什么是令牌类型 ID？

如果模型有特殊的构建方式，应该在子类中重写。

save_vocabulary

<来源>

代码语言：javascript复制

( save_directory: str filename_prefix: Optional = None )

Speech2TextFeatureExtractor

class transformers.Speech2TextFeatureExtractor

<来源>

代码语言：javascript复制

( feature_size = 80 sampling_rate = 16000 num_mel_bins = 80 padding_value = 0.0 do_ceptral_normalize = True normalize_means = True normalize_vars = True **kwargs )

参数

• feature_size（int，可选，默认为 80）— 提取特征的特征维度。
• sampling_rate（int，可选，默认为 16000）— 音频文件应数字化的采样率，以赫兹（Hz）表示。
• num_mel_bins（int，可选，默认为 80）— Mel 频率箱的数量。
• padding_value（float，可选，默认为 0.0）— 用于填充填充向量的值。
• do_ceptral_normalize（bool，可选，默认为True）— 是否对提取的特征应用语句级别的倒谱均值和方差归一化。
• normalize_means（bool，可选，默认为True）— 是否对提取的特征进行零均值归一化。
• normalize_vars（bool，可选，默认为True）— 是否对提取的特征进行单位方差归一化。

构建一个 Speech2Text 特征提取器。

这个特征提取器继承自 Speech2TextFeatureExtractor，其中包含大部分主要方法。用户应该参考这个超类以获取有关这些方法的更多信息。

这个类从原始语音中提取 mel 滤波器组特征，如果安装了 TorchAudio 则使用 TorchAudio，否则使用 numpy，并对提取的特征应用语句级别的倒谱均值和方差归一化。

__call__

<来源>

代码语言：javascript复制

( raw_speech: Union padding: Union = False max_length: Optional = None truncation: bool = False pad_to_multiple_of: Optional = None return_tensors: Union = None sampling_rate: Optional = None return_attention_mask: Optional = None **kwargs )

参数

• raw_speech（np.ndarray，List[float]，List[np.ndarray]，List[List[float]]）— 要填充的序列或批次序列。每个序列可以是一个 numpy 数组，一个浮点值列表，一个 numpy 数组列表或一个浮点值列表的列表。必须是单声道音频，不是立体声，即每个时间步长一个浮点数。
• padding（bool，str或 PaddingStrategy，可选，默认为True）— 选择一种策略来填充返回的序列（根据模型的填充方向和填充索引）：
  • True或'longest'：填充到批次中最长的序列（如果只提供一个序列，则不填充）。
  • 'max_length'：填充到指定的最大长度，使用参数max_length或者如果未提供该参数，则填充到模型的最大可接受输入长度。
  • False或'do_not_pad'（默认）：无填充（即，可以输出长度不同的序列批次）。
• max_length（int，可选）— 返回列表的最大长度和可选填充长度（见上文）。
• truncation (bool) — 激活截断，将输入序列截断到 max_length 以上的长度为 max_length。
• pad_to_multiple_of (int, 可选) — 如果设置，将序列填充到提供的值的倍数。 这对于启用 NVIDIA 硬件上的 Tensor Cores（计算能力 >= 7.5（Volta））或从序列长度为 128 的倍数中受益的 TPU 特别有用。
• return_attention_mask (bool, 可选) — 是否返回注意力遮罩。如果保持默认设置，将根据特定 feature_extractor 的默认设置返回注意力遮罩。 什么是注意力遮罩？ 对于 Speech2TextTransformer 模型，应始终传递 attention_mask 进行批量推断，以避免细微错误。
• return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
  • 'tf': 返回 TensorFlow tf.constant 对象。
  • 'pt': 返回 PyTorch torch.Tensor 对象。
  • 'np': 返回 Numpy np.ndarray 对象。
• sampling_rate (int, 可选) — 输入 raw_speech 的采样率。强烈建议在前向调用时传递 sampling_rate 以防止潜在错误。
• padding_value (float, 默认为 0.0) — 用于填充填充值/向量的值。

对一个或多个序列进行特征化和准备模型的主要方法。

Speech2TextProcessor

class transformers.Speech2TextProcessor

<来源>

代码语言：javascript复制

( feature_extractor tokenizer )

参数

• feature_extractor (Speech2TextFeatureExtractor) — Speech2TextFeatureExtractor 的实例。特征提取器是必需的输入。
• tokenizer (Speech2TextTokenizer) — Speech2TextTokenizer 的实例。分词器是必需的输入。

构建一个 Speech2Text 处理器，将 Speech2Text 特征提取器和 Speech2Text 分词器封装成单个处理器。

Speech2TextProcessor 提供了 Speech2TextFeatureExtractor 和 Speech2TextTokenizer 的所有功能。查看 call() 和 decode() 获取更多信息。

__call__

<来源>

代码语言：javascript复制

( *args **kwargs )

在正常模式下使用时，此方法将所有参数转发到 Speech2TextFeatureExtractor 的 call() 并返回其输出。如果在上下文中使用 as_target_processor()，此方法将所有参数转发到 Speech2TextTokenizer 的 call()。请参考上述两种方法的文档以获取更多信息。

from_pretrained

<来源>

代码语言：javascript复制

( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )

参数

• pretrained_model_name_or_path (str 或 os.PathLike) — 可以是：
  • 一个字符串，预训练特征提取器的 模型 id，托管在 huggingface.co 上的模型存储库中。有效的模型 id 可以位于根级别，如 bert-base-uncased，或者在用户或组织名称下命名空间化，如 dbmdz/bert-base-german-cased。
  • 一个 目录 的路径，其中包含使用 save_pretrained() 方法保存的特征提取器文件，例如，./my_model_directory/。
  • 一个保存的特征提取器 JSON 文件 的路径或 URL，例如，./my_model_directory/preprocessor_config.json。**kwargs — 传递给 from_pretrained() 和 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 的额外关键字参数。

实例化与预训练模型相关联的处理器。

此类方法只是调用特征提取器的 from_pretrained()、图像处理器 ImageProcessingMixin 和标记器 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 方法。有关更多信息，请参阅上述方法的文档字符串。

save_pretrained

<来源>

代码语言：javascript复制

( save_directory push_to_hub: bool = False **kwargs )

参数

• save_directory (str 或 os.PathLike) — 将保存特征提取器 JSON 文件和标记器文件的目录（如果目录不存在，则将创建该目录）。
• push_to_hub (bool, 可选, 默认为 False) — 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用 repo_id 指定要推送到的存储库（将默认为您的命名空间中的 save_directory 名称）。
• kwargs (Dict[str, Any], 可选) — 传递给 push_to_hub() 方法的额外关键字参数。

将此处理器的属性（特征提取器、标记器等）保存在指定目录中，以便可以使用 from_pretrained() 方法重新加载。

此类方法只是调用 save_pretrained() 和 save_pretrained()。有关更多信息，请参阅上述方法的文档字符串。

batch_decode

<来源>

代码语言：javascript复制

( *args **kwargs )

此方法将其所有参数转发到 Speech2TextTokenizer 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。

decode

<来源>

代码语言：javascript复制

( *args **kwargs )

此方法将其所有参数转发到 Speech2TextTokenizer 的 decode()。有关更多信息，请参阅此方法的文档字符串。

PytorchHide Pytorch 内容

Speech2TextModel

transformers.Speech2TextModel 类

<来源>

代码语言：javascript复制

( config: Speech2TextConfig )

参数

• config（Speech2TextConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的 Speech2Text 模型，在顶部没有特定头部输出原始隐藏状态。该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头部等）。

该模型也是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

代码语言：javascript复制

( input_features: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_features（torch.FloatTensor，形状为 (batch_size, sequence_length, feature_size)）— 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到类型为 List[float] 或 numpy.ndarray 的数组中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成 input_features，应使用 AutoFeatureExtractor 来提取 fbank 特征、填充和转换为 torch.FloatTensor 类型的张量。参见 call()
• attention_mask（torch.Tensor，形状为 (batch_size, sequence_length)，可选）— 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选在 [0, 1]：
  • 1 表示被 not masked 的标记。
  • 0 表示被 masked 的标记。

  什么是注意力掩码？

• decoder_input_ids（torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选）— 词汇表中解码器输入序列标记的索引。 可以使用 SpeechToTextTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ SpeechToText 使用 eos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，则可选择只输入最后的 decoder_input_ids（参见 past_key_values）。
• decoder_attention_mask（torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选）— 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。因果掩码也将默认使用。 如果要更改填充行为，应阅读 modeling_speech_to_text._prepare_decoder_attention_mask 并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。
• head_mask（torch.Tensor，形状为 (encoder_layers, encoder_attention_heads)，可选）— 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选在 [0, 1]：
  • 1 表示头部未被 masked，
  • 0 表示头部被 masked。
• decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使解码器中注意力模块中选择的头部失效的掩码。选择的掩码值在[0, 1]中：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使交叉注意力模块中选择的头部失效的掩码。选择的掩码值在[0, 1]中：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的元组，每个元组有 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输入）。 如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为 (batch_size, 1)，而不是所有decoder_input_ids的形状为 (batch_size, sequence_length)。
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则只需输入最后的decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• use_cache (bool, optional) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_outputs.Seq2SeqLMOutput 或 torch.FloatTensor 元组

transformers.modeling_outputs.Seq2SeqLMOutput 或 torch.FloatTensor 元组（如果传递return_dict=False或当config.return_dict=False时）包含各种元素，取决于配置（Speech2TextConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失。
• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入的输出 每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。 解码器在每个层的输出隐藏状态加上初始嵌入输出。
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor 元组（每个层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递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)，optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入的输出 每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。 编码器在每个层的输出隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor 元组（每个层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

Speech2TextModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import Speech2TextModel, AutoFeatureExtractor
>>> from datasets import load_dataset

>>> model = Speech2TextModel.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 256]

Speech2TextForConditionalGeneration

class transformers.Speech2TextForConditionalGeneration

<来源>

代码语言：javascript复制

( config: Speech2TextConfig )

参数

• config (Speech2TextConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

带有语言建模头的 Speech2Text 模型。可用于摘要。此模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_features: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_features (torch.FloatTensor of shape (batch_size, sequence_length, feature_size)) — 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_features，应使用 AutoFeatureExtractor 来提取 fbank 特征，填充并转换为torch.FloatTensor类型的张量。参见call()
• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值在 [0, 1] 中选择：
  • 对于未被masked的标记为 1。
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。 可以使用SpeechToTextTokenizer获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ SpeechToText 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需选择最后的decoder_input_ids作为输入（参见past_key_values）。
• decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。 如果您想要更改填充行为，您应该阅读modeling_speech_to_text._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图表 1。
• head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于将编码器中注意力模块的选定头部置零的掩码。掩码值在 [0, 1] 中选择：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于在解码器中使注意力模块中的选定头部失效的遮罩。在[0, 1]中选择的遮罩值：
  • 1 表示头部未被遮罩，
  • 0 表示头部被遮罩。
• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使交叉注意力模块中的选定头部失效的遮罩。在[0, 1]中选择的遮罩值：
  • 1 表示头部未被遮罩，
  • 0 表示头部被遮罩。
• encoder_outputs（tuple(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))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的元组，每个元组有 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_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，可以直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，则只需输入最后的decoder_inputs_embeds（参见past_key_values）。如果要更好地控制如何将decoder_input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100（参见input_ids文档字符串）。将索引设置为-100的标记将被忽略（遮罩），损失仅计算具有[0, ..., config.vocab_size]标签的标记。

返回

transformers.modeling_outputs.Seq2SeqLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（Speech2TextConfig）和输入。

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 语言建模损失。
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出 每层的输出）。 解码器在每一层输出的隐藏状态以及初始嵌入输出。
• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出 每层的输出）。 编码器在每一层输出的隐藏状态以及初始嵌入输出。
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

Speech2TextForConditionalGeneration 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数中定义，但应该在此之后调用Module实例，而不是这个函数，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import Speech2TextProcessor, Speech2TextForConditionalGeneration
>>> from datasets import load_dataset

>>> model = Speech2TextForConditionalGeneration.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> inputs = processor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features

>>> generated_ids = model.generate(inputs=input_features)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
'mister quilter is the apostle of the middle classes and we are glad to welcome his gospel'

TensorFlow 隐藏 TensorFlow 内容

TFSpeech2TextModel

class transformers.TFSpeech2TextModel

<来源>

代码语言：javascript复制

( config: Speech2TextConfig *inputs **kwargs )

参数

• config（Speech2TextConfig） - 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

裸的 Speech2Text 模型，输出没有特定头部的原始隐藏状态。此模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型也是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

transformers中的 TensorFlow 模型和层接受两种输入格式：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，在使用诸如model.fit()之类的方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递您的输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 Keras 的Functional API 创建自己的层或模型时，有三种可能性可用于收集所有输入张量在第一个位置参数中：

• 一个仅包含input_ids的单个张量，没有其他内容：model(input_ids)
• 一个长度不定的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些内容，因为您可以像对待任何其他 Python 函数一样传递输入！

call

<来源>

代码语言：javascript复制

( input_features: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqModelOutput or tuple(tf.Tensor)

参数

• input_features（形状为(batch_size, sequence_length, feature_size)的tf.Tensor）- 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要准备好数组为input_features，应使用 AutoFeatureExtractor 来提取 fbank 特征，填充并转换为浮点数张量。参见call()
• attention_mask（形状为({0})的tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：
  • 1 表示未被掩盖的标记，
  • 0 表示标记被掩盖。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 词汇表中解码器输入序列标记的索引。 可以使用 Speech2TextTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ SpeechToText 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，可以选择仅输入最后的decoder_input_ids（参见past_key_values）。 对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，用于去噪预训练，遵循论文中的方法。
• decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 默认情况下将被创建并忽略填充标记。不建议在大多数用例中设置此项。
• head_mask（形状为(encoder_layers, encoder_attention_heads)的tf.Tensor，可选）- 用于使编码器中的选定注意力模块头部失效的掩码。选择的掩码值在[0, 1]中。
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）- 用于使解码器中的选定注意力模块头部失效的掩码。选择的掩码值在[0, 1]中。
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）- 用于使交叉注意力模块中的选定头部失效的掩码。选择的掩码值在[0, 1]中。
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• encoder_outputs（tf.FloatTensor，可选）- 编码器最后一层的隐藏状态的输出。用于解码器的交叉注意力。形状为(batch_size, sequence_length, hidden_size)的序列
• past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）- 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（即那些没有将其过去键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的tf.FloatTensor，可选）— 可选地，可以直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则只需输入最后的decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅可在急切模式下使用，在图模式下将使用配置中的值。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅可在急切模式下使用，在图模式下将使用配置中的值。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回值

transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时）包含不同元素，取决于配置（Speech2TextConfig）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型解码器最后一层的隐藏状态序列。 如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
• past_key_values（List[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。 包含可用于加速顺序解码的解码器的预计算隐藏状态（注意力块中的键和值）。
• decoder_hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出，一个用于每层的输出）。 解码器在每一层输出的隐藏状态加上初始嵌入输出。
• decoder_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回）— 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每个层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor，可选）— 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回）— 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入的输出 一个用于每个层的输出）。 编码器在每个层的输出隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回）— 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每个层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

TFSpeech2TextModel 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, TFSpeech2TextModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/s2t-small-librispeech-asr")
>>> model = TFSpeech2TextModel.from_pretrained("facebook/s2t-small-librispeech-asr")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFSpeech2TextForConditionalGeneration

class transformers.TFSpeech2TextForConditionalGeneration

<来源>

代码语言：javascript复制

( config: Speech2TextConfig )

参数

• config（Speech2TextConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

具有语言建模头的语音到文本模型。可用于摘要。此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

此模型也是 tf.keras.Model 的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

transformers 中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用 model.fit() 等方法时，应该可以“正常工作” - 只需以 model.fit() 支持的任何格式传递输入和标签即可！但是，如果要在 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可用于收集所有输入张量在第一个位置参数中：

• 一个仅包含input_ids的单个张量，没有其他内容：model(input_ids)
• 一个长度可变的列表，包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
• 一个字典，包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些内容，因为您可以像对待其他 Python 函数一样传递输入！

call

<来源>

代码语言：javascript复制

( input_features: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False **kwargs ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqLMOutput or tuple(tf.Tensor)

参数

• input_features（形状为(batch_size, sequence_length, feature_size)的tf.Tensor）- 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将.flac或.wav音频文件加载到类型为List[float]或numpy.ndarray的数组中获得，例如通过 soundfile 库（pip install soundfile）。为准备好数组以获得input_features，应使用 AutoFeatureExtractor 来提取 fbank 特征，填充并转换为浮点数张量。参见call()
• attention_mask（形状为({0})的tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力。掩码值选定在[0, 1]之间：
  • 1 表示未被掩盖的标记，
  • 对于被掩盖的标记为 0。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 词汇表中解码器输入序列标记的索引。 可以使用 Speech2TextTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是解码器输入 ID？ 语音转文本使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可选择只输入最后的decoder_input_ids（参见past_key_values）。 对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，用于去噪预训练，遵循论文。
• decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 默认情况下将忽略填充标记。不建议在大多数情况下设置此项。
• head_mask（形状为(encoder_layers, encoder_attention_heads)的tf.Tensor，可选）- 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）- 用于使解码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的tf.Tensor，可选）- 用于使交叉注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• encoder_outputs (tf.FloatTensor, optional) — 编码器最后一层输出的隐藏状态。用于解码器的交叉注意力。形状为(batch_size, sequence_length, hidden_size)的序列
• past_key_values (Tuple[Tuple[tf.Tensor]] of length config.n_layers) — 包含预先计算的注意力块的键和值隐藏状态。可用于加速解码。如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)而不是所有decoder_input_ids的形状为(batch_size, sequence_length)。
• decoder_inputs_embeds (tf.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示而不是传递decoder_input_ids。如果使用了past_key_values，可以选择仅输入最后的decoder_inputs_embeds（请参阅past_key_values）。如果要更好地控制如何将decoder_input_ids索引转换为相关向量，这比模型内部的嵌入查找矩阵更有用。
• use_cache (bool, optional) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量中的attentions。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量中的hidden_states。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。此参数在急切模式下使用，在图模式中该值将始终设置为 True。
• training (bool, optional, 默认为False) — 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估之间有不同的行为）。
• labels (tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100 之间（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一组tf.Tensor（如果传递return_dict=False或当config.return_dict=False时）包括根据配置（Speech2TextConfig）和输入的不同元素。

• loss (tf.Tensor of shape (n,), optional, 其中 n 是非屏蔽标签的数量，在提供labels时返回) — 语言建模损失。
• logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• past_key_values (List[tf.Tensor], optional, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。 包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见 past_key_values 输入）。
• decoder_hidden_states (tuple(tf.Tensor), optional, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入输出，一个用于每层输出）。 每层解码器的隐藏状态加上初始嵌入输出。
• decoder_attentions (tuple(tf.Tensor), optional, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(tf.Tensor), optional, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(tf.Tensor), optional, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入输出，一个用于每层输出）。 每层编码器的隐藏状态加上初始嵌入输出。
• encoder_attentions (tuple(tf.Tensor), optional, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

TFSpeech2TextForConditionalGeneration 的前向方法重写了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例，而不是这个，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> import tensorflow as tf
>>> from transformers import Speech2TextProcessor, TFSpeech2TextForConditionalGeneration
>>> from datasets import load_dataset
>>> import soundfile as sf

>>> model = TFSpeech2TextForConditionalGeneration.from_pretrained(
...     "facebook/s2t-small-librispeech-asr", from_pt=True
... )
>>> processor = Speech2TextProcessor.from_pretrained("facebook/s2t-small-librispeech-asr")

>>> def map_to_array(batch):
...     speech, _ = sf.read(batch["file"])
...     batch["speech"] = speech
...     return batch

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> ds.set_format(type="tf")

>>> input_features = processor(
...     ds["speech"][0], sampling_rate=16000, return_tensors="tf"
... ).input_features  # Batch size 1
>>> generated_ids = model.generate(input_features)

>>> transcription = processor.batch_decode(generated_ids)

语音 翻译 模型 配置 索引

0 人点赞