Transformers--4-37-中文文档-四十-

Transformers 4.37 中文文档（四十）

原文：huggingface.co/docs/transformers

Wav2Vec2-BERT

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/wav2vec2-bert

概述

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

该模型在超过 143 种语言的 450 万小时未标记音频数据上进行了预训练。需要微调才能用于下游任务，如自动语音识别（ASR）或音频分类。

模型的官方结果可在论文的第 3.2.1 节中找到。

论文摘要如下：

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

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

使用提示

• Wav2Vec2-BERT 遵循与 Wav2Vec2-Conformer 相同的架构，但采用因果深度卷积层，并使用音频的梅尔频谱表示作为输入，而不是原始波形。

• Wav2Vec2-BERT 可以通过设置正确的config.position_embeddings_type来使用无相对位置嵌入、类似 Shaw 的位置嵌入、类似 Transformer-XL 的位置嵌入或旋转位置嵌入。

• Wav2Vec2-BERT 还引入了基于 Conformer 的适配器网络，而不是简单的卷积网络。

资源

自动语音识别

• Wav2Vec2BertForCTC 可以通过这个示例脚本来支持。

• 您还可以在如何在英语中微调语音识别模型和如何在任何语言中微调语音识别模型上调整这些笔记本。

音频分类

• Wav2Vec2BertForSequenceClassification 可以通过调整这个示例脚本来使用。

• 另请参阅：音频分类任务指南

Wav2Vec2BertConfig

class transformers.Wav2Vec2BertConfig

<来源>

( vocab_size = None hidden_size = 1024 num_hidden_layers = 24 num_attention_heads = 16 intermediate_size = 4096 feature_projection_input_dim = 160 hidden_act = 'swish' hidden_dropout = 0.0 activation_dropout = 0.0 attention_dropout = 0.0 feat_proj_dropout = 0.0 final_dropout = 0.1 layerdrop = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 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 = 'sum' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 768 tdnn_dim = (512, 512, 512, 512, 1500) tdnn_kernel = (5, 3, 3, 1, 1) tdnn_dilation = (1, 2, 3, 1, 1) xvector_output_dim = 512 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 add_adapter = False adapter_kernel_size = 3 adapter_stride = 2 num_adapter_layers = 1 adapter_act = 'relu' use_intermediate_ffn_before_adapter = False output_hidden_size = None position_embeddings_type = 'relative_key' rotary_embedding_base = 10000 max_source_positions = 5000 left_max_position_embeddings = 64 right_max_position_embeddings = 8 conv_depthwise_kernel_size = 31 conformer_conv_dropout = 0.1 **kwargs )

参数

• vocab_size（int，可选）—Wav2Vec2Bert 模型的词汇量。定义了在调用 Wav2Vec2BertModel 时可以表示的不同令牌的数量。模型的词汇量。定义了可以由传递给 Wav2Vec2BertModel 的inputs_ids表示的不同令牌。

• hidden_size（int，可选，默认为 1024）—编码器层和池化器层的维度。

• num_hidden_layers（int，可选，默认为 24）—Transformer 编码器中的隐藏层数。

• num_attention_heads（int，可选，默认为 16）—Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size（int，可选，默认为 4096）—Transformer 编码器中“中间”（即前馈）层的维度。

• feature_projection_input_dim（int，可选，默认为 160）—此模型的输入维度，即使用 SeamlessM4TFeatureExtractor 或 Wav2Vec2BertProcessor 处理输入音频后的维度。

• hidden_act（str或function，可选，默认为"swish"）—编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"、"swish"和"gelu_new"。

• hidden_dropout（float，可选，默认为 0.0）—嵌入层、编码器和池化器中所有全连接层的丢失概率。

• activation_dropout（float，可选，默认为 0.0）—全连接层内激活的丢失比率。

• attention_dropout（float，可选，默认为 0.0）—注意力概率的丢失比率。

• feat_proj_dropout（float，可选，默认为 0.0）—特征投影的丢失概率。

• final_dropout (float, optional, defaults to 0.1) — Wav2Vec2BertForCTC 最终投影层的丢弃概率。

• layerdrop (float, optional, defaults to 0.1) — LayerDrop 概率。更多细节请参阅 LayerDrop 论文)。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon 值。

• apply_spec_augment (bool, optional, defaults to True) — 是否对特征编码器的输出应用 SpecAugment 数据增强。有关详细信息，请参阅 SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。

• mask_time_prob (float, optional, defaults to 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, defaults to 10) — 沿时间轴的向量跨度长度。

