Transformers 4.37 中文文档（八十）（transformer1）

原文：huggingface.co/docs/transformers

Wav2Vec2-BERT

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

概述

Wav2Vec2-BERT模型是Meta AI无缝通信团队在Seamless:多语言表达和流式语音翻译中提出的。

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

该模型的正式结果在本文第3.2.1 节中介绍。

论文摘要如下。

自动语音翻译的最新进展显着扩大了支持的语言范围，改进了多模式功能，并实现了多种任务和功能。尽管如此，当今的大规模自动语音翻译系统仍然缺乏一些有助于使机器介导的通信和人与人之间的对话更加流畅的关键功能。这项工作引入了一系列模型，可实现端到端表示丰富和流式多语言翻译。首先，我们提供大型多语言和多模式SeamlessM4T 模型——SeamlessM4T v2 的改进版本。此更新的模型使用更新的UnitY2 框架，并使用较低资源语言数据进行训练。 SeamlessAlign增强版增加了涵盖76种语言的114,800小时自动对齐数据。 SeamlessM4T v2 为两种现代模型提供了基础：SeamlessExpressive 和SeamlessStreaming。 SeamlessExpressive 可实现保留语音风格和韵律的翻译。与之前的表达性言语研究相比，我们的研究解决了韵律中未探索的方面，例如语速和停顿，同时保留了个人言语的风格。关于SeamlessStreaming，我们的模型利用高效单调多头保留（EMMA）机制来生成低延迟目标翻译，而无需等待完整的源话语。 SeamlessStreaming 首创实现多种源语言和目标语言之间的同步语音到语音/文本翻译。为了了解这些模型的性能，我们结合了现有自动化指标的新版本和修改版本来评估韵律、延迟和鲁棒性。对于人类评估，我们调整了现有的协议来衡量与保留意义、自然性和表现力最相关的特征。为了确保我们的模型能够安全、负责任地使用，我们开发了第一个已知的多模式机器翻译红队操作、一个检测和减轻添加剂毒性的系统，以及一个检测和减轻性别偏见的系统。专为评估和缓解而设计的水印机制。深度造假的影响。因此，我们将SeamlessExpressive 和SeamlessStreaming 的关键组件结合起来，形成了Seamless，这是第一个可实现实时表达性跨语言交流的公开系统。总之，Seamless 为将通用语音翻译器从科幻小说概念转变为现实世界技术所需的技术基础提供了批判性的视角。最后，对这项工作—— 的贡献，包括模型、代码和水印检测器——，都是公开可用的，并且可以通过下面的链接访问。

该模型由ylacombe 提供。原始代码在这里。

使用提示

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

通过设置正确的config.position_embeddings_type，Wav2Vec2-BERT 可以使用非相对位置嵌入、类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 drop=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、掩码特征长度=10、mask_feature_min_masks=0 ctc_loss_reduction=\’sum\’ ctc_zero_infinity=False use_weighted_layer_sum=False=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=Falseadapter_kernel_size=3adapter_stride=2 num_adapter_layers=1adapter_act=\’relu\’ use_intermediate_ffn_before_adapter=False Output_hidden_size=无Position_embeddings_type=\’relative_key\’rotary_embeddings _base=10000 max_source_positions=5000 left_max_position_embeddings=64 right_max_position_embeddings=8 conv_Depthwise_kernel_size=31=0.1 **kwargs)

参数

vocab_size (int, 可选) Wav2Vec2Bert 模型的词汇大小。定义调用Wav2Vec2BertModel 时可以表示的不同标记的数量。模型词汇。定义可以由传递给Wav2Vec2BertModel 的inputs_id 表示的各种标记。

hidden_size (int, 可选，默认1024) — 编码器层和拉取器层的大小。

num_hidden_layers (int, 可选，默认24) Transformer 编码器中隐藏层的数量。

num_attention_heads (int, 可选，默认16) — Transformer 编码器的每个注意力层中的注意力头数量。

middle_size (int, 可选，默认4096) Transformer 编码器的“中间”（即前馈）层的大小。

feature_projection_input_dim (int, 可选，默认160) 该模型的输入维度，即使用SeamlessM4TFeatureExtractor 或Wav2Vec2BertProcessor 处理输入音频后的维度。

hidden_act（str 或函数，可选，默认为\’swish\’） – 编码器和拉取器的非线性激活函数（函数或字符串）。对于字符串，支持“gelu”、“relu”、“selu”、“swish”、“gelu_new”。

hidden_dropout (float, 可选，默认0.0) — 嵌入层、编码器和池化器中所有全连接层的Dropout 概率。

Activity_dropout (float, 可选，默认0.0) — 全连接层中激活的Dropout 率。

Attention_dropout (float, 可选，默认0.0) — 注意力概率丢失率。

feat_proj_dropout (float, 可选，默认0.0) — 特征投影丢失概率。

Final_dropout（浮点数，可选，默认为0.1） — Wav2Vec2BertForCTC 最终投影层丢失概率。

layerdrop (float, 可选，默认0.1) — LayerDrop 概率。（有关更多信息，请参阅LayerDrop 文档）。

Initializer_range (float, 可选，默认为0.02) — 用于初始化所有权重矩阵的截断规范初始化器的标准偏差。

layer_norm_eps (float, 可选，默认1e-05) — 层归一化层使用的Epsilon 值。

apply_spec_augment (布尔值，可选，默认为True) — 是否将SpecAugment 数据增强应用于特征编码器输出。有关更多信息，请参阅SpecAugment: 用于自动语音识别的简单数据增强方法。

Mask_time_prob (float, 可选，默认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, 可选，默认10) — 沿时间轴的向量跨度的长度。