• mask_time_min_masks (int, optional, defaults to 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_prob*len(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 输出的减少方式。只有在训练 Wav2Vec2BertForCTC 实例时才相关。

• ctc_zero_infinity (bool, optional, defaults to False) — 是否将无限损失和 torch.nn.CTCLoss 的相关梯度置零。当输入太短无法与目标对齐时，主要会出现无限损失。只有在训练 Wav2Vec2BertForCTC 实例时才相关。

• use_weighted_layer_sum (bool, optional, defaults to False) — 是否使用具有学习权重的层输出的加权平均值。只有在使用 Wav2Vec2BertForSequenceClassification 实例时才相关。

• classifier_proj_size (int, optional, defaults to 768) — 用于分类的令牌均值池化之前的投影的维度。

• tdnn_dim (Tuple[int] or List[int], optional, defaults to (512, 512, 512, 512, 1500)) — 一个整数元组，定义了 XVector 模型中 TDNN 模块中每个 1D 卷积层的输出通道数。tdnn_dim 的长度定义了 TDNN 层的数量。

• tdnn_kernel (Tuple[int] or List[int], optional, defaults to (5, 3, 3, 1, 1)) — 一个整数元组，定义了 XVector 模型中 TDNN 模块中每个 1D 卷积层的内核大小。tdnn_kernel 的长度必须与 tdnn_dim 的长度相匹配。

• tdnn_dilation (Tuple[int] or List[int], optional, defaults to (1, 2, 3, 1, 1)) — 一个整数元组，定义了 XVector 模型中 TDNN 模块中每个 1D 卷积层的膨胀因子。tdnn_dilation 的长度必须与 tdnn_dim 的长度相匹配。

• xvector_output_dim (int, optional, defaults to 512) — XVector 嵌入向量的维度。

• pad_token_id (int, optional, defaults to 0) — 开始流 标记的 id。

• bos_token_id (int, optional, defaults to 1) — 填充 标记的 id。

• eos_token_id (int, optional, defaults to 2) — 结束流 标记的 id。

• add_adapter (bool, optional, defaults to False) — 是否在 Wav2Vec2Bert 编码器顶部堆叠卷积注意力网络。对于为 SpeechEncoderDecoder 模型热启动 Wav2Vec2Bert 非常有用。

• adapter_kernel_size (int, optional, defaults to 3) — 适配器网络中卷积层的内核大小。只有在 add_adapter 为 True 时才相关。

• adapter_stride (int, optional, defaults to 2) — 适配器网络中卷积层的步幅。只有在 add_adapter 为 True 时才相关。

• num_adapter_layers (int, optional, defaults to 1) — 应在适配器网络中使用的卷积层的数量。只有在 add_adapter 为 True 时才相关。

• adapter_act (str or function, optional, defaults to "relu") — 适配器层中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu"、"swish" 和 "gelu_new"。

• use_intermediate_ffn_before_adapter (bool, optional, defaults to False) — 是否在 Wav2Vec2Bert 编码器顶部和适配器网络之前堆叠中间前馈块。只有在 add_adapter 为 True 时才相关。

• output_hidden_size (int, optional) — 编码器输出层的维度。如果未定义，则默认为 hidden-size。只有在 add_adapter 为 True 时才相关。

• position_embeddings_type (str, optional, defaults to "relative_key") — 可以指定为：

  • rotary，用于旋转位置嵌入。

  • relative，用于相对位置嵌入。

  • relative_key，用于由 Shaw 在 Self-Attention with Relative Position Representations (Shaw et al.) 中定义的相对位置嵌入。如果保留为 None，则不应用相对位置嵌入。

• rotary_embedding_base (int, optional, defaults to 10000) — 如果使用了 "rotary" 位置嵌入，定义了嵌入基数的大小。

• max_source_positions (int, optional, defaults to 5000) — 如果使用了 "relative" 位置嵌入，定义了最大源输入位置。

• left_max_position_embeddings (int, optional, defaults to 64) — 如果使用了 "relative_key"（又名 Shaw）位置嵌入，定义了相对位置的左剪切值。

• right_max_position_embeddings (int, optional, defaults to 8) — 如果使用了 "relative_key"（又名 Shaw）位置嵌入，定义了相对位置的右剪切值。

• conv_depthwise_kernel_size (int, optional, defaults to 31) — Conformer 块中深度可分离 1D 卷积层的内核大小。

• conformer_conv_dropout (float, 可选, 默认为 0.1) — Conformer 块中所有卷积层的丢弃概率。

这是用于存储 Wav2Vec2BertModel 配置的配置类。它用于根据指定的参数实例化 Wav2Vec2Bert 模型，定义模型架构。使用默认值实例化配置将产生类似于 Wav2Vec2Bert facebook/wav2vec2-bert-rel-pos-large架构的配置。

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

示例：

>>> from transformers import Wav2Vec2BertConfig, Wav2Vec2BertModel

>>> # Initializing a Wav2Vec2Bert facebook/wav2vec2-bert-rel-pos-large style configuration
>>> configuration = Wav2Vec2BertConfig()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-bert-rel-pos-large style configuration
>>> model = Wav2Vec2BertModel(configuration)

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

Wav2Vec2BertProcessor

class transformers.Wav2Vec2BertProcessor

<来源>

( feature_extractor tokenizer )

参数

• feature_extractor (SeamlessM4TFeatureExtractor) — SeamlessM4TFeatureExtractor 的实例。特征提取器是必需的输入。

• tokenizer (PreTrainedTokenizer) — PreTrainedTokenizer 的实例。Tokenizer 是必需的输入。

构建一个 Wav2Vec2-BERT 处理器，将 Wav2Vec2-BERT 特征提取器和 Wav2Vec2 CTC tokenizer 封装到单个处理器中。

Wav2Vec2Processor 提供了 SeamlessM4TFeatureExtractor 和 PreTrainedTokenizer 的所有功能。查看call()和 decode()的文档字符串以获取更多信息。

__call__

<来源>

( audio = None text = None **kwargs ) → export const metadata = 'undefined';BatchEncoding

参数

• text (str, List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果将序列提供为字符串列表（预分词），则必须设置is_split_into_words=True（以消除与序列批次的歧义）。

• audio (np.ndarray, torch.Tensor, List[np.ndarray], List[torch.Tensor]) — 要准备的音频或音频批次。每个音频可以是 NumPy 数组或 PyTorch 张量。在 NumPy 数组/PyTorch 张量的情况下，每个音频的形状应为（C，T），其中 C 是通道数，T 是音频的采样长度。

• kwargs (可选) — 将传递给特征提取器和/或 tokenizer 的剩余关键字参数字典。

返回

BatchEncoding

具有以下字段的 BatchEncoding：

• input_features — 要馈送给模型的音频输入特征。当audio不为None时返回。

• attention_mask — 指定当audio不为None时模型应关注哪些时间戳的索引列表。当仅指定text时，返回标记注意力掩码。

• labels — 要提供给模型的标记 id 列表。当text和audio都不是None时返回。

• input_ids — 要提供给模型的标记 id 列表。当text不是None且audio是None时返回。

准备模型一个或多个序列和音频的主要方法。如果audio不是None，则此方法将audio和kwargs参数转发给 SeamlessM4TFeatureExtractor 的call()以预处理音频。为了准备目标序列，如果text不是None，则此方法将text和kwargs参数转发给 PreTrainedTokenizer 的call()。更多信息请参考上述两个方法的文档字符串。

pad

<来源>

( input_features = None labels = None **kwargs )

如果input_features不是None，则此方法将input_features和kwargs参数转发给 SeamlessM4TFeatureExtractor 的 pad()以填充输入特征。如果labels不是None，则此方法将labels和kwargs参数转发给 PreTrainedTokenizer 的 pad()以填充标签。更多信息请参考上述两个方法的文档字符串。

from_pretrained

<来源>

( pretrained_model_name_or_path **kwargs )

save_pretrained

<来源>

( save_directory push_to_hub: bool = False **kwargs )

参数

• save_directory (str或os.PathLike) — 特征提取器 JSON 文件和标记器文件将保存在的目录（如果目录不存在，则将创建该目录）。

• push_to_hub (bool, optional, 默认为False) — 是否在保存模型后将其推送到 Hugging Face 模型中心。您可以使用repo_id指定要推送到的存储库（将默认为您的命名空间中的save_directory的名称）。

• kwargs (Dict[str, Any], optional) — 传递给 push_to_hub()方法的额外关键字参数。

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

此类方法简单地调用 save_pretrained()和 save_pretrained()。更多信息请参考上述方法的文档字符串。

batch_decode

<来源>

( *args **kwargs )

此方法将其所有参数转发给 PreTrainedTokenizer 的 batch_decode()。更多信息请参考此方法的文档字符串。

decode

<来源>

( *args **kwargs )

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

Wav2Vec2BertModel

类 transformers.Wav2Vec2BertModel

< source >

( config: Wav2Vec2BertConfig )

参数

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

裸 Wav2Vec2Bert 模型变压器输出原始隐藏状态，没有特定的顶部头。Wav2Vec2Bert 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 提出的wav2vec 2.0:自监督学习语音表示的框架。

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

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

前向

< source >

( input_features: 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.Wav2Vec2BaseModelOutput or tuple(torch.FloatTensor)

参数

• input_features (torch.FloatTensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要准备好数组为input_features，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2BertProcessor.call()。

• attention_mask (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]中：

  • 对于未屏蔽的标记，

  • 对于屏蔽的标记为 0。

  什么是注意力掩码？

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或者一个 torch.FloatTensor 元组（如果传入 return_dict=False 或者 config.return_dict=False）包含不同的元素，取决于配置（Wav2Vec2BertConfig）和输入。

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

• extract_features (torch.FloatTensor of shape (batch_size, sequence_length, conv_dim[-1])) — 模型最后一个卷积层提取的特征向量序列。

• 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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, Wav2Vec2BertModel
>>> 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("hf-audio/wav2vec2-bert-CV16-en")
>>> model = Wav2Vec2BertModel.from_pretrained("hf-audio/wav2vec2-bert-CV16-en")

>>> # 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, 146, 1024]

Wav2Vec2BertForCTC

class transformers.Wav2Vec2BertForCTC

< source >

( config target_lang: Optional = None )

参数

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

带有顶部 语言建模 头部的 Wav2Vec2Bert 模型，用于 Connectionist Temporal Classification (CTC)。Wav2Vec2Bert 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中由 Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli 提出。

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

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

forward

< source >

( input_features: 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_features (torch.FloatTensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库(pip install soundfile)。要将数组准备成input_features，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。详情请参见 Wav2Vec2BertProcessor.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, 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）包含各种元素，具体取决于配置（Wav2Vec2BertConfig）和输入。

• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, Wav2Vec2BertForCTC
>>> 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("hf-audio/wav2vec2-bert-CV16-en")
>>> model = Wav2Vec2BertForCTC.from_pretrained("hf-audio/wav2vec2-bert-CV16-en")

>>> # 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]
'mr quilter is the apostle 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)
17.04

Wav2Vec2BertForSequenceClassification

class transformers.Wav2Vec2BertForSequenceClassification

<来源>

( config )

参数

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

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

Wav2Vec2Bert 由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出。

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

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

forward

<来源>

( input_features: 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_features (torch.FloatTensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_features，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2BertProcessor.call()。

• attention_mask (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选在[0, 1]范围内：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 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）包含各种元素，取决于配置（Wav2Vec2BertConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 分类（如果 config.num_labels==1 则为回归）损失。

• logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, Wav2Vec2BertForSequenceClassification
>>> 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("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0")

>>> # 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]

>>> # 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

Wav2Vec2BertForAudioFrameClassification

class transformers.Wav2Vec2BertForAudioFrameClassification

< source >

( config )

参数

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

Wav2Vec2Bert 模型在顶部带有一个用于说话者分离等任务的帧分类头。

Wav2Vec2Bert 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 提出的，详见wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations。

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

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

forward

< source >

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

参数

• input_features（形状为(batch_size, sequence_length)的torch.FloatTensor）— 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_features，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2BertProcessor.call()。

• attention_mask（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选在[0, 1]范围内：

  • 对于not masked的标记为 1，

  • 对于masked的标记为 0。

  什么是注意力掩码？

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.TokenClassifierOutput 或torch.FloatTensor元组

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 分类损失。

• logits（形状为(batch_size, sequence_length, config.num_labels)的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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, Wav2Vec2BertForAudioFrameClassification
>>> 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("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForAudioFrameClassification.from_pretrained("facebook/w2v-bert-2.0")

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

>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()

Wav2Vec2BertForXVector

class transformers.Wav2Vec2BertForXVector

<来源>

( config )

参数

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

Wav2Vec2Bert 模型，顶部带有 XVector 特征提取头，用于说话者验证等任务。

Wav2Vec2Bert 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出的。

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

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

forward

<来源>

( input_features: 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.XVectorOutput or tuple(torch.FloatTensor)

参数

• input_features (torch.FloatTensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要准备好数组为input_features，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参见 Wav2Vec2BertProcessor.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.XVectorOutput 或tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 分类损失。

• logits (torch.FloatTensor，形状为(batch_size, config.xvector_output_dim)) — AMSoftmax 之前的分类隐藏状态。

• embeddings (torch.FloatTensor，形状为(batch_size, config.xvector_output_dim)) — 用于基于向量相似性检索的话语嵌入。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。

  模型在每个层的输出以及初始嵌入输出的隐藏状态。

• attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, Wav2Vec2BertForXVector
>>> 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("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForXVector.from_pretrained("facebook/w2v-bert-2.0")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
...     embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7  # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
...     print("Speakers are not the same!")

Wav2Vec2-Conformer

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

概述

Wav2Vec2-Conformer 是由 Changhan Wang、Yun Tang、Xutai Ma、Anne Wu、Sravya Popuri、Dmytro Okhonko、Juan Pino 在更新版本的fairseq S2T: Fast Speech-to-Text Modeling with fairseq中添加的。

模型的官方结果可以在论文的表 3 和表 4 中找到。

Wav2Vec2-Conformer 权重由 Meta AI 团队在Fairseq 库中发布。

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

使用提示

• Wav2Vec2-Conformer 遵循与 Wav2Vec2 相同的架构，但将Attention-block 替换为Conformer-block，如Conformer: Convolution-augmented Transformer for Speech Recognition中介绍的那样。

• 对于相同数量的层，Wav2Vec2-Conformer 比 Wav2Vec2 需要更多的参数，但也能提高词错误率。

• Wav2Vec2-Conformer 使用与 Wav2Vec2 相同的分词器和特征提取器。

• Wav2Vec2-Conformer 可以通过设置正确的config.position_embeddings_type来使用无相对位置嵌入、类似 Transformer-XL 的位置嵌入或旋转位置嵌入。

资源

• 音频分类任务指南

• 自动语音识别任务指南

Wav2Vec2ConformerConfig

class transformers.Wav2Vec2ConformerConfig

<来源>

( vocab_size = None hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout = 0.1 activation_dropout = 0.1 attention_dropout = 0.1 feat_proj_dropout = 0.0 feat_quantizer_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 = (512, 512, 512, 512, 512, 512, 512) conv_stride = (5, 2, 2, 2, 2, 2, 2) conv_kernel = (10, 3, 3, 3, 3, 2, 2) 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 num_codevectors_per_group = 320 num_codevector_groups = 2 contrastive_logits_temperature = 0.1 num_negatives = 100 codevector_dim = 256 proj_codevector_dim = 256 diversity_loss_weight = 0.1 ctc_loss_reduction = 'sum' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 tdnn_dim = (512, 512, 512, 512, 1500) tdnn_kernel = (5, 3, 3, 1, 1) tdnn_dilation = (1, 2, 3, 1, 1) xvector_output_dim = 512 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 add_adapter = False adapter_kernel_size = 3 adapter_stride = 2 num_adapter_layers = 3 output_hidden_size = None position_embeddings_type = 'relative' rotary_embedding_base = 10000 max_source_positions = 5000 conv_depthwise_kernel_size = 31 conformer_conv_dropout = 0.1 **kwargs )

参数

• vocab_size（int，可选）— Wav2Vec2Conformer 模型的词汇表大小。定义了在调用 Wav2Vec2ConformerModel 时可以表示的不同令牌数量。模型的词汇表大小。定义了可以由传递给 Wav2Vec2ConformerModel 的inputs_ids表示的不同令牌。

• hidden_size（int，可选，默认为 768）— 编码器层和池化层的维度。

• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数。

• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size（int，可选，默认为 3072）— Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act（str或function，可选，默认为"gelu"）— 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。

• hidden_dropout（float，可选，默认为 0.1）— 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• activation_dropout（float，可选，默认为 0.1）— 全连接层内部激活的 dropout 比率。

• attention_dropout（float，可选，默认为 0.1）— 注意力概率的 dropout 比率。

• final_dropout（float，可选，默认为 0.1）— Wav2Vec2ConformerForCTC 的最终投影层的 dropout 概率。

• layerdrop (float, optional, defaults to 0.1) — LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

• feat_extract_norm (str, optional, defaults to "group") — 应用于特征编码器中 1D 卷积层的规范化。"group"表示仅对第一个 1D 卷积层进行组归一化，"layer"表示对所有 1D 卷积层进行层归一化。

• feat_proj_dropout (float, optional, defaults to 0.0) — 特征编码器输出的丢弃概率。

• feat_extract_activation (str, optional, defaults to “gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数（函数或字符串）。如果是字符串，支持“gelu”、“relu”、“selu”和“gelu_new”`。

• feat_quantizer_dropout (float, optional, defaults to 0.0) — 量化特征编码器状态的丢弃概率。

• conv_dim (Tuple[int] or List[int], optional, defaults to (512, 512, 512, 512, 512, 512, 512)) — 定义特征编码器中每个 1D 卷积层的输入和输出通道数的整数元组。conv_dim的长度定义了 1D 卷积层的数量。

• conv_stride (Tuple[int] or List[int], optional, defaults to (5, 2, 2, 2, 2, 2, 2)) — 定义特征编码器中每个 1D 卷积层的步幅的整数元组。conv_stride的长度定义了卷积层的数量，并且必须与conv_dim的长度匹配。

• conv_kernel (Tuple[int] or List[int], optional, defaults to (10, 3, 3, 3, 3, 3, 3)) — 定义特征编码器中每个 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, optional, defaults to 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, optional, defaults to 10) — 沿时间轴的向量跨度长度。

• mask_time_min_masks (int, optional, defaults to 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, 默认为 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, 默认为 10) — 沿特征轴的向量跨度长度。

• mask_feature_min_masks (int, optional, 默认为 0) — 沿特征轴生成的长度为mask_feature_length的掩码的最小数量，每个时间步，与mask_feature_prob无关。仅在”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”时相关。

• num_codevectors_per_group (int, optional, 默认为 320) — 每个量化码书（组）中的条目数。

• num_codevector_groups (int, optional, 默认为 2) — 产品码矢量量化的码矢量组数。

• contrastive_logits_temperature (float, optional, 默认为 0.1) — 对比损失中的温度kappa。

• feat_quantizer_dropout (float, optional, 默认为 0.0) — 用于量化器的特征编码器输出的丢失概率。

• num_negatives (int, optional, 默认为 100) — 对比损失的负样本数量。

• codevector_dim (int, optional, 默认为 256) — 量化特征向量的维度。

• proj_codevector_dim (int, optional, 默认为 256) — 量化和变换特征的最终投影的维度。

• diversity_loss_weight (int, optional, 默认为 0.1) — 代码本多样性损失组件的权重。

• ctc_loss_reduction (str, optional, 默认为"sum") — 指定应用于torch.nn.CTCLoss输出的减少方式。仅在训练 Wav2Vec2ConformerForCTC 实例时相关。

• ctc_zero_infinity (bool, optional, 默认为False) — 是否将无穷损失和torch.nn.CTCLoss的相关梯度置零。当输入太短无法与目标对齐时，主要会出现无穷损失。仅在训练 Wav2Vec2ConformerForCTC 实例时相关。

• use_weighted_layer_sum (bool, optional, 默认为False) — 是否使用具有学习权重的层输出的加权平均值。仅在使用 Wav2Vec2ConformerForSequenceClassification 实例时相关。

• classifier_proj_size (int, optional, 默认为 256) — 用于分类的标记均值池化之前的投影的维度。

• tdnn_dim (Tuple[int] 或 List[int], optional, 默认为(512, 512, 512, 512, 1500)) — 定义XVector模型中TDNN模块中每个 1D 卷积层的输出通道数的整数元组。tdnn_dim的长度定义了TDNN层的数量。

• tdnn_kernel (Tuple[int] 或 List[int], optional, 默认为(5, 3, 3, 1, 1)) — 定义XVector模型中TDNN模块中每个 1D 卷积层的内核大小的整数元组。tdnn_kernel的长度必须与tdnn_dim的长度相匹配。

• tdnn_dilation (Tuple[int] 或 List[int], 可选, 默认为(1, 2, 3, 1, 1)) — 一个整数元组，定义XVector模型中TDNN模块中每个 1D 卷积层的扩张因子。tdnn_dilation的长度必须与tdnn_dim的长度相匹配。

• xvector_output_dim (int, 可选, 默认为 512) — XVector嵌入向量的维度。

• add_adapter (bool, 可选, 默认为False) — 是否应在 Wav2Vec2Conformer 编码器顶部堆叠卷积网络。对于 Warm-starting Wav2Vec2Conformer 用于 SpeechEncoderDecoder 模型非常有用。

• adapter_kernel_size (int, 可选, 默认为 3) — 适配器网络中卷积层的核大小。仅在add_adapter为 True 时相关。

• adapter_stride (int, 可选, 默认为 2) — 适配器网络中卷积层的步幅。仅在add_adapter为 True 时相关。

• num_adapter_layers (int, 可选, 默认为 3) — 适配器网络中应使用的卷积层的数量。仅在add_adapter为 True 时相关。

• output_hidden_size (int, 可选) — 编码器输出层的维度。如果未定义，则默认为hidden-size。仅在add_adapter为 True 时相关。

• position_embeddings_type (str, 可选, 默认为"relative") — 可以指定为relative或rotary，分别用于相对位置嵌入或旋转位置嵌入。如果为None，则不应用相对位置嵌入。

• rotary_embedding_base (int, 可选, 默认为 10000) — 如果使用"rotary"位置嵌入，定义嵌入基数的大小。

• max_source_positions (int, 可选, 默认为 5000) — 如果使用"relative"位置嵌入，定义最大源输入位置。

• conv_depthwise_kernel_size (int, 默认为 31) — Conformer 块中深度卷积 1D 层的核大小。

• conformer_conv_dropout (float, 默认为 0.1) — Conformer 块中所有卷积层的 dropout 概率。

这是用于存储 Wav2Vec2ConformerModel 配置的配置类。根据指定的参数实例化一个 Wav2Vec2Conformer 模型，定义模型架构。使用默认值实例化配置将产生类似于 Wav2Vec2Conformer facebook/wav2vec2-conformer-rel-pos-large架构的配置。

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

示例：

>>> from transformers import Wav2Vec2ConformerConfig, Wav2Vec2ConformerModel

>>> # Initializing a Wav2Vec2Conformer facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> configuration = Wav2Vec2ConformerConfig()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> model = Wav2Vec2ConformerModel(configuration)

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

Wav2Vec2Conformer 特定输出

class transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput

<来源>

( loss: Optional = None projected_states: FloatTensor = None projected_quantized_states: FloatTensor = None codevector_perplexity: FloatTensor = None hidden_states: Optional = None attentions: Optional = None contrastive_loss: Optional = None diversity_loss: Optional = None )

参数

• loss (可选, 当传递sample_negative_indices时返回，torch.FloatTensor，形状为(1,)) — 总损失，作为对比损失(L_m)和多样性损失(L_d)的总和，如官方论文中所述。 (分类)损失。

• projected_states (torch.FloatTensor，形状为(batch_size, sequence_length, config.proj_codevector_dim)) — 模型的隐藏状态投影到config.proj_codevector_dim，可用于预测掩码投影量化状态。

• projected_quantized_states（形状为(batch_size, sequence_length, config.proj_codevector_dim)的torch.FloatTensor）— 量化提取的特征向量投影到config.proj_codevector_dim，表示对比损失的正目标向量。

• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

• contrastive_loss（可选，在传递sample_negative_indices时返回，形状为(1,)的torch.FloatTensor）— 对比损失（L_m），如官方论文中所述。

• diversity_loss（可选，在传递sample_negative_indices时返回，形状为(1,)的torch.FloatTensor）— 多样性损失（L_d），如官方论文中所述。

Wav2Vec2ConformerForPreTraining 的输出类型，具有潜在的隐藏状态和注意力。

Wav2Vec2ConformerModel

class transformers.Wav2Vec2ConformerModel

<来源>

( config: Wav2Vec2ConformerConfig )

参数

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

裸的 Wav2Vec2Conformer 模型变压器，输出原始隐藏状态，没有特定的头部。Wav2Vec2Conformer 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出的。

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

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

forward

<来源>

( 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.Wav2Vec2BaseModelOutput 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]范围内的掩码值：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

  只有当相应的处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如wav2vec2-conformer-rel-pos-large，在进行批量推断时，应不传递attention_mask以避免性能下降。对于这样的模型，input_values应该简单地用 0 填充并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略有不同的结果。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

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

transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False，或输入取决于配置（Wav2Vec2ConformerConfig）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。

• extract_features（形状为(batch_size, sequence_length, conv_dim[-1])的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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, Wav2Vec2ConformerModel
>>> 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("facebook/wav2vec2-conformer-rope-large-960h-ft")
>>> model = Wav2Vec2ConformerModel.from_pretrained("facebook/wav2vec2-conformer-rope-large-960h-ft")

>>> # 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, 1024]

Wav2Vec2ConformerForCTC

class transformers.Wav2Vec2ConformerForCTC

<来源>

( config target_lang: Optional = None )

参数

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

带有顶部语言建模头部的 Wav2Vec2Conformer 模型，用于连接主义时间分类（CTC）。Wav2Vec2Conformer 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出的。

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

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

forward

<来源>

( 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中获得，例如通过声音文件库（pip install soundfile）。要准备好数组为input_values，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2Processor.call()。

• attention_mask（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于避免在填充标记索引上执行卷积和注意力的掩码。选择的掩码值在[0, 1]中：

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

  只有在相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，比如wav2vec2-conformer-rel-pos-large，在进行批量推理时，应不传递attention_mask以避免性能下降。对于这样的模型，input_values应该简单地用 0 填充并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略微不同的结果。

• 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时）包含根据配置（Wav2Vec2ConformerConfig）和输入的各种元素。

• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, Wav2Vec2ConformerForCTC
>>> 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("facebook/wav2vec2-conformer-rope-large-960h-ft")
>>> model = Wav2Vec2ConformerForCTC.from_pretrained("facebook/wav2vec2-conformer-rope-large-960h-ft")

>>> # 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 APOSTLE 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)
64.21

Wav2Vec2ConformerForSequenceClassification

class transformers.Wav2Vec2ConformerForSequenceClassification

<来源>

( config )

参数

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

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

Wav2Vec2Conformer 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在wav2vec 2.0:自监督学习语音表示的框架中提出的。

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

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

前向

<来源>

( 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（形状为(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]范围内：

  • 对于未屏蔽的标记，

  • 对于屏蔽的标记为 0。

  注意力蒙版是什么？

  只有当相应处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如wav2vec2-conformer-rel-pos-large，在进行批量推断时，应不传递attention_mask以避免性能下降。对于这些模型，input_values应简单地填充为 0 并在不传递attention_mask的情况下传递。请注意，这些模型的结果也会因input_values是否填充而略有不同。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算序列分类/回归损失的标签。索引应在[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 时）包含各种元素，这取决于配置（Wav2Vec2ConformerConfig）和输入。

• 损失 (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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForSequenceClassification
>>> 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("facebook/wav2vec2-conformer-rope-large-960h-ft")
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rope-large-960h-ft")

>>> # 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]

>>> # 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

Wav2Vec2ConformerForAudioFrameClassification

class transformers.Wav2Vec2ConformerForAudioFrameClassification

<来源>

( config )

参数

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

Wav2Vec2Conformer 模型在顶部带有一个帧分类头，用于说话人分离等任务。

Wav2Vec2Conformer 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中提出的。

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

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

forward

<来源>

( input_values: Optional attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput 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。

  注意力掩码是什么？

  只有当相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如wav2vec2-conformer-rel-pos-large，在进行批量推断时应避免传递attention_mask以避免性能下降。对于这些模型，input_values应简单地填充为 0 并在没有attention_mask的情况下传递。请注意，这些模型的结果也会因input_values是否填充而略有不同。

• 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.TokenClassifierOutput 或tuple(torch.FloatTensor)

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

• loss (torch.FloatTensor，形状为(1,), 可选, 当提供labels时返回) — 分类损失。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForAudioFrameClassification
>>> 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("facebook/wav2vec2-conformer-rope-large-960h-ft")
>>> model = Wav2Vec2ConformerForAudioFrameClassification.from_pretrained("facebook/wav2vec2-conformer-rope-large-960h-ft")

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

>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()

Wav2Vec2ConformerForXVector

class transformers.Wav2Vec2ConformerForXVector

<来源>

( config )

参数

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

Wav2Vec2Conformer 模型，顶部带有 XVector 特征提取头，用于说话者验证等任务。

Wav2Vec2Conformer 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出的。

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

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

forward

<来源>

( 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.XVectorOutput 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]之间：

  • 对于未被masked的令牌为 1。

  • 对于被masked的令牌为 0。

  什么是注意力掩码？

  只有当相应的处理器具有 config.return_attention_mask == True 时才应传递 attention_mask。对于所有处理器具有 config.return_attention_mask == False 的模型，比如 wav2vec2-conformer-rel-pos-large，在进行批量推理时，应该 不 传递 attention_mask 以避免性能下降。对于这些模型，input_values 应该简单地用 0 填充并在不传递 attention_mask 的情况下传递。请注意，这些模型根据 input_values 是否填充会产生略有不同的结果。

• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。

• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

• return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。

• labels（形状为 (batch_size,) 的 torch.LongTensor，可选） — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss（形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回） — 分类损失。

• logits（形状为 (batch_size, config.xvector_output_dim) 的 torch.FloatTensor） — AMSoftmax 之前的分类隐藏状态。

• embeddings（形状为 (batch_size, config.xvector_output_dim) 的 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForXVector
>>> 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("facebook/wav2vec2-conformer-rope-large-960h-ft")
>>> model = Wav2Vec2ConformerForXVector.from_pretrained("facebook/wav2vec2-conformer-rope-large-960h-ft")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
...     embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7  # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
...     print("Speakers are not the same!")

Wav2Vec2ConformerForPreTraining

class transformers.Wav2Vec2ConformerForPreTraining

< source >

( config: Wav2Vec2ConformerConfig )

参数

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

带有量化器和VQ头部的 Wav2Vec2Conformer 模型。Wav2Vec2Conformer 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出的。

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

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

forward

<来源>

( input_values: Optional attention_mask: Optional = None mask_time_indices: Optional = None sampled_negative_indices: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput 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 表示被掩码的标记。

  注意力掩码是什么？

  只有当相应的处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，比如wav2vec2-conformer-rel-pos-large，在进行批量推理时，应不传递attention_mask以避免性能下降。对于这样的模型，input_values应该简单地用 0 填充并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略有不同的结果。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回的张量下的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回的张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

• mask_time_indices (torch.BoolTensor，形状为(batch_size, sequence_length)，可选) — 用于对对比损失的提取特征进行掩码的索引。在训练模式下，模型学习在config.proj_codevector_dim空间中预测掩码提取特征。

• sampled_negative_indices (torch.BoolTensor of shape (batch_size, sequence_length, num_negatives), 可选) — 指示哪些量化目标向量用作对比损失中的负采样向量的索引。预训练所需的必要输入。

返回

transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False）包含各种元素，取决于配置（Wav2Vec2ConformerConfig）和输入。

• loss (可选, 当传入 sample_negative_indices 时返回, torch.FloatTensor of shape (1,)) — 总损失，作为对比损失 (L_m) 和多样性损失 (L_d) 的和，如官方论文中所述。 (分类) 损失。

• projected_states (torch.FloatTensor of shape (batch_size, sequence_length, config.proj_codevector_dim)) — 模型隐藏状态投影到 config.proj_codevector_dim，可用于预测掩码投影量化状态。

• projected_quantized_states (torch.FloatTensor of shape (batch_size, sequence_length, config.proj_codevector_dim)) — 量化提取的特征向量投影到 config.proj_codevector_dim，代表对比损失的正目标向量。

• 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 后的结果，用于计算自注意力头中的加权平均值。

• contrastive_loss (可选, 当传入 sample_negative_indices 时返回, torch.FloatTensor of shape (1,)) — 如官方论文中所述的对比损失 (L_m)。

• diversity_loss (可选, 当传入 sample_negative_indices 时返回, torch.FloatTensor of shape (1,)) — 如官方论文中所述的多样性损失 (L_d)。

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

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

例如：

>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForPreTraining
>>> from transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForPreTraining.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values  # Batch size 1

>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
...     shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
...     features_shape=(batch_size, sequence_length),
...     num_negatives=model.config.num_negatives,
...     mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
...     data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )

>>> with torch.no_grad():
...     outputs = model(input_values, mask_time_indices=mask_time_indices)

>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)

>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)

>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
...     input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss

Wav2Vec2Phoneme

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/wav2vec2_phoneme

概述

Wav2Vec2Phoneme 模型是由 Qiantong Xu、Alexei Baevski、Michael Auli 在Simple and Effective Zero-shot Cross-lingual Phoneme Recognition (Xu et al., 2021中提出的。

该论文的摘要如下：

最近在自训练、自监督预训练和无监督学习方面取得的进展使得语音识别系统在没有任何标记数据的情况下表现良好。然而，在许多情况下，存在相关语言的标记数据，但这些方法没有利用这些数据。本文通过微调多语言预训练的 wav2vec 2.0 模型来扩展之前关于零样本跨语言迁移学习的工作，以转录未见过的语言。这是通过使用发音特征将训练语言的音素映射到目标语言来实现的。实验证明，这种简单的方法明显优于之前引入了任务特定架构并且仅使用了部分单语预训练模型的工作。

相关的检查点可以在huggingface.co/models?other=phoneme-recognition下找到。

该模型由patrickvonplaten贡献

原始代码可以在这里找到。

使用提示

• Wav2Vec2Phoneme 使用与 Wav2Vec2 完全相同的架构

• Wav2Vec2Phoneme 是一个接受与语音信号的原始波形对应的浮点数组的语音模型。

• Wav2Vec2Phoneme 模型是使用连接主义时间分类（CTC）进行训练的，因此模型输出必须使用 Wav2Vec2PhonemeCTCTokenizer 进行解码。

• Wav2Vec2Phoneme 可以同时在多种语言上进行微调，并在单次前向传递中将未见过的语言解码为一系列音素。

• 默认情况下，该模型输出一系列音素。为了将音素转换为一系列单词，应该使用字典和语言模型。

Wav2Vec2Phoneme 的架构基于 Wav2Vec2 模型，有关 API 参考，请查看Wav2Vec2的文档页面，除了标记器。

Wav2Vec2PhonemeCTCTokenizer

class transformers.Wav2Vec2PhonemeCTCTokenizer

<来源>

( vocab_file bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' phone_delimiter_token = ' ' word_delimiter_token = None do_phonemize = True phonemizer_lang = 'en-us' phonemizer_backend = 'espeak' **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。

• bos_token (str, 可选，默认为"<s>") — 句子开始标记。

• eos_token (str, 可选，默认为"</s>") — 句子结束标记。

• unk_token (str, 可选，默认为"<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• pad_token (str, 可选，默认为"<pad>") — 用于填充的标记，例如在批处理不同长度的序列时。

• do_phonemize (bool, 可选，默认为True) — 标记器是否应该对输入进行音素化。只有当将一系列音素传递给标记器时，do_phonemize应设置为False。

• phonemizer_lang (str, 可选，默认为"en-us") — 标记器应将输入文本音素化为的音素集的语言。

• phonemizer_backend (str, 可选，默认为"espeak") — 由音素化库使用的后端音素化库。默认为espeak-ng。更多信息请参见phonemizer package。

  **kwargs — 传递给 PreTrainedTokenizer 的额外关键字参数

构建一个 Wav2Vec2PhonemeCTC 分词器。

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

__call__

< source >

( text: Union = None text_pair: Union = None text_target: Union = None text_pair_target: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 is_split_into_words: bool = False pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → export const metadata = 'undefined';BatchEncoding

参数

• text (str, List[str], List[List[str]], 可选) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）的形式提供，则必须设置is_split_into_words=True（以消除与批次序列的歧义）。

• text_pair (str, List[str], List[List[str]], 可选) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）的形式提供，则必须设置is_split_into_words=True（以消除与批次序列的歧义）。

• text_target (str, List[str], List[List[str]], 可选) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）的形式提供，则必须设置is_split_into_words=True（以消除与批次序列的歧义）。

• text_pair_target (str, List[str], List[List[str]], 可选) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）的形式提供，则必须设置is_split_into_words=True（以消除与批次序列的歧义）。

• add_special_tokens (bool, 可选, 默认为 True) — 在编码序列时是否添加特殊标记。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了自动添加到输入 id 的标记。如果要自动添加bos或eos标记，则这很有用。

• padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 激活和控制填充。接受以下值：

  • True 或 'longest': 填充到批次中最长的序列（如果只提供单个序列，则不填充）。

  • 'max_length': 填充到指定的最大长度或模型的最大可接受输入长度（如果未提供该参数）。

  • False 或 'do_not_pad'（默认）: 不填充（即，可以输出长度不同的序列批次）。

• truncation (bool, str 或 TruncationStrategy, 可选, 默认为 False) — 激活和控制截断。接受以下值：

  • True 或 'longest_first': 截断到指定的最大长度或模型的最大可接受输入长度（如果未提供该参数）。这将逐标记截断，如果提供了一对序列（或一批对序列），则从该对中最长的序列中删除一个标记。

  • 'only_first': 截断到指定的最大长度或模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对序列（或一批对序列），则仅截断第一个序列。

  • 'only_second': 截断到指定的最大长度，由参数 max_length 指定，或者截断到模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对输入 ID 序列（或一批对），并且 truncation_strategy = longest_first 或 True，则会引发错误，而不是返回溢出标记。

  • False 或 'do_not_truncate'（默认）：不截断（即，可以输出长度大于模型最大可接受输入大小的批次）。

• max_length (int, optional) — 控制截断/填充参数之一使用的最大长度。

  如果未设置或设置为 None，则将使用预定义的模型最大长度（如果截断/填充参数需要最大长度）。如果模型没有特定的最大输入长度（如 XLNet），则将禁用截断/填充到最大长度。

• stride (int, optional, defaults to 0) — 如果设置为一个数字，并且与 max_length 一起使用，当 return_overflowing_tokens=True 时返回的溢出标记将包含截断序列末尾的一些标记，以提供截断和溢出序列之间的一些重叠。该参数的值定义了重叠标记的数量。

• is_split_into_words (bool, optional, 默认为 False) — 输入是否已经预分词（例如，已经分成单词）。如果设置为 True，分词器会假定输入已经分成单词（例如，通过在空格上分割），然后对其进行分词。这对于 NER 或标记分类很有用。

• pad_to_multiple_of (int, optional) — 如果设置，将填充序列到提供的值的倍数。需要激活 padding。这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用，计算能力 >= 7.5（Volta）。

• return_tensors (str 或 TensorType, optional) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf': 返回 TensorFlow tf.constant 对象。

  • 'pt': 返回 PyTorch torch.Tensor 对象。

  • 'np': 返回 Numpy np.ndarray 对象。

• return_token_type_ids (bool, optional) — 是否返回标记类型 ID。如果保持默认设置，将根据特定分词器的默认值返回标记类型 ID，由 return_outputs 属性定义。

  什么是标记类型 ID？

• return_attention_mask (bool, *optional) — 是否返回注意力掩码。如果保持默认设置，将根据特定分词器的默认值返回注意力掩码，由 return_outputs` 属性定义。

  什么是注意力掩码？

• return_overflowing_tokens (bool, optional, 默认为 False) — 是否返回溢出标记序列。如果提供了一对输入 ID 序列（或一批对），并且 truncation_strategy = longest_first 或 True，则会引发错误，而不是返回溢出标记。

• return_special_tokens_mask (bool, optional, 默认为 False) — 是否返回特殊标记掩码信息。

• return_offsets_mapping (bool, optional, 默认为 False) — 是否返回每个标记的 (char_start, char_end)。

  仅适用于继承自 PreTrainedTokenizerFast 的快速分词器，如果使用 Python 的分词器，此方法将引发 NotImplementedError。

• return_length (bool, optional, 默认为 False) — 是否返回编码输入的长度。

• verbose (bool, optional, 默认为 True) — 是否打印更多信息和警告。**kwargs — 传递给 self.tokenize() 方法

返回

BatchEncoding

一个具有以下字段的 BatchEncoding：

• input_ids — 要提供给模型的标记 id 列表。

  什么是输入 ID？

• token_type_ids — 要提供给模型的标记类型 id 列表（当return_token_type_ids=True或token_type_ids在self.model_input_names中时）。

  什么是标记类型 ID？

• attention_mask — 指定哪些标记应由模型关注的索引列表（当return_attention_mask=True或attention_mask在self.model_input_names中时）。

  什么是注意力掩码？

• overflowing_tokens — 溢出的标记序列列表（当指定max_length并且return_overflowing_tokens=True时）。

• num_truncated_tokens — 截断的标记数（当指定max_length并且return_overflowing_tokens=True时）。

• special_tokens_mask — 由 0 和 1 组成的列表，其中 1 指定添加的特殊标记，0 指定常规序列标记（当add_special_tokens=True和return_special_tokens_mask=True时）。

• length — 输入的长度（当return_length=True时）

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

batch_decode

<来源>

( sequences: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None output_char_offsets: bool = False **kwargs ) → export const metadata = 'undefined';List[str] or ~models.wav2vec2.tokenization_wav2vec2_phoneme.Wav2Vec2PhonemeCTCTokenizerOutput

参数

• sequences（Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]） — 标记化输入 id 的列表。可以使用__call__方法获得。

• skip_special_tokens（bool，可选，默认为False） — 是否在解码中删除特殊标记。

• clean_up_tokenization_spaces（bool，可选） — 是否清除标记化空格。

• output_char_offsets（bool，可选，默认为False） — 是否输出字符偏移。字符偏移可以与采样率和模型下采样率结合使用，计算转录字符的时间戳。

  请查看~models.wav2vec2.tokenization_wav2vec2.decode的示例，以更好地理解如何使用output_word_offsets。~model.wav2vec2_phoneme.tokenization_wav2vec2_phoneme.batch_decode与音素和批处理输出的处理方式类似。

• kwargs（其他关键字参数，可选） — 将传递给底层模型特定的解码方法。

返回

List[str]或~models.wav2vec2.tokenization_wav2vec2_phoneme.Wav2Vec2PhonemeCTCTokenizerOutput

解码后的句子。当output_char_offsets == True时，将是~models.wav2vec2.tokenization_wav2vec2_phoneme.Wav2Vec2PhonemeCTCTokenizerOutput。

通过调用解码将标记 id 的列表列表转换为字符串列表。

decode

<来源>

( token_ids: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None output_char_offsets: bool = False **kwargs ) → export const metadata = 'undefined';str or ~models.wav2vec2.tokenization_wav2vec2_phoneme.Wav2Vec2PhonemeCTCTokenizerOutput

参数

• token_ids（Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]） — 标记化输入 id 的列表。可以使用__call__方法获得。

• skip_special_tokens（bool，可选，默认为False） — 是否在解码中删除特殊标记。

• clean_up_tokenization_spaces（bool，可选） — 是否清除标记化空格。

• output_char_offsets（bool，可选，默认为False） — 是否输出字符偏移。字符偏移可以与采样率和模型下采样率结合使用，计算转录字符的时间戳。

  请查看~models.wav2vec2.tokenization_wav2vec2.decode的示例，以更好地理解如何使用output_word_offsets。~model.wav2vec2_phoneme.tokenization_wav2vec2_phoneme.batch_decode与音素的处理方式相同。

• kwargs（额外的关键字参数，可选）- 将传递给底层模型特定的解码方法。

返回

str 或 ~models.wav2vec2.tokenization_wav2vec2_phoneme.Wav2Vec2PhonemeCTCTokenizerOutput

解码后的句子。当 output_char_offsets == True 时，将是一个 ~models.wav2vec2.tokenization_wav2vec2_phoneme.Wav2Vec2PhonemeCTCTokenizerOutput。

将一系列 id 转换为字符串，使用分词器和词汇表，可以选择删除特殊标记并清理分词空格。

类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

phonemize

< source >

( text: str phonemizer_lang: Optional = None )

WavLM

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/wavlm

概述

WavLM 模型是由 Sanyuan Chen、Chengyi Wang、Zhengyang Chen、Yu Wu、Shujie Liu、Zhuo Chen、Jinyu Li、Naoyuki Kanda、Takuya Yoshioka、Xiong Xiao、Jian Wu、Long Zhou、Shuo Ren、Yanmin Qian、Yao Qian、Jian Wu、Michael Zeng、Furu Wei 在《WavLM: 大规模自监督预训练用于全栈语音处理》中提出的。

该论文的摘要如下：

自监督学习（SSL）在语音识别中取得了巨大成功，但对其他语音处理任务的探索有限。由于语音信号包含说话人身份、语用学、口语内容等多方面信息，为所有语音任务学习通用表示是具有挑战性的。在本文中，我们提出了一个新的预训练模型 WavLM，用于解决全栈下游语音任务。WavLM 基于 HuBERT 框架构建，重点放在口语内容建模和说话人身份保留上。我们首先为 Transformer 结构配备了门控相对位置偏差，以提高其在识别任务上的能力。为了更好地区分说话人，我们提出了一种话语混合训练策略，其中额外的重叠话语是无监督创建的，并在模型训练过程中加以整合。最后，我们将训练数据集从 60k 小时扩大到 94k 小时。WavLM Large 在 SUPERB 基准测试中取得了最先进的性能，并为各种语音处理任务在其代表性基准测试中带来了显著改进。

相关检查点可以在huggingface.co/models?other=wavlm下找到。

该模型由patrickvonplaten贡献。作者的代码可以在这里找到。

使用提示

• WavLM 是一个接受与语音信号的原始波形对应的浮点数组的语音模型。请使用 Wav2Vec2Processor 进行特征提取。

• WavLM 模型可以使用连接主义时间分类（CTC）进行微调，因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。

• WavLM 在说话人验证、说话人识别和说话人分割任务中表现特别好。

资源

• 音频分类任务指南

• 自动语音识别任务指南

WavLMConfig

class transformers.WavLMConfig

<来源>

( vocab_size = 32 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 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 = (512, 512, 512, 512, 512, 512, 512) conv_stride = (5, 2, 2, 2, 2, 2, 2) conv_kernel = (10, 3, 3, 3, 3, 2, 2) conv_bias = False num_conv_pos_embeddings = 128 num_conv_pos_embedding_groups = 16 num_buckets = 320 max_bucket_distance = 800 do_stable_layer_norm = False 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 num_codevectors_per_group = 320 num_codevector_groups = 2 contrastive_logits_temperature = 0.1 num_negatives = 100 codevector_dim = 256 proj_codevector_dim = 256 diversity_loss_weight = 0.1 ctc_loss_reduction = 'mean' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 tdnn_dim = (512, 512, 512, 512, 1500) tdnn_kernel = (5, 3, 3, 1, 1) tdnn_dilation = (1, 2, 3, 1, 1) xvector_output_dim = 512 num_ctc_classes = 80 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 add_adapter = False adapter_kernel_size = 3 adapter_stride = 2 num_adapter_layers = 3 output_hidden_size = None **kwargs )

参数

• vocab_size（int，可选，默认为 32）— WavLM 模型的词汇大小。定义了在调用 WavLMModel 时可以表示的不同令牌数量。模型的词汇大小。定义了可以由传递给 WavLMModel 的inputs_ids表示的不同令牌。

• hidden_size（int，可选，默认为 768）— 编码器层和池化层的维度。

• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数。

• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size（int，可选，默认为 3072）— Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new"。

• hidden_dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

• activation_dropout (float, optional, defaults to 0.1) — 全连接层内部激活的丢弃比例。

• attention_dropout (float, optional, defaults to 0.1) — 注意力概率的丢弃比例。

• final_dropout (float, optional, defaults to 0.1) — WavLMForCTC 最终投影层的丢弃概率。

• layerdrop (float, optional, defaults to 0.1) — LayerDrop 概率。详情请参考 LayerDrop paper)。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-12) — 层规范化层使用的 epsilon 值。

• feat_extract_norm (str, optional, defaults to "group") — 用于特征编码器中的 1D 卷积层的规范化方式。可以选择 "group" 表示仅对第一个 1D 卷积层进行分组规范化，或者选择 "layer" 表示对所有 1D 卷积层进行层规范化。

• feat_proj_dropout (float, optional, defaults to 0.0) — 特征编码器输出的丢弃概率。

• feat_extract_activation (str, optional, defaults to “gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数（函数或字符串）。如果是字符串，支持 “gelu”, “relu”, “selu”和“gelu_new”`。

• conv_dim (Tuple[int] or List[int], optional, defaults to (512, 512, 512, 512, 512, 512, 512)) — 定义特征编码器中每个 1D 卷积层的输入和输出通道数的整数元组。conv_dim 的长度定义了 1D 卷积层的数量。

• conv_stride (Tuple[int] or List[int], optional, defaults to (5, 2, 2, 2, 2, 2, 2)) — 定义特征编码器中每个 1D 卷积层的步幅的整数元组。conv_stride 的长度定义了卷积层的数量，并且必须与 conv_dim 的长度匹配。

• conv_kernel (Tuple[int] or List[int], optional, defaults to (10, 3, 3, 3, 3, 3, 3)) — 定义特征编码器中每个 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 卷积位置嵌入层的组数。

• do_stable_layer_norm (bool, optional, defaults to False) — 是否应用 Transformer 编码器的 stable 层规范化架构。do_stable_layer_norm is True 表示在注意力层之前应用层规范化，而 do_stable_layer_norm is False 表示在注意力层之后应用层规范化。

• apply_spec_augment (bool, optional, defaults to True) — 是否对特征编码器的输出应用 SpecAugment 数据增强。详情请参考 SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。

• mask_time_prob (float, optional, defaults to 0.05) — 沿时间轴的每个特征向量被选择为要屏蔽的向量跨度的起始的概率。大约会有 mask_time_prob * sequence_length // mask_time_length 个特征向量沿时间轴被屏蔽。仅在 apply_spec_augment 为真时相关。

• mask_time_length (int, optional, defaults to 10) — 沿时间轴的向量跨度长度。

• mask_time_min_masks (int, optional, defaults to 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) — 沿特征轴的每个特征向量被选择为要屏蔽的向量跨度的起始的概率。大约会有 mask_time_prob * hidden_size // mask_time_length 个特征向量沿时间轴被屏蔽。仅在 apply_spec_augment 为真时相关。

• mask_feature_length (int, optional, defaults to 10) — 沿特征轴的向量跨度长度。

• num_codevectors_per_group (int, optional, defaults to 320) — 每个量化码书（组）中的条目数。

• num_codevector_groups (int, optional, defaults to 2) — 产品码矢量量化的码矢量组数。

• contrastive_logits_temperature (float, optional, defaults to 0.1) — 对比损失中的温度 kappa。

• num_negatives (int, optional, defaults to 100) — 对比损失的负样本数量。

• codevector_dim (int, optional, defaults to 256) — 量化特征向量的维度。

• proj_codevector_dim (int, optional, defaults to 256) — 量化和变换特征的最终投影的维度。

• diversity_loss_weight (int, optional, defaults to 0.1) — 码书多样性损失组件的权重。

• ctc_loss_reduction (str, optional, defaults to "mean") — 指定应用于 torch.nn.CTCLoss 输出的减少方式。仅在训练 WavLMForCTC 实例时相关。

• ctc_zero_infinity (bool, optional, defaults to False) — 是否将 torch.nn.CTCLoss 的无限损失和相关梯度置零。当输入太短无法与目标对齐时主要会出现无限损失。仅在训练 WavLMForCTC 实例时相关。

• use_weighted_layer_sum (bool, optional, defaults to False) — 是否使用具有学习权重的层输出的加权平均。仅在使用 WavLMForSequenceClassification 实例时相关。

• classifier_proj_size (int, optional, defaults to 256) — 分类前的投影维度，用于标记均值池化。

• tdnn_dim (Tuple[int] or List[int], optional, defaults to (512, 512, 512, 512, 1500)) — XVector 模型中 TDNN 模块中每个一维卷积层的输出通道数的整数元组。tdnn_dim 的长度定义了 TDNN 层的数量。

• tdnn_kernel (Tuple[int] or List[int], optional, defaults to (5, 3, 3, 1, 1)) — XVector 模型中 TDNN 模块中每个一维卷积层的内核大小的整数元组。tdnn_kernel 的长度必须与 tdnn_dim 的长度相匹配。

• tdnn_dilation (Tuple[int] or List[int], optional, defaults to (1, 2, 3, 1, 1)) — XVector 模型中 TDNN 模块中每个一维卷积层的膨胀因子的整数元组。tdnn_dilation 的长度必须与 tdnn_dim 的长度相匹配。

• xvector_output_dim（int，可选，默认为 512）— XVector嵌入向量的维度。

• add_adapter（bool，可选，默认为False）— 是否应在 Wav2Vec2 编码器顶部堆叠卷积网络。对于 Warm-starting Wav2Vec2 用于 SpeechEncoderDecoder 模型非常有用。

• adapter_kernel_size（int，可选，默认为 3）— 适配器网络中卷积层的核大小。仅在add_adapter为 True 时相关。

• adapter_stride（int，可选，默认为 2）— 适配器网络中卷积层的步幅。仅在add_adapter为 True 时相关。

• num_adapter_layers（int，可选，默认为 3）— 适配器网络中应使用的卷积层的数量。仅在add_adapter为 True 时相关。

• output_hidden_size（int，可选）— 编码器输出层的维度。如果未定义，则默认为hidden-size。仅在add_adapter为 True 时相关。

这是用于存储 WavLMModel 配置的配置类。根据指定的参数实例化一个 WavLM 模型，定义模型架构。使用默认值实例化配置将产生类似于 WavLM microsoft/wavlm-base架构的配置。

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

示例：

示例：

>>> from transformers import WavLMConfig, WavLMModel

>>> # Initializing a WavLM facebook/wavlm-base-960h style configuration
>>> configuration = WavLMConfig()

>>> # Initializing a model (with random weights) from the facebook/wavlm-base-960h style configuration
>>> model = WavLMModel(configuration)

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

WavLMModel

class transformers.WavLMModel

<来源>

( config: WavLMConfig )

参数

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

WavLM 模型转换器裸输出原始隐藏状态，没有任何特定的头部。WavLM 是由 Sanyuan Chen、Chengyi Wang、Zhengyang Chen、Yu Wu、Shujie Liu、Zhuo Chen、Jinyu Li、Naoyuki Kanda、Takuya Yoshioka、Xiong Xiao、Jian Wu、Long Zhou、Shuo Ren、Yanmin Qian、Yao Qian、Jian Wu、Michael Zeng、Xiangzhan Yu、Furu Wei 在《WavLM: 使用标记和未标记数据进行统一语音表示学习》中提出的。

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

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

forward

<来源>

( 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.Wav2Vec2BaseModelOutput 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。

  注意力蒙版是什么？

  只有当相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，当进行批量推断时，应避免传递attention_mask以避免性能下降。对于这样的模型，input_values应简单地填充为 0 并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略有不同的结果。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

• extract_features (torch.FloatTensor，形状为(batch_size, sequence_length, conv_dim[-1])) — 模型最后一个卷积层提取的特征向量序列。

• 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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, WavLMModel
>>> 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("patrickvonplaten/wavlm-libri-clean-100h-base-plus")
>>> model = WavLMModel.from_pretrained("patrickvonplaten/wavlm-libri-clean-100h-base-plus")

>>> # 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, 768]

WavLMForCTC

class transformers.WavLMForCTC

< source >

( config target_lang: Optional = None )

参数

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

WavLM 模型在 Connectionist Temporal Classification (CTC) 上具有 语言建模 头部。WavLM 是由 Sanyuan Chen, Chengyi Wang, Zhengyang Chen, Yu Wu, Shujie Liu, Zhuo Chen, Jinyu Li, Naoyuki Kanda, Takuya Yoshioka, Xiong Xiao, Jian Wu, Long Zhou, Shuo Ren, Yanmin Qian, Yao Qian, Jian Wu, Michael Zeng, Xiangzhan Yu, Furu Wei 在 WavLM: Unified Speech Representation Learning with Labeled and Unlabeled Data 中提出的。

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

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

forward

< source >

( 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 (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] 中的掩码值。

  • 对于未被 masked 的标记为 1，

  • 对于被 masked 的标记为 0。

  什么是注意力掩码？

  attention_mask 只有在相应的处理器具有 config.return_attention_mask == True 时才应传递。对于所有处理器的 config.return_attention_mask == False 的模型，当进行批量推理时，应 不 传递 attention_mask 以避免性能下降。对于这种模型，input_values 应该简单地用 0 填充并在不传递 attention_mask 的情况下传递。请注意，这些模型根据 input_values 是否填充而产生略有不同的结果。

• 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，则根据配置（WavLMConfig）和输入包含各种元素。

• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

WavLMForCTC 前向方法，覆盖__call__特殊方法。

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

示例：

>>> from transformers import AutoProcessor, WavLMForCTC
>>> 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("patrickvonplaten/wavlm-libri-clean-100h-base-plus")
>>> model = WavLMForCTC.from_pretrained("patrickvonplaten/wavlm-libri-clean-100h-base-plus")

>>> # 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 aposle 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)
12.51

WavLMForSequenceClassification

class transformers.WavLMForSequenceClassification

<来源>

( config )

参数

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

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

WavLM 是由 Sanyuan Chen、Chengyi Wang、Zhengyang Chen、Yu Wu、Shujie Liu、Zhuo Chen、Jinyu Li、Naoyuki Kanda、Takuya Yoshioka、Xiong Xiao、Jian Wu、Long Zhou、Shuo Ren、Yanmin Qian、Yao Qian、Jian Wu、Michael Zeng、Xiangzhan Yu、Furu Wei 在《WavLM: Unified Speech Representation Learning with Labeled and Unlabeled Data》中提出的。

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

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

forward

< source >

( 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。

  什么是注意力掩码？

  只有当相应的处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，当进行批量推断时，应避免传递attention_mask以避免性能下降。对于这些模型，input_values应简单地用 0 填充并在不带attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略有不同的结果。

• 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时）包含根据配置（WavLMConfig）和输入的不同元素。

• loss (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 后的注意力权重。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, WavLMForSequenceClassification
>>> 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("patrickvonplaten/wavlm-libri-clean-100h-base-plus")
>>> model = WavLMForSequenceClassification.from_pretrained("patrickvonplaten/wavlm-libri-clean-100h-base-plus")

>>> # 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]

>>> # 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

WavLMForAudioFrameClassification

class transformers.WavLMForAudioFrameClassification

<来源>

( config )

参数

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

WavLM 模型在顶部带有帧分类头，用于说话人分离等任务。

WavLM 是由 Sanyuan Chen、Chengyi Wang、Zhengyang Chen、Yu Wu、Shujie Liu、Zhuo Chen、Jinyu Li、Naoyuki Kanda、Takuya Yoshioka、Xiong Xiao、Jian Wu、Long Zhou、Shuo Ren、Yanmin Qian、Yao Qian、Jian Wu、Michael Zeng、Xiangzhan Yu、Furu Wei 在《WavLM: 统一的带标记和未标记数据的语音表示学习》中提出的。

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

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

forward

<来源>

( input_values: Optional attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput 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，

  • 对于被“掩码”的标记。

  什么是注意力掩码？

  只有当相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，应避免传递attention_mask以避免在进行批量推断时性能下降。对于这样的模型，input_values应该简单地用 0 填充并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略有不同的结果。

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor of shape (batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss (torch.FloatTensor of shape (1,), 可选，当提供labels时返回) — 分类损失。

• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类得分（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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, WavLMForAudioFrameClassification
>>> 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("microsoft/wavlm-base-plus-sd")
>>> model = WavLMForAudioFrameClassification.from_pretrained("microsoft/wavlm-base-plus-sd")

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

>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
[0, 0]

WavLMForXVector

class transformers.WavLMForXVector

< source >

( config )

参数

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

WavLM 模型在顶部具有 XVector 特征提取头，用于说话者验证等任务。

WavLM 是由 Sanyuan Chen、Chengyi Wang、Zhengyang Chen、Yu Wu、Shujie Liu、Zhuo Chen、Jinyu Li、Naoyuki Kanda、Takuya Yoshioka、Xiong Xiao、Jian Wu、Long Zhou、Shuo Ren、Yanmin Qian、Yao Qian、Jian Wu、Michael Zeng、Xiangzhan Yu、Furu Wei 提出的WavLM: Unified Speech Representation Learning with Labeled and Unlabeled Data。

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

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

forward

< source >

( 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.XVectorOutput 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]中。

  • 对于未被遮罩的标记，

  • 对于被遮罩的标记为 0。

  什么是注意力遮罩？

  只有在相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，应避免传递attention_mask以避免在进行批量推断时性能下降。对于这样的模型，input_values应简单地用 0 填充并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略有不同的结果。

• 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.XVectorOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.XVectorOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包括根据配置(WavLMConfig)和输入而变化的各种元素。

• loss (torch.FloatTensor of shape (1,), 可选, 当提供labels时返回) — 分类损失。

• logits (torch.FloatTensor of shape (batch_size, config.xvector_output_dim)) — AMSoftmax 之前的分类隐藏状态。

• embeddings (torch.FloatTensor of shape (batch_size, config.xvector_output_dim)) — 用于基于向量相似性检索的话语嵌入。

• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, WavLMForXVector
>>> 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("microsoft/wavlm-base-plus-sv")
>>> model = WavLMForXVector.from_pretrained("microsoft/wavlm-base-plus-sv")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
...     embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7  # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
...     print("Speakers are not the same!")
>>> round(similarity.item(), 2)
0.97

Whisper

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/whisper

概述

Whisper 模型由 Alec Radford、Jong Wook Kim、Tao Xu、Greg Brockman、Christine McLeavey、Ilya Sutskever 在通过大规模弱监督实现稳健语音识别中提出。

论文摘要如下：

我们研究了简单训练以预测互联网上大量音频转录的语音处理系统的能力。当扩展到 680,000 小时的多语言和多任务监督时，得到的模型在标准基准上表现良好，并且通常与先前的完全监督结果竞争，但在零次迁移设置中无需任何微调。与人类相比，模型接近其准确性和稳健性。我们发布了模型和推理代码，以作为进一步研究稳健语音处理的基础。

此模型由Arthur Zucker贡献。此模型的 Tensorflow 版本由amyeroberts贡献。原始代码可在此处找到。

使用提示

• 该模型通常无需任何微调即可表现良好。

• 该架构遵循经典的编码器-解码器架构，这意味着它依赖于 generate()函数进行推理。

• 目前仅实现了短形式的推理，即音频被预分段为<=30 秒的片段。长形式（包括时间戳）将在未来的版本中实现。

• 可以使用 WhisperProcessor 来准备音频以供模型使用，并将预测的 ID 解码回文本。

• 要转换模型和处理器，我们建议使用以下方法：

python src/transformers/models/whisper/convert_openai_to_hf.py --checkpoint_path "" --pytorch_dump_folder_path "Arthur/whisper-3" --convert_preprocessor True

脚本将自动从 OpenAI 检查点确定所有必要的参数。需要安装tiktoken库以执行将 OpenAI 分词器转换为tokenizers版本的转换。

推理

以下是使用预训练的 Whisper 模型转录音频样本的逐步指南：

>>> from datasets import load_dataset
>>> from transformers import WhisperProcessor, WhisperForConditionalGeneration

>>> # Select an audio file and read it:
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio_sample = ds[0]["audio"]
>>> waveform = audio_sample["array"]
>>> sampling_rate = audio_sample["sampling_rate"]

>>> # Load the Whisper model in Hugging Face format:
>>> processor = WhisperProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

>>> # Use the model and processor to transcribe the audio:
>>> input_features = processor(
...     waveform, sampling_rate=sampling_rate, return_tensors="pt"
... ).input_features

>>> # Generate token ids
>>> predicted_ids = model.generate(input_features)

>>> # Decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)

>>> transcription[0]
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 Whisper。如果您有兴趣提交资源以包含在此处，请随时提交拉取请求，我们将进行审核！资源应该展示一些新东西，而不是重复现有资源。

• 一个包含脚本的分支，用于将 Hugging Face 格式的 Whisper 模型转换为 OpenAI 格式。🌎 使用示例：

pip install -U openai-whisper
python convert_hf_to_openai.py \
    --checkpoint openai/whisper-tiny \
    --whisper_dump_path whisper-tiny-openai.pt

WhisperConfig

class transformers.WhisperConfig

<来源>

( vocab_size = 51865 num_mel_bins = 80 encoder_layers = 4 encoder_attention_heads = 6 decoder_layers = 4 decoder_attention_heads = 6 decoder_ffn_dim = 1536 encoder_ffn_dim = 1536 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 decoder_start_token_id = 50257 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 384 dropout = 0.0 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 scale_embedding = False max_source_positions = 1500 max_target_positions = 448 pad_token_id = 50256 bos_token_id = 50256 eos_token_id = 50256 suppress_tokens = None begin_suppress_tokens = [220, 50256] use_weighted_layer_sum = False classifier_proj_size = 256 apply_spec_augment = False 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 median_filter_width = 7 **kwargs )

参数

• vocab_size（int，可选，默认为 51865）— Whisper 模型的词汇量。定义了在调用 WhisperModel 时可以由decoder_input_ids表示的不同标记数量。

• num_mel_bins（int，可选，默认为 80）— 每个输入特征中使用的 mel 特征数量。应与WhisperProcessor类中使用的值对应。

• encoder_layers（int，可选，默认为 4）— 编码器层数。

• decoder_layers（int，可选，默认为 4）— 解码器层数。

• encoder_attention_heads（int，可选，默认为 6）— Transformer 编码器中每个注意力层的注意力头数。

• decoder_attention_heads (int, optional, 默认为 6) — Transformer 解码器中每个注意力层的注意力头数。

• encoder_ffn_dim (int, optional, 默认为 1536) — 编码器中“中间”（通常称为前馈）层的维度。

• decoder_ffn_dim (int, optional, 默认为 1536) — 解码器中“中间”（通常称为前馈）层的维度。

• encoder_layerdrop (float, optional, 默认为 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。

• decoder_layerdrop (float, optional, 默认为 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。

• decoder_start_token_id（int，optional，默认为 50257）--对应于“<|startoftranscript|>”标记，当没有向generate函数提供decoder_input_ids时，会自动使用该标记。它用于根据任务指导模型的生成过程。

• use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

• is_encoder_decoder (bool, optional, 默认为True) — 模型是否用作编码器/解码器。

• activation_function (str, optional, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• d_model (int, optional, 默认为 384) — 层的维度。

• dropout (float, optional, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢弃概率。

• attention_dropout (float, optional, 默认为 0.0) — 注意力概率的丢弃比率。

• activation_dropout (float, optional, 默认为 0.0) — 全连接层内部激活的丢弃比率。

• init_std (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• scale_embedding (bool, optional, 默认为 False) — 通过除以 sqrt(d_model)来缩放嵌入。

• max_source_positions (int, optional, 默认为 1500) — 该模型可能用于的对数梅尔滤波器组特征的最大序列长度。

• max_target_positions (int, optional, 默认为 448) — 该模型可能用于的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。

• pad_token_id (int, optional, 默认为 50256) — 填充标记 id。

• bos_token_id (int, optional, 默认为 50256) — 流的开始标记 id。

• eos_token_id (int, optional, 默认为 50256) — 流的结束标记 id。

• suppress_tokens (List[int], optional) — 包含将在generate函数中由对数处理器使用的非语音标记的列表。NON_SPEECH_TOKENS 和 NON_SPEECH_TOKENS_MULTI 分别对应于english-only和multilingual模型。

• begin_suppress_tokens (List[int], optional, 默认为[220,50256]) — 包含在采样过程开始时将被抑制的标记的列表。初始化为" "（blank_token_id）和eos_token_id的标记。

• use_weighted_layer_sum (bool, optional, 默认为False) — 是否使用带有学习权重的层输出的加权平均值。仅在使用 WhisperForAudioClassification 的实例时相关。

• classifier_proj_size (int, optional, 默认为 256) — 分类前的投影维度，用于标记均值池化。仅在使用 WhisperForAudioClassification 的实例时相关。

• apply_spec_augment (bool, optional, defaults to False) — 是否将SpecAugment数据增强应用于特征编码器的输出。有关详细信息，请参阅SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。

• mask_time_prob (float, optional, defaults to 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, defaults to 10) — 沿时间轴的向量跨度长度。

• mask_time_min_masks (int, optional, defaults to 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_prob*len(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时才相关。

• median_filter_width (int, optional, defaults to 7) — 用于在计算标记时间戳时平滑交叉注意力输出的中值滤波器的宽度。应为奇数。

这是用于存储 WhisperModel 配置的配置类。它用于根据指定的参数实例化 Whisper 模型，定义模型架构。使用默认值实例化配置将产生类似于 Whisper openai/whisper-tiny架构的配置。

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

示例：

>>> from transformers import WhisperConfig, WhisperModel

>>> # Initializing a Whisper tiny style configuration
>>> configuration = WhisperConfig()

>>> # Initializing a model (with random weights) from the tiny style configuration
>>> model = WhisperModel(configuration)

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

WhisperTokenizer

class transformers.WhisperTokenizer

< source >

( vocab_file merges_file normalizer_file = None errors = 'replace' unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' pad_token = None add_prefix_space = False language = None task = None predict_timestamps = False **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。

• merges_file (str) — 合并文件的路径。

• normalizer_file (str, optional) — 正则化器文件的路径。

• errors（str，optional，默认为"replace"）--将字节解码为 UTF-8 时要遵循的示例。请参阅bytes.decode了解更多信息。

• unk_token（str，optional，默认为"<|endoftext|>"）--未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。

• bos_token（str，optional，默认为"<|endoftext|>"）--序列标记的开头。decoder_start_token_id用于在生成时将第一个令牌设置为"<|startoftranscript|>"。

• eos_token（str，optional，默认为"<|endoftext|>"）--序列结束标记。

• pad_token (str, optional) — 用于填充的标记，例如在批处理不同长度的序列时。

• add_prefix_space (bool, optional, defaults to False) — 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。

• language（str，可选）--转录文本的语言。对于多语言语音识别和语音翻译任务，相应的语言 id 标记被附加到序列的开头，例如对于西班牙语，标记"<|es|>"被附加到顺序的开头。这只能用于多语言微调。

• task（str，可选）--要附加在序列开头的任务标识符（如果有）。这应用于多语言微调，"transcribe"用于语音识别，"translate"用于语音翻译。

• predict_timestamps（bool，*optional*，默认为False）--是否省略序列开头的<|notimestamps|>`标记。

构建一个 Whisper tokenizer。

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

set_prefix_tokens

<来源>

( language: str = None task: str = None predict_timestamps: bool = None )

参数

• language（str，可选，默认为 None）— 转录文本的语言。

• task（str，可选，默认为 None）— 任务标识符，附加在序列开头（如果有）。

• predict_timestamps（bool，optional，默认为None）--是否省略序列开头的<|notimestamps|>标记。

覆盖附加到标签序列开头的前缀标记。此方法可以独立使用以

在微调时根据需要更新前缀标记。示例：

>>> # instantiate the tokenizer and set the prefix token to Spanish
>>> tokenizer = WhisperTokenizer.from_pretrained("openai/whisper-tiny", language="spanish")
>>> # now switch the prefix token from Spanish to French
>>> tokenizer.set_prefix_tokens(language="french")

build_inputs_with_special_tokens

<来源>

( token_ids_0 token_ids_1 = None )

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

get_special_tokens_mask

<来源>

( 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]，可选）— 序列对的可选第二个 ID 列表。

• already_has_special_tokens（bool，可选，默认为 False）— 标记列表是否已经格式化为模型的特殊标记。

返回

List[int]

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

从没有添加特殊标记的标记列表中检索序列 ID。在使用分词器的 prepare_for_model 方法添加特殊标记时调用此方法。

create_token_type_ids_from_sequences

<来源>

( 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

<来源>

( save_directory: str filename_prefix: Optional = None )

batch_decode

<来源>

( sequences: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → export const metadata = 'undefined';List[str]

参数

• sequences（Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]）— 标记化输入 ID 的列表。可以使用 __call__ 方法获取。

• skip_special_tokens（bool，可选，默认为 False）— 是否在解码时删除特殊标记。

• clean_up_tokenization_spaces（bool，可选）— 是否清理分词空格。如果为 None，将默认为 self.clean_up_tokenization_spaces。

• kwargs（额外的关键字参数，可选）— 将传递给底层模型特定的解码方法。

返回

List[str]

解码的句子列表。

通过调用解码将标记 ID 的列表列表转换为字符串列表。

decode

<来源>

( token_ids skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None output_offsets: bool = False time_precision: float = 0.02 decode_with_timestamps: bool = False normalize: bool = False basic_normalize: bool = False remove_diacritics: bool = False **kwargs ) → export const metadata = 'undefined';str

参数

• token_ids（Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]）— 标记化输入 ID 的列表。可以使用 __call__ 方法获取。

• skip_special_tokens（bool，可选，默认为 False）— 是否在解码时删除特殊标记。

• clean_up_tokenization_spaces（bool，可选）— 是否清理分词空格。如果为 None，将默认为 self.clean_up_tokenization_spaces（在 tokenizer_config 中可用）。

• output_offsets (bool, optional, 默认为 False) — 是否输出标记的偏移量。只有在模型预测时间戳时才应设置此选项。

• time_precision (float, optional, 默认为 0.02) — 从标记转换为时间的时间比率。

• decode_with_timestamps (bool, optional, 默认为 False) — 是否在原始文本中包含时间戳进行解码。

• normalize (bool, optional, 默认为 False) — 是否对解码后的文本应用英文文本规范化。仅当目标文本为英文时适用。否则，应应用基本文本规范化。

• basic_normalize (bool, optional, 默认为 False) — 是否对解码后的文本应用基本文本规范化。适用于多语言目标文本。

• remove_diacritics (bool, optional, 默认为 False) — 在应用基本文本规范化时是否删除变音符号。删除变音符号可能会破坏解码后文本中的信息，因此应谨慎使用。

• kwargs（其他关键字参数，optional） — 将传递给底层模型特定的解码方法。

返回值

str

解码后的句子。

将 id 序列转换为字符串，使用 tokenizer 和词汇表，可选择删除特殊标记并清除标记化空格。

类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

WhisperTokenizerFast

class transformers.WhisperTokenizerFast

<来源>

( vocab_file = None merges_file = None normalizer_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' add_prefix_space = False language = None task = None predict_timestamps = False **kwargs )

参数

• vocab_file (str, optional) — 词汇文件的路径。

• merges_file (str, optional) — 合并文件的路径。

• normalizer_file (str, optional) — 正规化文件的路径。

• tokenizer_file (str, optional) — 包含加载 tokenizer 所需所有内容的 tokenizers 文件的路径（通常具有 .json 扩展名）。

• unk_token（str，optional，默认为"<|endoftext|>"）--未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。

• bos_token（str，optional，默认为"<|endoftext|>"）--序列标记的开头。decoder_start_token_id用于在生成时将第一个令牌设置为"<|startoftranscript|>"。

• eos_token（str，optional，默认为"<|endoftext|>"）--序列结束标记。

• add_prefix_space (bool, optional, 默认为 False) — 是否在输入前添加一个初始空格。这样可以将前导单词视为任何其他单词。（Whisper tokenizer 通过前面的空格检测单词的开头）。

• language（str，可选）--转录文本的语言。对于多语言语音识别和语音翻译任务，相应的语言 id 标记被附加到序列的开头，例如对于西班牙语，标记"<|es|>"被附加到顺序的开头。这只能用于多语言微调。

• task（str，可选）--要附加在序列开头的任务标识符（如果有）。这应用于多语言微调，“转录”用于语音识别，“翻译”用于语音翻译。

• predict_timestamps（bool，optional，默认为False）--是否省略序列开头的<|notimestamps|>标记。

构建一个“快速”的 Whisper tokenizer（由 HuggingFace 的 tokenizers 库支持）。

此 tokenizer 继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

set_prefix_tokens

<来源>

( language: str = None task: str = None predict_timestamps: bool = None )

参数

• language (str, optional, 默认为 None) — 转录文本的语言。

• task (str, optional, 默认为 None) — 要附加到序列开头的任务标识符（如果有）。

• predict_timestamps（bool，optional，默认为None）--是否省略序列开头的<|notimestamps|>标记。

覆盖附加到标签序列开头的前缀标记。此方法可单独使用以

根据需要更新前缀标记进行微调。示例：

>>> # instantiate the tokenizer and set the prefix token to Spanish
>>> tokenizer = WhisperTokenizerFast.from_pretrained("openai/whisper-tiny", language="spanish")
>>> # now switch the prefix token from Spanish to French
>>> tokenizer.set_prefix_tokens(language="french")

build_inputs_with_special_tokens

<来源>

( token_ids_0 token_ids_1 = None )

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

get_special_tokens_mask

<来源>

( 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]，可选）— 序列对的第二个 ID 列表。

• already_has_special_tokens（bool，可选，默认为False）— 标记列表是否已经使用特殊标记格式化为模型。

返回

List[int]

整数列表在范围[0, 1]内：1 表示特殊标记，0 表示序列标记。

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

create_token_type_ids_from_sequences

<来源>

( 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

<来源>

( save_directory: str filename_prefix: Optional = None )

batch_decode

<来源>

( sequences: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → export const metadata = 'undefined';List[str]

参数

• sequences（Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]）— 标记化输入 ID 的列表。可以使用__call__方法获得。

• skip_special_tokens（bool，可选，默认为False）— 是否在解码中删除特殊标记。

• clean_up_tokenization_spaces（bool，可选）— 是否清除标记空格。如果为None，将默认为self.clean_up_tokenization_spaces。

• kwargs（其他关键字参数，可选）— 将传递给底层模型特定解码方法。

返回

List[str]

解码句子的列表。

通过调用解码将标记 ID 列表的列表转换为字符串列表。

decode

<来源>

( token_ids skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None output_offsets: bool = False time_precision: float = 0.02 decode_with_timestamps: bool = False normalize: bool = False basic_normalize: bool = False remove_diacritics: bool = False **kwargs ) → export const metadata = 'undefined';str

参数

• token_ids（Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]）— 标记化输入 ID 的列表。可以使用__call__方法获得。

• skip_special_tokens（bool，可选，默认为False）— 是否在解码中删除特殊标记。

• clean_up_tokenization_spaces（bool，可选）— 是否清除标记空格。如果为None，将默认为self.clean_up_tokenization_spaces（在tokenizer_config中可用）。

• output_offsets（bool，可选，默认为False）— 是否输出标记的偏移量。只有在模型预测时间戳时才应设置此选项。

• time_precision（float，可选，默认为 0.02）— 从标记到时间的转换时间比率。

• decode_with_timestamps（bool，可选，默认为False）— 是否在原始文本中包含时间戳进行解码。

• normalize（bool，可选，默认为False）— 是否对解码文本应用英文文本规范化。仅在目标文本为英文时适用。否则，应应用基本文本规范化。

• basic_normalize（bool，可选，默认为False）— 是否对解码文本应用基本文本规范化。适用于多语言目标文本。

• remove_diacritics（bool，可选，默认为False）— 是否在应用基本文本规范化时删除变音符号。删除变音符号可能会破坏解码文本中的信息，因此应谨慎使用。

• kwargs（额外的关键字参数，可选）- 将传递给底层模型特定的解码方法。

返回

str

解码后的句子。

将字符串中的 ids 序列转换为字符串，使用 tokenizer 和词汇表，可选择删除特殊标记并清理标记化空格。

类似于执行self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

WhisperFeatureExtractor

class transformers.WhisperFeatureExtractor

<来源>

( feature_size = 80 sampling_rate = 16000 hop_length = 160 chunk_length = 30 n_fft = 400 padding_value = 0.0 return_attention_mask = False **kwargs )

参数

• feature_size（int，默认为 80）- 提取特征的特征维度。

• sampling_rate（int，默认为 16000）- 音频文件应数字化的采样率，以赫兹（Hz）表示。

• hop_length（int，默认为 160）- 用于获取梅尔频率系数的 STFT 的重叠窗口的长度。

• chunk_length（int，默认为 30）- 用于修剪和填充较长或较短音频序列的sampling_rate样本的最大块数。

• n_fft（int，默认为 400）- 傅立叶变换的大小。

• padding_value（float，可选，默认为 0.0）- 用于填充音频的填充值。应对应于静音。

构建一个 Whisper 特征提取器。

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

该类使用自定义的 numpy 实现从原始语音中提取 mel 滤波器组特征，该实现应与 pytorch 的torch.stft等效。

__call__

<来源>

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

参数

• raw_speech（np.ndarray，List[float]，List[np.ndarray]，List[List[float]]）- 要填充的序列或序列批次。每个序列可以是 numpy 数组，浮点值列表，numpy 数组列表或浮点值列表的列表。必须是单声道音频，不是立体声，即每个时间步长一个浮点数。

• truncation（bool，可选，默认为True）- 激活截断以将输入序列截断为max_length以上的长度为max_length。

• pad_to_multiple_of（int，可选，默认为 None）- 如果设置，将填充序列到提供的值的倍数。

  这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用，其计算能力为>= 7.5（Volta），或者对于受益于序列长度为 128 的 TPUs。

• return_attention_mask（bool，可选）- 是否返回注意力掩码。如果保持默认设置，将根据特定 feature_extractor 的默认设置返回注意力掩码。

  什么是注意力掩码？

  对于 Whisper 模型，批量推理时应始终传递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）- 用于填充填充值/向量的值。

• do_normalize（bool，可选，默认为False）— 是否对输入进行零均值单位方差归一化。归一化可以帮助显著提高模型的性能。

用于对一个或多个序列进行特征化和准备模型的主要方法。如果可用，实现使用 PyTorch 进行 STFT 计算，否则使用较慢的基于 NumPy 的方法。

WhisperProcessor

class transformers.WhisperProcessor

< source >

( feature_extractor tokenizer )

参数

• feature_extractor（WhisperFeatureExtractor）— WhisperFeatureExtractor 的一个实例。特征提取器是必需的输入。

• tokenizer（WhisperTokenizer）— WhisperTokenizer 的一个实例。分词器是必需的输入。

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

WhisperProcessor 提供了 WhisperFeatureExtractor 和 WhisperTokenizer 的所有功能。有关更多信息，请参阅call()和 decode()。

__call__

< source >

( *args **kwargs )

将audio参数转发到 WhisperFeatureExtractor 的call()，将text参数转发到call()。请参阅上述两种方法的文档字符串以获取更多信息。

from_pretrained

< source >

( 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

<来源>

( 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

<来源>

( *args **kwargs )

此方法将其所有参数转发到 WhisperTokenizer 的 batch_decode()。请参考此方法的文档字符串以获取更多信息。

decode

<来源>

( *args **kwargs )

此方法将其所有参数转发到 WhisperTokenizer 的 decode()。请参考此方法的文档字符串以获取更多信息。

PytorchHide Pytorch 内容

WhisperModel

class transformers.WhisperModel

<来源>

( config: WhisperConfig )

参数

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

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

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

forward

<来源>

( 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 decoder_position_ids: 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.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_features（形状为(batch_size, feature_size, sequence_length)的torch.FloatTensor）- 从原始语音波形中提取的浮点值 mel 特征。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要准备好数组为input_features，应使用 AutoFeatureExtractor 来提取 mel 特征，填充并转换为torch.FloatTensor类型的张量。请参阅call()

• attention_mask（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于避免在填充标记索引上执行SpecAugment数据增强的掩码。掩码值选定在[0, 1]之间：

  • 1 表示标记未被掩码，

  • 0 表示标记被掩码。

  注意力掩码是什么？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 解码器输入序列标记在词汇表中的索引。

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

  解码器输入 ID 是什么？

  Whisper 使用decoder_start_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

  如果您想要更改填充行为，您应该阅读modeling_whisper._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参阅BART 论文中的图表 1。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）- 用于将编码器中注意力模块的选定头部置零的掩码。掩码值选定在[0, 1]之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• 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的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，用户可以选择仅输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的输入）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• decoder_inputs_embeds (torch.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示，而不是传递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 而不是一个普通元组。

返回

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

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

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列输出。

  如果使用了past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values (tuple(tuple(torch.FloatTensor)), 可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。

• decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> model = WhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], 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, 512]

_mask_input_features

<来源>

( input_features: FloatTensor attention_mask: Optional = None )

根据SpecAugment沿时间轴和/或特征轴掩盖提取的特征。

WhisperForConditionalGeneration

class transformers.WhisperForConditionalGeneration

<来源>

( config: WhisperConfig )

参数

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

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

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

forward

<来源>

( 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 decoder_position_ids: 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（形状为(batch_size, feature_size, sequence_length)的torch.FloatTensor）- 从原始语音波形中提取的浮点值 mel 特征。原始语音波形可以通过将.flac或.wav音频文件加载到类型为List[float]或numpy.ndarray的数组中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_features，应使用 AutoFeatureExtractor 来提取 mel 特征，填充并转换为torch.FloatTensor类型的张量。参见call()

• attention_mask（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于避免在填充标记索引上执行SpecAugment数据增强的掩码。掩码值选定在[0, 1]范围内：

  • 1 表示头部未被掩盖,

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 词汇表中解码器输入序列标记的索引。

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

  什么是解码器输入 ID？

  Whisper 使用decoder_start_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可能只需输入最后的decoder_input_ids（请参见past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

  如果要更改填充行为，应阅读modeling_whisper._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见BART 论文中的图表 1。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）- 用于在编码器中使注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]范围内：

  • 1 表示头部未被掩盖,

  • 0 表示头部被掩盖。

• 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的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输入）。

  如果使用past_key_values，用户可以选择只输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的输入），而不是形状为(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）包含根据配置（WhisperConfig）和输入的不同元素。

• loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）— 语言建模损失。

• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于加速顺序解码（参见past_key_values输入）。

• decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出和每一层的输出）。

  解码器在每一层输出的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

• cross_attentions (tuple(torch.FloatTensor)，可选，当传递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)，可选) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出和每一层的输出）。

  编码器在每一层输出的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

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

>>> inputs = processor(ds[0]["audio"]["array"], 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
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

generate

<来源>

( input_features: Optional = None generation_config: Optional = None logits_processor: Optional = None stopping_criteria: Optional = None prefix_allowed_tokens_fn: Optional = None synced_gpus: bool = False return_timestamps: Optional = None task: Optional = None language: Optional = None is_multilingual: Optional = None prompt_ids: Optional = None condition_on_prev_tokens: Optional = None temperature: Union = None compression_ratio_threshold: Optional = None logprob_threshold: Optional = None no_speech_threshold: Optional = None num_segment_frames: Optional = None attention_mask: Optional = None time_precision: float = 0.02 return_token_timestamps: Optional = None return_segments: bool = False return_dict_in_generate: Optional = None **kwargs ) → export const metadata = 'undefined';ModelOutput or torch.LongTensor or Dict[str, Any]

参数

• input_features（torch.Tensor，形状为(batch_size, feature_size, sequence_length)，可选）— 浮点值的对数梅尔特征，从原始语音波形中提取。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_features，应使用 AutoFeatureExtractor 来提取梅尔特征，填充并转换为torch.FloatTensor类型的张量。详细信息请参见call()。

• generation_config（~generation.GenerationConfig，可选）— 用作生成调用的基本参数化的生成配置。传递给生成的**kwargs与generation_config的属性匹配将覆盖它们。如果未提供generation_config，将使用默认值，其加载优先级如下：1）从generation_config.json模型文件中，如果存在；2）从模型配置中。请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查其文档以参数化生成。

• logits_processor（LogitsProcessorList，可选）— 自定义对数处理器，补充由参数和生成配置构建的默认对数处理器。如果传递的对数处理器已经使用参数或生成配置创建，则会引发错误。此功能适用于高级用户。

• 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 是必需的）

• return_timestamps（bool，可选）— 是否返回文本的时间戳。这将启用WhisperTimestampsLogitsProcessor。

• task（str，可选）— 用于生成的任务，可以是“translate”或“transcribe”。model.config.forced_decoder_ids将相应更新。

• language（str，optional）--用于生成的语言标记，可以是<|en|>、en或english形式。您可以在model.generation_config.lang_to_id字典中找到所有可能的语言标记。

• is_multilingual（bool，可选）— 模型是否是多语言的。

• prompt_ids（torch.Tensor，可选）— 通过将文本传递给get_prompt_ids()创建的令牌 ID 的秩-1 张量，作为每个块的提示提供。这可用于为转录提供或“提示工程”上下文，例如自定义词汇或专有名词，以使其更有可能正确预测这些单词。它不能与decoder_start_token_id结合使用，因为它会覆盖此值。

• condition_on_prev_tokens（bool，可选）— 仅适用于长篇转录。是否将每个片段的生成条件设置为前一个片段。如Whisper 论文所示，这可以帮助提高性能。

• temperature (float 或 float 列表，可选) — 用于生成的温度。传递单个 float 值并且 do_sample=True 会激活使用采样进行生成。对于长篇转录，可以通过传递一组浮点值（例如 (0.0, 0.2, 0.4, 0.6, 0.8, 1.0)）来激活温度回退。正如Whisper 论文所示，这可以帮助提高性能。

• compression_ratio_threshold (float, 可选) — 仅适用于长篇转录。如果定义了，将计算每个片段的 zlib 压缩率。如果一个片段的压缩率高于 compression_ratio_threshold，则激活温度回退：生成的片段被丢弃，使用更高的温度重复生成。这个特性背后的直觉是，具有非常高压缩率的片段存在大量重复。通过增加温度注入更多随机性可以减少不需要的重复。如果定义了 compression_ratio_threshold，请确保 temperature 是一个值列表。compression_ratio_threshold 的常见值为 1.35。正如Whisper 论文所示，这可以帮助提高性能。

• logprob_threshold (float, 可选) — 仅适用于长篇转录。如果定义了，将计算每个片段的平均对数概率。如果给定片段的对数概率低于 logprob_threshold，则激活温度回退：生成的片段被丢弃，使用更高的温度重复生成。这个特性背后的直觉是，低对数概率的片段可以通过增加温度注入更多随机性来改善。如果定义了 logprob_threshold，请确保 temperature 是一个值列表。logprob_threshold 的常见值为 -1.0。正如Whisper 论文所示，这可以帮助提高性能。

• no_speech_threshold (float, 可选) — 仅适用于长篇转录。如果定义了，“无语音”标记与 logprob_threshold 结合使用来确定一个片段是否只包含静音。在这种情况下，将跳过该片段的转录。正如Whisper 论文所示，这可以帮助提高性能。

• num_segment_frames (int, 可选) — 单个片段包含的帧数。如果未定义，num_segment_frames 默认为模型的步幅乘以最大输入长度。

• attention_mask (torch.Tensor, 可选) — 在使用批量大小 > 1 进行长篇转录时需要传递 attention_mask。

• time_precision (int, 可选, 默认为 0.02) — 输出标记的持续时间（秒）。例如，0.02 表示生成的标记平均占据 20 毫秒。

• return_token_timestamps (bool, 可选) — 是否返回文本的标记级时间戳。可以与 return_timestamps 选项一起使用。要获得单词级时间戳，请使用分词器将标记分组成单词。

• return_segments (bool, 可选, 默认为 False) — 是否额外返回所有片段的列表。请注意，只有在进行长篇转录时才能启用此选项。

• return_dict_in_generate (bool, 可选, 默认为 False) — 是否返回 ModelOutput 而不仅仅返回生成的标记。请注意，在进行长篇转录时，只有在设置 return_segments 为 True 时才能启用 return_dict_in_generate。在这种情况下，每个片段的生成输出将添加到每个片段中。

• kwargs（Dict[str, Any]，可选）-generate_config的特定于特定模型的参数化和/或其他模型特定 kwargs，将转发到模型的forward函数。如果模型是编码器-解码器模型，则不应以前缀形式指定编码器特定 kwargs，而应以decoder_为前缀指定解码器特定 kwargs。

返回

ModelOutput 或torch.LongTensor或Dict[str, Any]

一个 ModelOutput（如果return_dict_in_generate=True或当config.return_dict_in_generate=True时）或一个torch.FloatTensor或一个段的字典，当return_segments=True时。

如果传入的输入> 30 秒/ > 3000 mel 输入特征，并且return_segments=True，则返回一个生成的序列 id 字典，称为sequences，以及每个生成段的列表。

否则，如果传入的输入<= 30 秒/ >= 3000 mel 输入特征，则可能的 ModelOutput 类型为：

• GenerateEncoderDecoderOutput，

• GenerateBeamEncoderDecoderOutput

否则，仅返回生成的输出序列 id。

将对数 mel 输入特征转录或翻译为自回归生成的令牌 id 序列。

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

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

示例：

• 详细转录：要转录或翻译超过 30 秒的音频，请处理音频文件而不截断，并一次传递所有 mel 特征以生成。

>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset, Audio

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> model.cuda()

>>> # load audios > 30 seconds
>>> ds = load_dataset("distil-whisper/meanwhile", "default")["test"]
>>> # resample to 16kHz
>>> ds = ds.cast_column("audio", Audio(sampling_rate=16000))
>>> # take first 8 audios and retrieve array
>>> audio = ds[:8]["audio"]
>>> audio = [x["array"] for x in audio]

>>> # make sure to NOT truncate the input audio, to return the `attention_mask` and to pad to the longest audio
>>> inputs = processor(audio, return_tensors="pt", truncation=False, padding="longest", return_attention_mask=True, sampling_rate=16_000)
>>> inputs = inputs.to("cuda", torch.float32)

>>> # transcribe audio to ids
>>> generated_ids = model.generate(**inputs)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription[0]
' Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile!'

• 简化转录：如果传入的 mel 输入特征< 30 秒，则整个音频将通过一次调用生成进行转录。

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

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

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

>>> inputs = processor(ds[0]["audio"]["array"], 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
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

WhisperForCausalLM

class transformers.WhisperForCausalLM

<来源>

( config )

参数

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

Whisper 解码器，顶部带有语言建模头（线性层，其权重与输入嵌入绑定）。

这个模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入大小，修剪头等）。

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

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None encoder_outputs: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None 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.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 中：

  • 1 表示标记是 not masked，

  • 0 表示标记是 masked。什么是注意力掩码？

• encoder_outputs (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使注意力模块中选择的头部失效的掩码。掩码值选在 [0, 1] 中：

  • 1 表示头部未被 masked，

  • 0 表示头部被 masked。

• cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使交叉注意力模块中选择的头部失效的掩码。掩码值选在 [0, 1] 中：

  • 1 表示头部未被 masked，

  • 0 表示头部被 masked。

• 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 输入）。如果使用了 past_key_values，用户可以选择只输入最后一个形状为 (batch_size, 1) 的 decoder_input_ids（这些没有将其过去的键值状态提供给该模型的标记）而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应该在 [0, ..., config.vocab_size] 或 -100（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。

• use_cache (bool, optional) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

  • 1 表示标记是 not masked，

  • 0 表示标记是 masked。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的元组。

返回值

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

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

• 损失 (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个标记预测）。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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 后的自注意力头中的注意力权重，用于计算加权平均值。

• cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

  注意力 softmax 后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。

  包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（查看past_key_values输入）。

示例：

>>> from transformers import WhisperForCausalLM, WhisperForConditionalGeneration, WhisperProcessor
>>> import torch
>>> from datasets import load_dataset

>>> processor = WhisperProcessor.from_pretrained("openai/whisper-large-v2")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v2")

>>> assistant_model = WhisperForCausalLM.from_pretrained("distil-whisper/distil-large-v2")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> sample = ds[0]["audio"]
>>> input_features = processor(
...     sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt"
... ).input_features

>>> predicted_ids = model.generate(input_features, assistant_model=assistant_model)

>>> # decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.'

WhisperForAudioClassification

class transformers.WhisperForAudioClassification

<来源>

( config )

参数

• input_features (torch.FloatTensor，形状为(batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点值 mel 特征。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_features，应使用 AutoFeatureExtractor 来提取 mel 特征，填充并转换为torch.FloatTensor类型的张量。请参见call()

• head_mask (torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，optional) — 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• 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)是编码器最后一层输出的隐藏状态序列。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

带有顶部序列分类头部（在汇聚输出上的线性层）的 Whisper 编码器模型，用于类似 SUPERB 关键词识别的任务。

forward

<来源>

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

参数

• input_features (torch.FloatTensor，形状为(batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点值 mel 特征。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_features，应使用 AutoFeatureExtractor 来提取 mel 特征，填充并转换为torch.FloatTensor类型的张量。请参见call()

• head_mask (torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，optional) — 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• 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)是编码器最后一层输出的隐藏状态序列。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor of shape (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 时）包含各种元素，取决于配置（WhisperConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。

• logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> model = WhisperForAudioClassification.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")

>>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True)
>>> sample = next(iter(ds))

>>> inputs = feature_extractor(
...     sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features

>>> with torch.no_grad():
...     logits = model(input_features).logits

>>> predicted_class_ids = torch.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'Afrikaans'

TensorFlowHide TensorFlow 内容

TFWhisperModel

class transformers.TFWhisperModel

< source >

( config: WhisperConfig **kwargs )

参数

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

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

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

call

<来源>

( input_features: TFModelInputType | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None decoder_position_ids: 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: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: Optional[Tuple[Union[np.ndarray, tf.Tensor]]] = 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqModelOutput or tuple(tf.Tensor)

参数

• input_features（形状为(batch_size, feature_size, sequence_length)的tf.Tensor）- 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_features，应使用 AutoFeatureExtractor 来提取 fbank 特征，填充并转换为tf.Tensor类型的张量。请参见call()

• decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 词汇表中解码器输入序列标记的索引。

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

  什么是 decoder input IDs？

  SpeechToText 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，可选择只输入最后的decoder_input_ids（参见past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）- 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果蒙版也将默认使用。

  如果要更改填充行为，请阅读modeling_whisper._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

• 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（tuple(tuple(tf.Tensor)，可选）- 元组包含(last_hidden_state，可选：hidden_states，可选：attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（tuple(tuple(tf.Tensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tuple(tf.Tensor)的元组，每个元组有 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。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递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 而不是普通元组。

返回

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

一个 transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（WhisperConfig）和输入而异的各种元素。

• 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)。

  包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

• 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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import tensorflow as tf
>>> from transformers import TFWhisperModel, AutoFeatureExtractor
>>> from datasets import load_dataset

>>> model = TFWhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="tf")
>>> input_features = inputs.input_features
>>> decoder_input_ids = tf.convert_to_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, 512]

TFWhisperForConditionalGeneration

class transformers.TFWhisperForConditionalGeneration

<来源>

( config: WhisperConfig **kwargs )

参数

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

带有语言建模头的 Whisper 模型。可用于自动语音识别。该模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

call

<来源>

( input_features: TFModelInputType | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None decoder_position_ids: 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: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: Optional[Tuple[Union[np.ndarray, tf.Tensor]]] = 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: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqLMOutput or tuple(tf.Tensor)

参数

• input_features（形状为(batch_size, feature_size, sequence_length)的tf.Tensor）— 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要准备好数组为input_features，应使用 AutoFeatureExtractor 来提取 fbank 特征，填充并转换为tf.Tensor类型的张量。参见call()

• decoder_input_ids（形状为(batch_size, target_sequence_length)的tf.Tensor，可选）— 解码器输入序列标记在词汇表中的索引。

  可以使用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 (tf.Tensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

  如果要更改填充行为，应阅读modeling_whisper._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

• head_mask (tf.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于使编码器中注意力模块的选择头部失效的掩码。掩码值选在[0, 1]：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• decoder_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于在解码器中使选择的注意力模块的头部失效的掩码。掩码值选在[0, 1]范围内：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• cross_attn_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使交叉注意力模块的选择头部失效的掩码。掩码值选在[0, 1]范围内：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• encoder_outputs (tuple(tuple(tf.Tensor), optional) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层的输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(tf.Tensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tf.Tensor)元组，每个元组有 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 (tf.Tensor 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，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。

• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

• labels（形状为(batch_size, sequence_length)的tf.Tensor，可选）- 用于计算语言建模损失的标签。索引应该在[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）包含根据配置（WhisperConfig）和输入的不同元素。

• loss（形状为(n,)的tf.Tensor，可选，当提供labels时返回，其中 n 是未屏蔽标签的数量）- 语言建模损失。

• logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• 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), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

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

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

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

示例：

>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFWhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = TFWhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

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

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

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

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

JAXHide JAX content

FlaxWhisperModel

class transformers.FlaxWhisperModel

< source >

( config: WhisperConfig input_shape: Tuple = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

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

• dtype (jax.numpy.dtype, optional, defaults to jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的dtype执行。请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。如果您希望更改模型参数的 dtype，请参阅 to_fp16()和 to_bf16()。

裸 Whisper 模型变压器输出原始隐藏状态，没有特定的头部。此模型继承自 FlaxPreTrainedModel。检查超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。此模型还是 Flax Linen flax.nn.Module子类。将其用作常规 Flax 模块，并参考 Flax 文档以了解所有与一般用法和行为相关的事项。最后，此模型支持固有的 JAX 功能，例如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

< source >

( input_features: Array decoder_input_ids: Array attention_mask: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_features（形状为(batch_size, feature_size, sequence_length)的numpy.ndarray）- 从原始语音波形中提取的浮点值 mel 特征。原始语音波形可以通过将.flac或.wav音频文件加载到类型为List[float]或numpy.ndarray的数组中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成input_features，应使用 WhisperFeatureExtractor 来提取特征，填充并转换为类型为numpy.ndarray的张量。参见call()

• attention_mask（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- Whisper 不支持对input_features进行掩码，此参数保留以确保兼容性，但不会使用。默认情况下，输入对数 mel 频谱图中的静音将被忽略。

• decoder_input_ids（形状为(batch_size, target_sequence_length)的numpy.ndarray，可选）- 词汇表中解码器输入序列标记的索引。可以使用 WhisperTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是解码器输入 ID？ Whisper 使用decoder_start_token_id作为decoder_input_ids生成的起始标记。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的numpy.ndarray，可选）- 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

• position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- Whisper 在编码器中不使用position_ids，因为input_features始终具有相同的大小且不使用掩码，但此参数保留以确保兼容性。默认情况下，输入对数 mel 频谱图中的静音将被忽略。

• decoder_position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）- 每个解码器输入序列标记的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的attentions。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。

• return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或tuple(torch.FloatTensor)

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

• last_hidden_state (形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray`) — 模型解码器最后一层的隐藏状态序列。

  如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后隐藏状态。

• past_key_values (tuple(tuple(jnp.ndarray)), 可选的, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

• decoder_hidden_states (tuple(jnp.ndarray), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。

  解码器在每一层输出时的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(jnp.ndarray), 可选的, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

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

• cross_attentions (tuple(jnp.ndarray), 可选的, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray`, 可选的) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(jnp.ndarray), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。

  编码器在每一层输出时的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(jnp.ndarray), 可选的, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

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

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

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

示例:

>>> from transformers import AutoTokenizer, FlaxWhisperModel

>>> tokenizer = AutoTokenizer.from_pretrained("openai/whisper-tiny")
>>> model = FlaxWhisperModel.from_pretrained("openai/whisper-tiny")

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

>>> last_hidden_states = outputs.last_hidden_state

FlaxWhisperForConditionalGeneration

class transformers.FlaxWhisperForConditionalGeneration

<来源>

( config: WhisperConfig input_shape: Tuple = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

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

• dtype (jax.numpy.dtype, 可选, 默认为 jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的dtype执行。请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。如果要更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

带有语言建模头的 Whisper 模型。此模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。此模型还是 Flax Linen flax.nn.Module子类。将其用作常规 Flax 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。最后，此模型支持内在的 JAX 功能，例如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_features: Array decoder_input_ids: Array attention_mask: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_features (numpy.ndarray，形状为(batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点值梅尔特征。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要准备数组为input_features，应使用 WhisperFeatureExtractor 来提取特征、填充和转换为numpy.ndarray类型的张量。参见call()。

• attention_mask (numpy.ndarray，形状为(batch_size, sequence_length)，可选) — Whisper 不支持input_features的掩码，此参数保留以确保兼容性，但不会使用。默认情况下，输入对数梅尔频谱中的静音将被忽略。

• decoder_input_ids (numpy.ndarray of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。可以使用 WhisperTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。Whisper 使用decoder_start_token_id作为decoder_input_ids生成的起始标记。

• decoder_attention_mask (numpy.ndarray of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

• position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — Whisper 在编码器中不使用position_ids，因为input_features始终具有相同的大小并且不使用掩码，但为了兼容性保留了这个参数。默认情况下，输入对数梅尔频谱中的静音将被忽略。

• decoder_position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 解码器输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或tuple(torch.FloatTensor)

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

• logits (jnp.ndarray of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。

• decoder_hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

  解码器在每一层输出的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

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

• cross_attentions (tuple(jnp.ndarray)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出 + 一个用于每一层的输出）。

  编码器在每一层输出的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

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

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

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

转录示例：

>>> from transformers import WhisperProcessor, FlaxWhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = WhisperProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = FlaxWhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en", from_pt=True)
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="np")
>>> input_features = inputs.input_features
>>> generated_ids = model.generate(input_ids=input_features)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

FlaxWhisperForAudioClassification

class transformers.FlaxWhisperForAudioClassification

<来源>

( config: WhisperConfig input_shape: Tuple = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

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

• dtype (jax.numpy.dtype，可选，默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）中的一种。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的dtype执行。请注意，这仅指定计算的数据类型，不影响模型参数的数据类型。如果您希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

带有顶部音频分类头的 Whisper 模型。此模型继承自 FlaxPreTrainedModel。检查超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。此模型还是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax 模块，并参考 Flax 文档以获取有关一般用法和行为的所有相关信息。最后，此模型支持内在的 JAX 功能，例如：

• 即时 (JIT) 编译

• 自动微分

• 矢量化

• 并行化

__call__

< source >

( input_features: Array attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_features (numpy.ndarray of shape (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点值 mel 特征。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到类型为 List[float] 或 numpy.ndarray 的数组中获得，例如通过 soundfile 库 (pip install soundfile)。要将数组准备成 input_features，应使用 WhisperFeatureExtractor 来提取特征，填充并转换为类型为 numpy.ndarray 的张量。参见 call()

• attention_mask (numpy.ndarray of shape (batch_size, sequence_length), 可选) — Whisper 不支持对 input_features 进行掩码，此参数保留了兼容性，但不会使用。默认情况下，输入对数 mel 频谱图中的静音会被忽略。

• decoder_input_ids (numpy.ndarray of shape (batch_size, target_sequence_length), 可选) — 词汇表中解码器输入序列标记的索引。可以使用 WhisperTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是解码器输入 ID？ Whisper 使用 decoder_start_token_id 作为 decoder_input_ids 生成的起始标记。

• decoder_attention_mask (numpy.ndarray of shape (batch_size, target_sequence_length), 可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下还将使用因果掩码。如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见 论文 中的图表 1。

• position_ids (numpy.ndarray of shape (batch_size, sequence_length), 可选) — Whisper 在编码器中不使用 position_ids，因为 input_features 总是相同大小且不使用掩码，但为了兼容性保留了此参数。默认情况下，输入对数 mel 频谱图中的静音会被忽略。

• decoder_position_ids (numpy.ndarray of shape (batch_size, sequence_length), 可选) — 每个解码器输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或tuple(torch.FloatTensor)

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

• logits (jnp.ndarray，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。

• hidden_states (tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每层的输出）。

  模型在每一层输出的隐藏状态以及初始嵌入输出。

• attentions (tuple(jnp.ndarray), 可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

转录示例：

>>> import jax.numpy as jnp
>>> from transformers import AutoFeatureExtractor, FlaxWhisperForAudioClassification
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> model = FlaxWhisperForAudioClassification.from_pretrained(
...     "sanchit-gandhi/whisper-medium-fleurs-lang-id", from_pt=True
... )
>>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True)

>>> sample = next(iter(ds))

>>> inputs = feature_extractor(
...     sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="np"
... )
>>> input_features = inputs.input_features

>>> logits = model(input_features).logits

>>> predicted_class_ids = jnp.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'af_za'

XLS-R

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/xls_r

概述

XLS-R 模型由 Arun Babu、Changhan Wang、Andros Tjandra、Kushal Lakhotia、Qiantong Xu、Naman Goyal、Kritika Singh、Patrick von Platen、Yatharth Saraf、Juan Pino、Alexei Baevski、Alexis Conneau、Michael Auli 在XLS-R: Self-supervised Cross-lingual Speech Representation Learning at Scale中提出。

论文的摘要如下：

本文介绍了 XLS-R，这是一个基于 wav2vec 2.0 的大规模跨语言语音表示学习模型。我们在 128 种语言中使用多达 20 亿参数的模型进行训练，使用近 50 万小时的公开可用语音音频数据，比已知最大的先前工作的公共数据量大一个数量级。我们的评估涵盖了各种任务、领域、数据制度和语言，包括高资源和低资源语言。在 CoVoST-2 语音翻译基准测试中，我们将先前的最新技术平均提高了 7.4 BLEU，涵盖了 21 个翻译方向到英语。对于语音识别，XLS-R 在 BABEL、MLS、CommonVoice 以及 VoxPopuli 等最佳已知先前工作上的错误率平均降低了 14-34%。XLS-R 还在 VoxLingua107 语言识别上树立了新的技术水平。此外，我们展示了在足够大的模型尺寸下，跨语言预训练可以在将英语语音翻译成其他语言时胜过仅英语预训练，这种情况有利于单语预训练。我们希望 XLS-R 可以帮助改进世界上更多语言的语音处理任务。

相关的检查点可以在huggingface.co/models?other=xls_r下找到。

原始代码可以在这里找到。

使用提示

• XLS-R 是一个语音模型，接受与语音信号的原始波形对应的浮点数组。

• XLS-R 模型是使用连接主义时间分类（CTC）进行训练的，因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。

XLS-R 的架构基于 Wav2Vec2 模型，请参考 Wav2Vec2 的文档页面获取 API 参考。

XLSR-Wav2Vec2

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/xlsr_wav2vec2

概述

XLSR-Wav2Vec2 模型是由 Alexis Conneau，Alexei Baevski，Ronan Collobert，Abdelrahman Mohamed，Michael Auli 在无监督跨语言表示学习语音识别中提出的。

论文摘要如下：

本文介绍了 XLSR，通过在多种语言的语音的原始波形上预训练单一模型来学习跨语言语音表示。我们构建在 wav2vec 2.0 的基础上，该模型通过解决对掩码潜在语音表示的对比任务进行训练，并共同学习跨语言共享的潜在量化。结果模型在标记数据上进行微调，实验表明跨语言预训练明显优于单语言预训练。在 CommonVoice 基准测试中，XLSR 相对音素错误率降低了 72%，相对于已知最佳结果。在 BABEL 上，我们的方法相对于类似系统改善了 16%的词错误率。我们的方法实现了一个单一的多语言语音识别模型，与强大的个体模型竞争。分析表明，潜在的离散语音表示在不同语言之间共享，对于相关语言的共享增加。我们希望通过发布在 53 种语言中预训练的大型模型 XLSR-53 来促进低资源语音理解的研究。

原始代码可以在这里找到。

使用提示

• XLSR-Wav2Vec2 是一个语音模型，接受与语音信号的原始波形对应的浮点数组。

• XLSR-Wav2Vec2 模型是使用连接主义时间分类（CTC）进行训练的，因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。

XLSR-Wav2Vec2 的架构基于 Wav2Vec2 模型，因此可以参考 Wav2Vec2 的文档页面。

多模型模型

ALIGN

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/align

概述

ALIGN 模型在通过嘈杂文本监督扩展视觉和视觉语言表示学习中由 Chao Jia、Yinfei Yang、Ye Xia、Yi-Ting Chen、Zarana Parekh、Hieu Pham、Quoc V. Le、Yunhsuan Sung、Zhen Li、Tom Duerig 提出。ALIGN 是一个多模态视觉和语言模型。它可用于图像文本相似度和零样本图像分类。ALIGN 具有双编码器架构，其中 EfficientNet 作为其视觉编码器，BERT 作为其文本编码器，并通过对比学习学习对齐视觉和文本表示。与以往的工作不同，ALIGN 利用了一个庞大的嘈杂数据集，并表明语料库的规模可以用来实现具有简单配方的 SOTA 表示。

论文的摘要如下：

预训练表示对许多 NLP 和感知任务变得至关重要。虽然 NLP 中的表示学习已经过渡到在没有人类注释的原始文本上进行训练，但视觉和视觉语言表示仍然严重依赖于昂贵或需要专业知识的策划训练数据集。对于视觉应用，表示主要是使用具有显式类标签的数据集学习，如 ImageNet 或 OpenImages。对于视觉语言，像 Conceptual Captions、MSCOCO 或 CLIP 这样的流行数据集都涉及到一个不容易的数据收集（和清理）过程。这种昂贵的策划过程限制了数据集的规模，从而阻碍了训练模型的扩展。在本文中，我们利用了一个超过十亿个图像替代文本对的嘈杂数据集，该数据集是在 Conceptual Captions 数据集中没有昂贵的过滤或后处理步骤的情况下获得的。一个简单的双编码器架构学习使用对比损失对图像和文本对的视觉和语言表示进行对齐。我们表明，我们语料库的规模可以弥补其噪声，并导致即使使用如此简单的学习方案也能实现最先进的表示。我们的视觉表示在转移到 ImageNet 和 VTAB 等分类任务时表现出色。对齐的视觉和语言表示使零样本图像分类成为可能，并在 Flickr30K 和 MSCOCO 图像文本检索基准上取得了新的最先进结果，即使与更复杂的交叉注意力模型相比也是如此。这些表示还使得可以进行具有复杂文本和文本+图像查询的跨模态搜索。

这个模型是由Alara Dirik贡献的。原始代码未发布，这个实现是基于 Kakao Brain 根据原始论文实现的。

用法示例

ALIGN 使用 EfficientNet 获取视觉特征，使用 BERT 获取文本特征。然后，文本和视觉特征都投影到具有相同维度的潜在空间中。然后使用投影图像和文本特征之间的点积作为相似度分数。

AlignProcessor 将 EfficientNetImageProcessor 和 BertTokenizer 封装成一个单一实例，用于对文本进行编码和预处理图像。以下示例展示了如何使用 AlignProcessor 和 AlignModel 获取图像文本相似度分数。

import requests
import torch
from PIL import Image
from transformers import AlignProcessor, AlignModel

processor = AlignProcessor.from_pretrained("kakaobrain/align-base")
model = AlignModel.from_pretrained("kakaobrain/align-base")

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
candidate_labels = ["an image of a cat", "an image of a dog"]

inputs = processor(text=candidate_labels, images=image, return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs)

# this is the image-text similarity score
logits_per_image = outputs.logits_per_image

# we can take the softmax to get the label probabilities
probs = logits_per_image.softmax(dim=1)
print(probs)

资源

一系列官方 Hugging Face 和社区（由🌎表示）资源，可帮助您开始使用 ALIGN。

• 有关 ALIGN 和 COYO-700M 数据集 的博客文章。

• 一个零样本图像分类 演示。

• kakaobrain/align-base 模型的 模型卡片。

如果您有兴趣提交资源以包含在此处，请随时打开一个拉取请求，我们将进行审查。资源应该展示一些新内容，而不是重复现有资源。

AlignConfig

class transformers.AlignConfig

< source >

( text_config = None vision_config = None projection_dim = 640 temperature_init_value = 1.0 initializer_range = 0.02 **kwargs )

参数

• text_config (dict, optional) — 用于初始化 AlignTextConfig 的配置选项字典。

• vision_config (dict, optional) — 用于初始化 AlignVisionConfig 的配置选项字典。

• projection_dim (int, optional, 默认为 640) — 文本和视觉投影层的维度。

• temperature_init_value (float, optional, 默认为 1.0) — temperature 参数的初始值。默认值与原始 ALIGN 实现相同。

• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• kwargs (optional) — 关键字参数字典。

AlignConfig 是用于存储 AlignModel 配置的配置类。它用于根据指定的参数实例化一个 ALIGN 模型，定义文本模型和视觉模型配置。使用默认值实例化配置将产生与 ALIGN kakaobrain/align-base 架构类似的配置。

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

示例：

>>> from transformers import AlignConfig, AlignModel

>>> # Initializing a AlignConfig with kakaobrain/align-base style configuration
>>> configuration = AlignConfig()

>>> # Initializing a AlignModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignModel(configuration)

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

>>> # We can also initialize a AlignConfig from a AlignTextConfig and a AlignVisionConfig
>>> from transformers import AlignTextConfig, AlignVisionConfig

>>> # Initializing ALIGN Text and Vision configurations
>>> config_text = AlignTextConfig()
>>> config_vision = AlignVisionConfig()

>>> config = AlignConfig.from_text_vision_configs(config_text, config_vision)

from_text_vision_configs

< source >

( text_config: AlignTextConfig vision_config: AlignVisionConfig **kwargs ) → export const metadata = 'undefined';AlignConfig

返回

AlignConfig

配置对象的一个实例

从对齐文本模型配置和对齐视觉模型配置实例化一个 AlignConfig（或派生类）。

AlignTextConfig

class transformers.AlignTextConfig

< source >

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' use_cache = True **kwargs )

参数

• vocab_size (int, optional, 默认为 30522) — Align 文本模型的词汇量。定义了在调用 AlignTextModel 时可以表示的不同标记数量。

• hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。

• num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。

• num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

• hidden_act (str或Callable, optional, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。

• max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如 512、1024 或 2048）。

• type_vocab_size (int, optional, 默认为 2) — 在调用 AlignTextModel 时传递的token_type_ids的词汇表大小。

• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。

• pad_token_id (int, optional, 默认为 0) — 填充标记 id。

• position_embedding_type (str, optional, 默认为"absolute") — 位置嵌入的类型。选择"absolute"、"relative_key"、"relative_key_query"中的一个。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参考Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"的更多信息，请参考[Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)]中的Method 4 (https://arxiv.org/abs/2009.13658)。

• use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。

这是用于存储 AlignTextModel 配置的配置类。根据指定的参数实例化一个 ALIGN 文本编码器，定义模型架构。使用默认值实例化配置将产生与 ALIGN kakaobrain/align-base架构的文本编码器类似的配置。这里的默认值是从 BERT 复制的。

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

示例：

>>> from transformers import AlignTextConfig, AlignTextModel

>>> # Initializing a AlignTextConfig with kakaobrain/align-base style configuration
>>> configuration = AlignTextConfig()

>>> # Initializing a AlignTextModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignTextModel(configuration)

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

AlignVisionConfig

class transformers.AlignVisionConfig

< source >

( num_channels: int = 3 image_size: int = 600 width_coefficient: float = 2.0 depth_coefficient: float = 3.1 depth_divisor: int = 8 kernel_sizes: List = [3, 3, 5, 3, 5, 5, 3] in_channels: List = [32, 16, 24, 40, 80, 112, 192] out_channels: List = [16, 24, 40, 80, 112, 192, 320] depthwise_padding: List = [] strides: List = [1, 2, 2, 2, 1, 2, 1] num_block_repeats: List = [1, 2, 2, 3, 3, 4, 1] expand_ratios: List = [1, 6, 6, 6, 6, 6, 6] squeeze_expansion_ratio: float = 0.25 hidden_act: str = 'swish' hidden_dim: int = 2560 pooling_type: str = 'mean' initializer_range: float = 0.02 batch_norm_eps: float = 0.001 batch_norm_momentum: float = 0.99 drop_connect_rate: float = 0.2 **kwargs )

参数

• num_channels (int, optional, 默认为 3) — 输入通道数。

• image_size (int, optional, 默认为 600) — 输入图像大小。

• width_coefficient (float, optional, 默认为 2.0) — 每个阶段网络宽度的缩放系数。

• depth_coefficient (float, optional, 默认为 3.1) — 每个阶段网络深度的缩放系数。

• depth_divisor int, optional, 默认为 8) — 网络宽度的单位。

• kernel_sizes (List[int], optional, 默认为[3, 3, 5, 3, 5, 5, 3]) — 每个块中要使用的卷积核大小列表。

• in_channels (List[int], optional, 默认为[32, 16, 24, 40, 80, 112, 192]) — 用于卷积层中每个块的输入通道大小列表。

• out_channels (List[int], 可选, 默认为[16, 24, 40, 80, 112, 192, 320]) — 用于卷积层中每个块中使用的输出通道大小列表。

• depthwise_padding (List[int], 可选, 默认为[]) — 具有方形填充的块索引列表。

• strides (List[int], 可选, 默认为[1, 2, 2, 2, 1, 2, 1]) — 用于卷积层中每个块中使用的步幅大小列表。

• num_block_repeats (List[int], 可选, 默认为[1, 2, 2, 3, 3, 4, 1]) — 每个块重复的次数列表。

• expand_ratios (List[int], 可选, 默认为[1, 6, 6, 6, 6, 6, 6]) — 每个块的缩放系数列表。

• squeeze_expansion_ratio (float, 可选, 默认为 0.25) — 挤压扩展比率。

• hidden_act (str或function, 可选, 默认为"silu") — 每个块中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu", "relu", "selu", "gelu_new", "silu"和"mish"。

• hiddem_dim (int, 可选, 默认为 1280) — 分类头之前层的隐藏维度。

• pooling_type (str或function, 可选, 默认为"mean") — 应用于密集分类头之前的最终池化类型。可用选项为["mean", "max"]

• initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• batch_norm_eps (float, 可选, 默认为 1e-3) — 批量归一化层使用的 epsilon。

• batch_norm_momentum (float, 可选, 默认为 0.99) — 批量归一化层使用的动量。

• drop_connect_rate (float, 可选, 默认为 0.2) — 跳过连接的丢弃率。

这是一个配置类，用于存储 AlignVisionModel 的配置。根据指定的参数实例化一个 ALIGN 视觉编码器，定义模型架构。使用默认值实例化配置将产生与 ALIGN kakaobrain/align-base架构的视觉编码器类似的配置。默认值来自 EfficientNet (efficientnet-b7)

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

示例：

>>> from transformers import AlignVisionConfig, AlignVisionModel

>>> # Initializing a AlignVisionConfig with kakaobrain/align-base style configuration
>>> configuration = AlignVisionConfig()

>>> # Initializing a AlignVisionModel (with random weights) from the kakaobrain/align-base style configuration
>>> model = AlignVisionModel(configuration)

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

AlignProcessor

class transformers.AlignProcessor

<来源>

( image_processor tokenizer )

参数

• image_processor (EfficientNetImageProcessor) — 图像处理器是必需的输入。

• tokenizer ([BertTokenizer, BertTokenizerFast]) — 分词器是必需的输入。

构建一个 ALIGN 处理器，将 EfficientNetImageProcessor 和 BertTokenizer/BertTokenizerFast 包装成一个同时继承图像处理器和分词器功能的单个处理器。查看__call__()和 decode()以获取更多信息。

batch_decode

<来源>

( *args **kwargs )

此方法将所有参数转发给 BertTokenizerFast 的 batch_decode()。请参考此方法的文档字符串获取更多信息。

decode

<来源>

( *args **kwargs )

此方法将所有参数转发给 BertTokenizerFast 的 decode()。请参考此方法的文档字符串获取更多信息。

AlignModel

class transformers.AlignModel

<来源>

( config: AlignConfig )

参数

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

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

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

forward

<来源>

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

  索引可以使用 AutoTokenizer 获得。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？ attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选): 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 1 对应于未被掩码的标记，

  • 0 对应于被掩码的标记。

  什么是注意力掩码？ position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选): 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

  什么是位置 ID？ token_type_ids (torch.LongTensor，形状为({0})，可选): 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]之间：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？ head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选): 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

  inputs_embeds (torch.FloatTensor of shape ({0}, hidden_size), optional): 可选地，您可以选择直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)): 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 EfficientNetImageProcessor.call()。return_loss (bool, optional): 是否返回对比损失。output_attentions (bool, optional): 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。output_hidden_states (bool, optional): 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。return_dict (bool, optional): 是否返回 ModelOutput 而不是普通元组。

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

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

get_text_features

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示未被屏蔽的标记，

  • 0 表示被屏蔽的标记。

  什么是注意力掩码？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

  什么是位置 ID？

• token_type_ids (torch.LongTensor of shape ({0}), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• inputs_embeds (torch.FloatTensor，形状为({0}, hidden_size)，可选) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

text_features (torch.FloatTensor，形状为(batch_size, output_dim)

通过将投影层应用于 AlignTextModel 的汇聚输出获得的文本嵌入。

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

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

示例：

>>> from transformers import AutoTokenizer, AlignModel

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)

get_image_features

<来源>

( pixel_values: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';image_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。如果提供，可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 EfficientNetImageProcessor.call()。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

image_features (torch.FloatTensor，形状为(batch_size, output_dim))

通过将投影层应用于 AlignVisionModel 的汇聚输出获得的图像嵌入。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AlignModel

>>> model = AlignModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> image_features = model.get_image_features(**inputs)

AlignTextModel

class transformers.AlignTextModel

<来源>

( config: AlignTextConfig add_pooling_layer: bool = True )

参数

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

来自 ALIGN 的文本模型，没有顶部的头部或投影。此模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，如果提供，将忽略填充。

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

  什么是输入 ID？

• attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• token_type_ids (torch.LongTensor，形状为({0})，可选) — 指示输入的第一部分和第二部分的段标记索引。索引选择在[0, 1]中：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• inputs_embeds (torch.FloatTensor，形状为({0}, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包括根据配置（<class 'transformers.models.align.configuration_align.AlignTextConfig'>）和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。

• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）- 经过用于辅助预训练任务的层进一步处理后，序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是从预训练期间的下一个句子预测（分类）目标中训练的。

• 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 之后的注意权重，用于计算自注意力头中的加权平均值。

• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True和config.add_cross_attention=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  解码器的交叉注意力层的注意权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回）- 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值以及可选地在交叉注意力块中使用config.is_encoder_decoder=True）可用（参见past_key_values输入）以加速顺序解码。

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

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

示例：

>>> from transformers import AutoTokenizer, AlignTextModel

>>> model = AlignTextModel.from_pretrained("kakaobrain/align-base")
>>> tokenizer = AutoTokenizer.from_pretrained("kakaobrain/align-base")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

AlignVisionModel

class transformers.AlignVisionModel

<来源>

( config: AlignVisionConfig )

参数

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

ALIGN 中的视觉模型，没有任何头部或顶部的投影。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( pixel_values: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)

参数

• pixel_values（torch.FloatTensor，形状为(batch_size, num_channels, height, width)）— 像素值。默认情况下将忽略填充，如果您提供填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 EfficientNetImageProcessor.call()。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

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

一个transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（<class 'transformers.models.align.configuration_align.AlignVisionConfig'>）和输入。

• last_hidden_state（torch.FloatTensor，形状为(batch_size, num_channels, height, width)）— 模型最后一层的隐藏状态序列。

• pooler_output（torch.FloatTensor，形状为(batch_size, hidden_size)）— 在空间维度上进行池化操作后的最后一层隐藏状态。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出的一个+每一层的输出的一个）。

  模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AlignVisionModel

>>> model = AlignVisionModel.from_pretrained("kakaobrain/align-base")
>>> processor = AutoProcessor.from_pretrained("kakaobrain/align-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states