Mask_time_min_masks (int，可选，默认为2) — 沿着时间线的每个时间步生成的长度为mask_feature_length 的掩码的最小数量，无论mask_feature_prob 是多少。仅适用于mask_time_prob*len(time_axis)/mask_time_length、mask_time_min_masks。

Mask_feature_prob (float, 可选，默认0.0) — 沿特征轴被屏蔽的所有特征向量的比例（0 到1 之间）。掩码过程在轴上生成一个与Mask_feature_prob*len(feature_axis)/mask_time_length 无关的掩码。如果概率推理从向量范围开始，其中每个特征向量被选为掩码，则mask_feature_prob 必须为prob_vector_start*mask_feature_length。请注意，重叠可以减少实际屏蔽向量的比例。仅当apply_spec_augment 为True 时才相关。

Mask_feature_length (int, 可选，默认10) — 沿特征轴的向量跨度的长度。

Mask_feature_min_masks (int，可选，默认为0) — 每个时间步沿特征轴生成的长度为Mask_feature_length 的掩码的最小数量，与mask_feature_prob 无关。仅适用于mask_feature_prob*len(feature_axis)/mask_feature_length、mask_feature_min_masks。

ctc_loss_reduction (str, 可选，默认为\’sum\’) — 指定应用于torch.nn.CTCLoss 输出的减少量。仅在训练Wav2Vec2BertForCTC 实例时相关。

ctc_zero_infinity (boolean, 可选，默认为False) — 是否将torch.nn.CTCLoss 的无限损失和相关梯度归零。无限损失主要发生在输入太短而无法匹配目标时。仅在训练Wav2Vec2BertForCTC 实例时相关。

use_weighted_layer_sum (bool, 可选，默认为False) — 是否使用学习权重的层输出的加权平均值。仅在使用Wav2Vec2BertForSequenceClassification 实例时相关。

classifier_proj_size (int, 可选，默认768) — 预令牌投影的维度表示分类池。

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

tdnn_kernel（Tuple[int] 或List[int]，可选，默认为(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 嵌入向量的维度。

Pad_token_id（int，可选，默认为0）— 开始流式传输的令牌的ID。

bos_token_id（int，可选，默认为1）— 设置令牌的ID。

eos_token_id（int，可选，默认为2）— 流结束令牌的ID。

add_adapter (bool, 可选，默认为False) — 是否将卷积注意力网络堆叠在Wav2Vec2Bert 编码器之上。对于SpeechEncoderDecoder 模型中的热启动Wav2Vec2Bert 很有用。

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

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

num_adapter_layers (int，可选，默认为1) — 适配器网络中应使用的卷积层数。仅当add_adapter 为True 时才相关。

adapter_act (str 或function，可选，默认为\’relu\’) — 适配器层的非线性激活函数（函数或字符串）。对于字符串，支持“gelu”、“relu”、“selu”、“swish”、“gelu_new”。

use_intermediate_ffn_before_adapter （布尔值，可选，默认为False） — 是否在Wav2Vec2Bert 编码器上方和适配器网络之前堆叠中间前馈块。仅当add_adapter 为True 时才相关。

Output_hidden_size (int, 可选) — 编码器输出层的大小。如果未定义，则默认为隐藏大小。仅当add_adapter 为True 时才相关。

Position_embeddings_type (str，可选，默认为“relative_key”) — 可以指定为：

用于旋转和嵌入旋转位置。

relative，用于相对位置填充。

relative_key：用于由Shaw 在“相对位置表示的自注意力”（Shaw 等人）中定义的相对位置嵌入。如果保留为None，则不会应用相对位置填充。

rotary_embedding_base (int, 可选，默认10000) — 定义使用“旋转”位置嵌入时嵌入基数的大小。

max_source_positions (int，可选，默认5000) — 定义使用“相对”位置填充时的最大源输入位置。

left_max_position_embeddings （int，可选，默认为64） — “relative_key”（又名Shaw）定义使用位置嵌入时相对位置的左侧裁剪值。

right_max_position_embeddings (int，可选，默认为8) —“relative_key”（又名Shaw）定义使用位置嵌入时相对位置的正确裁剪值。

conv_ Depthwise_kernel_size (int, 可选，默认31) — Conformer 块中深度可分离1D 卷积层的内核大小。

conformer_conv_dropout (float, 可选，默认0.1) — Conformer 块中所有卷积层的Dropout 概率。

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

配置对象继承自PretrainedConfig，可用于控制模型输出。有关更多信息，请参阅PretrainedConfig 文档。

例子：

从变压器导入Wav2Vec2BertConfig 和Wav2Vec2BertModel

# Wav2Vec2Bert facebook/wav2vec2-bert-rel-pos-large 初始化样式设置

配置=Wav2Vec2BertConfig()

# facebook/wav2vec2-bert-rel-pos-large 从样式设置初始化模型（具有随机权重）

模型=Wav2Vec2BertModel(配置)

# 访问模型设置

配置=模型.config

Wav2Vec2BertProcessor

class transformers.Wav2Vec2BertProcessor

酱

（feature_extractor 分词器）

参数

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

tokenizer (PreTrainedTokenizer) — PreTrainedTokenizer 的实例。分词器是必需的输入。

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

Wav2Vec2Processor 提供SeamlessM4TFeatureExtractor 和PreTrainedTokenizer 的所有功能。有关更多信息，请参阅call() 和decode() 文档字符串。

call

酱

( 音频=无文本=无**kwargs ) const 元数据=\’未知\’;

参数

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 (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 (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_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, 默认为 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, 默认为 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（形状为(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（形状为(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 (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 (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 (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（形状为(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 (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