Transformers 4.37 中文文档（七十九）

原文：huggingface.co/docs/transformers

UniSpeech-SAT

查看原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/unispeech-sat

概述

UniSpeech-SAT 模型是由 Sanyuan Chen、Yu Wu、Chengyi Wang、Zhengyang Chen、Zhuo Chen、Shujie Liu、Jian Wu、Yao Qian、Furu Wei、Jinyu Li、Xiangzhan Yu 在UniSpeech-SAT: Universal Speech Representation Learning with Speaker Aware Pre-Training中提出的。

论文摘要如下：

自监督学习（SSL）是语音处理的一个长期目标，因为它利用大规模未标记数据，避免了大量的人工标注。近年来，在语音识别中应用自监督学习取得了巨大成功，但在建模说话者特征方面的尝试有限。在本文中，我们旨在改进现有的 SSL 框架，用于说话者表示学习。我们介绍了两种方法来增强无监督说话者信息提取。首先，我们将多任务学习应用于当前的 SSL 框架，将话语级对比损失与 SSL 目标函数整合在一起。其次，为了更好地区分说话者，我们提出了一种话语混合策略用于数据增强，其中额外的重叠话语是无监督创建的，并在训练过程中整合。我们将这些方法整合到 HuBERT 框架中。在 SUPERB 基准上的实验结果表明，所提出的系统在通用表示学习方面取得了最先进的性能，特别是针对说话者识别导向的任务。进行了消融研究，验证了每种提出方法的有效性。最后，我们将训练数据集扩大到 94,000 小时的公共音频数据，并在所有 SUPERB 任务中实现了进一步的性能提升。

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

使用提示

• UniSpeechSat 是一个语音模型，接受与语音信号的原始波形对应的浮点数组。请使用 Wav2Vec2Processor 进行特征提取。
• UniSpeechSat 模型可以使用连接主义时间分类（CTC）进行微调，因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。
• UniSpeechSat 在说话者验证、说话者识别和说话者日程任务中表现特别好。

资源

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

UniSpeechSatConfig

class transformers.UniSpeechSatConfig

<来源>

( 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 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 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 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 = '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 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 num_clusters = 504 **kwargs )

参数

• vocab_size（int，可选，默认为 32）— UniSpeechSat 模型的词汇大小。定义了在调用 UniSpeechSatModel 时可以表示的不同令牌的数量。模型的词汇大小。定义了可以由传递给 UniSpeechSatModel 的inputs_ids表示的不同令牌。
• hidden_size（int，可选，默认为 768）— 编码器层和池化层的维度。
• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数。
• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
• hidden_dropout (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有完全连接层的 dropout 概率。
• activation_dropout (float, optional, defaults to 0.1) — 完全连接层内激活的 dropout 比率。
• attention_dropout (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
• feat_proj_dropout (float, optional, defaults to 0.0) — 特征编码器输出的 dropout 概率。
• feat_quantizer_dropout (float, optional, defaults to 0.0) — 用于量化器使用的特征编码器输出的 dropout 概率。
• final_dropout (float, optional, defaults to 0.1) — UniSpeechSatForCTC 的最终投影层的 dropout 概率。
• layerdrop (float, optional, defaults to 0.1) — LayerDrop 概率。更多详情请参阅 LayerDrop 论文)。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
• layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。
• feat_extract_norm (str, optional, defaults to "group") — 应用于特征编码器中的 1D 卷积层的规范化方式。可以选择"group"表示仅对第一个 1D 卷积层进行组归一化，或者选择"layer"表示对所有 1D 卷积层进行层归一化。
• 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, 2, 2)) — 定义特征编码器中每个 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 编码器的稳定层归一化架构。do_stable_layer_norm is True表示在注意力层之前应用层归一化，而do_stable_layer_norm is False表示在注意力层之后应用层归一化。
• apply_spec_augment (bool, optional, 默认为True) — 是否对特征编码器的输出应用SpecAugment数据增强。有关详细信息，请参阅SpecAugment：用于自动语音识别的简单数据增强方法。
• mask_time_prob (float, optional, 默认为 0.05) — 沿时间轴遮蔽的所有特征向量的百分比（介于 0 和 1 之间）。遮蔽过程在该轴上生成“mask_time_prob*len(time_axis)/mask_time_length”个独立的遮罩。如果从每个特征向量被选择为要遮蔽的向量跨度的起点的概率推理，mask_time_prob应为prob_vector_start*mask_time_length。请注意，重叠可能会降低实际遮蔽向量的百分比。仅在apply_spec_augment为 True 时相关。
• mask_time_length (int, optional, 默认为 10) — 沿时间轴的向量跨度长度。
• mask_time_min_masks (int, optional, 默认为 2) — 沿时间轴生成的长度为mask_feature_length的最小遮罩数量，每个时间步，与mask_feature_prob无关。仅在“mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”时相关。
• mask_feature_prob (float, optional, 默认为 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。
• 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, 默认为"mean") — 指定应用于torch.nn.CTCLoss输出的减少方式。仅在训练 UniSpeechSatForCTC 实例时相关。
• ctc_zero_infinity (bool, optional, 默认为False) — 是否将torch.nn.CTCLoss的无限损失和相关梯度置零。当输入太短无法与目标对齐时，主要会出现无限损失。仅在训练 UniSpeechSatForCTC 实例时相关。
• use_weighted_layer_sum (bool，可选，默认为False）— 是否使用带有学习权重的层输出的加权平均值。仅在使用 UniSpeechSatForSequenceClassification 的实例时相关。
• classifier_proj_size (int，可选，默认为 256）— 分类前的投影维度均值池化。
• 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。
• num_clusters (int，可选，默认为 504）— 弱标记的簇数。仅在使用 UniSpeechSatForPreTraining 的实例时相关。

这是用于存储 UniSpeechSatModel 配置的配置类。根据指定的参数实例化 UniSpeechSat 模型，定义模型架构。使用默认值实例化配置将产生类似于 UniSpeechSat microsoft/unispeech-sat-base-100h-libri-ft架构的配置。

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

示例：

>>> from transformers import UniSpeechSatModel, UniSpeechSatConfig

>>> # Initializing a UniSpeechSat microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> configuration = UniSpeechSatConfig()

>>> # Initializing a model from the microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> model = UniSpeechSatModel(configuration)

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

UniSpeechSat 特定输出

class transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput

<来源>

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

参数

• loss（可选，当模型处于训练模式时返回，形状为(1,)的torch.FloatTensor）— 总损失，作为对比损失（L_m）和多样性损失（L_d）的和，如官方论文中所述。 （分类）损失。
• projected_states (torch.FloatTensor，形状为(batch_size, sequence_length, config.proj_codevector_dim)）— 模型的隐藏状态投影到config.proj_codevector_dim，可用于预测掩码的投影量化状态。
• projected_quantized_states (torch.FloatTensor，形状为(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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

UniSpeechSatModel

class transformers.UniSpeechSatModel

<来源>

( config: UniSpeechSatConfig )

参数

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

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

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

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

forward

<来源>

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

参数

• input_values（形状为(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的模型，例如microsoft/unispeech-sat-base-100h-libri-ft，在进行批量推断时应不传递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时）包含各种元素，这取决于配置（UniSpeechSatConfig）和输入。

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

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

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

示例：

>>> from transformers import AutoProcessor, UniSpeechSatModel
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatModel.from_pretrained("microsoft/unispeech-sat-base-100h-libri-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, 768]

UniSpeechSatForCTC

class transformers.UniSpeechSatForCTC

<来源>

( config target_lang: Optional = None )

参数

• config (UniSpeechSatConfig) — 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，只会加载配置。 请查看 from_pretrained() 方法以加载模型权重。
• target_lang (str, optional) — 适配器权重的语言 id。 适配器权重存储在格式为 adapter..safetensors 或 adapter..bin 的文件中。 仅在使用带有适配器的 UniSpeechSatForCTC 实例时相关。 默认情况下使用 ‘eng’。

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

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

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

forward

< source >

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

参数

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

  什么是注意力掩码？ 只有在相应的处理器具有 config.return_attention_mask == True 时才应传递 attention_mask。 对于所有处理器具有 config.return_attention_mask == False 的模型，例如 microsoft/unispeech-sat-base-100h-libri-ft，在进行批量推断时应 不 传递 attention_mask 以避免性能下降。 对于这些模型，input_values 应简单地填充为 0 并在不传递 attention_mask 的情况下传递。 请注意，这些模型的结果也会因 input_values 是否填充而略有不同。

• 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 或torch.FloatTensor元组

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

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

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

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

示例：

>>> from transformers import AutoProcessor, UniSpeechSatForCTC
>>> 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("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForCTC.from_pretrained("microsoft/unispeech-sat-base-100h-libri-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 QUILDER 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)
39.88

UniSpeechSatForSequenceClassification

class transformers.UniSpeechSatForSequenceClassification

< source >

( config )

参数

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

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

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

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

这个模型是 PyTorch torch.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.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

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

  什么是注意力掩码？ 只有当相应的处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如microsoft/unispeech-sat-base-100h-libri-ft，在进行批量推断时，应不传递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时），包含根据配置(UniSpeechSatConfig)和输入而异的各种元素。

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

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

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

示例：

>>> from transformers import AutoFeatureExtractor, UniSpeechSatForSequenceClassification
>>> 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/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-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

UniSpeechSatForAudioFrameClassification

class transformers.UniSpeechSatForAudioFrameClassification

<来源>

( config )

参数

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

UniSpeech-SAT 模型顶部带有用于说话人分离等任务的帧分类头。

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

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

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

forward

<来源>

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

参数

• input_values（形状为(batch_size, sequence_length)的torch.FloatTensor） - 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得。通过 AutoProcessor 将数组准备为input_values，并将其转换为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的模型，例如microsoft/unispeech-sat-base-100h-libri-ft，在进行批量推断时，应不传递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.TokenClassifierOutput 或tuple(torch.FloatTensor)

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

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

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

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

示例：

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

UniSpeechSatForXVector

class transformers.UniSpeechSatForXVector

<来源>

( config )

参数

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

UniSpeech-SAT 模型在顶部使用 XVector 特征提取头，用于说话者验证等任务。

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

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

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

forward

<来源>

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

参数

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

  什么是注意力掩码？ 只有当相应的处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如microsoft/unispeech-sat-base-100h-libri-ft，在进行批量推断时应不传递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）包含各种元素，具体取决于配置（UniSpeechSatConfig）和输入。

• 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时返回) — 形状为(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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

UniSpeechSatForPreTraining

class transformers.UniSpeechSatForPreTraining

< source >

( config: UniSpeechSatConfig )

参数

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

UniSpeechSat 模型具有量化器和顶部的VQ头。UniSpeechSat 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在《wav2vec 2.0:自监督学习语音表示的框架》中提出的。

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

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

forward

< source >

( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput or tuple(torch.FloatTensor)

参数

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

  什么是注意力掩码？ 只有当相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如 microsoft/unispeech-sat-base-100h-libri-ft，在进行批量推断时，应避免传递attention_mask以避免性能下降。对于这些模型，input_values 应该简单地用 0 填充并在不传递attention_mask的情况下传递。请注意，这些模型根据input_values是否填充会产生略有不同的结果。

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

返回

transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput 或 tuple(torch.FloatTensor)

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

• loss (optional，在模型处于训练模式时返回，形状为(1,)的torch.FloatTensor) — 总损失，作为对比损失（L_m）和多样性损失（L_d）的总和，如官方论文中所述。 （分类）损失。
• projected_states (torch.FloatTensor，形状为(batch_size, sequence_length, config.proj_codevector_dim)) — 模型的隐藏状态投影到 config.proj_codevector_dim，可用于预测掩码投影量化状态。
• projected_quantized_states (torch.FloatTensor，形状为(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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import torch
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForPreTraining
>>> from transformers.models.unispeech_sat.modeling_unispeech_sat import _compute_mask_indices

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base")
>>> model = UniSpeechSatForPreTraining.from_pretrained("microsoft/unispeech-sat-base")
>>> # TODO: Add full pretraining example

UnivNet

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

概述

UnivNet 模型是由 Won Jang、Dan Lim、Jaesam Yoon、Bongwan Kin 和 Juntae Kim 在UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation中提出的。UnivNet 模型是一个生成对抗网络（GAN），用于合成高保真度语音波形。在transformers中共享的 UnivNet 模型是生成器，它将一个条件化的对数梅尔频谱图和可选的噪声序列映射到语音波形（例如声码器）。推理只需要生成器。用于训练生成器的鉴别器没有实现。

论文摘要如下：

大多数神经声码器使用带限制的梅尔频谱图来生成波形。如果将全频段谱特征用作输入，则声码器可以提供尽可能多的声学信息。然而，在一些使用全频段梅尔频谱图的模型中，会出现过度平滑的问题，其中生成了非锐利的频谱图。为了解决这个问题，我们提出了 UnivNet，一个能够实时合成高保真波形的神经声码器。受到语音活动检测领域的研究启发，我们添加了一个多分辨率谱图鉴别器，该鉴别器使用了使用不同参数集计算的多个线性谱图幅度。通过使用全频段梅尔频谱图作为输入，我们希望通过添加一个使用多个分辨率谱图作为输入的鉴别器来生成高分辨率信号。在包含数百位说话者信息的数据集上进行评估时，UnivNet 在看到和未看到的说话者方面获得了最佳客观和主观结果。这些结果，包括文本转语音的最佳主观评分，展示了快速适应新说话者的潜力，而无需从头开始训练。

提示：

• UnivNetModel.forward()的noise_sequence参数应为标准的高斯噪声（例如来自torch.randn），形状为([batch_size], noise_length, model.config.model_in_channels)，其中noise_length应与input_features参数的长度维度（维度 1）匹配。如果未提供，将随机生成；可以向generator参数提供torch.Generator，以便可以重现前向传递。（请注意，UnivNetFeatureExtractor 默认会返回生成的噪声，因此通常不需要手动生成noise_sequence。）
• 通过UnivNetFeatureExtractor.batch_decode()方法可以从 UnivNetModel 输出中移除 UnivNetFeatureExtractor 添加的填充，如下面的用法示例所示。
• 在每个波形的末尾填充静音可以减少生成音频样本末尾的伪影。可以通过在 UnivNetFeatureExtractor.call()中提供pad_end = True来实现。更多细节请参见此问题。

用法示例：

import torch
from scipy.io.wavfile import write
from datasets import Audio, load_dataset

from transformers import UnivNetFeatureExtractor, UnivNetModel

model_id_or_path = "dg845/univnet-dev"
model = UnivNetModel.from_pretrained(model_id_or_path)
feature_extractor = UnivNetFeatureExtractor.from_pretrained(model_id_or_path)

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
# Resample the audio to the model and feature extractor's sampling rate.
ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
# Pad the end of the converted waveforms to reduce artifacts at the end of the output audio samples.
inputs = feature_extractor(
    ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], pad_end=True, return_tensors="pt"
)

with torch.no_grad():
    audio = model(**inputs)

# Remove the extra padding at the end of the output.
audio = feature_extractor.batch_decode(**audio)[0]
# Convert to wav file
write("sample_audio.wav", feature_extractor.sampling_rate, audio)

该模型由dg845贡献。据我所知，没有官方代码发布，但可以在maum-ai/univnet找到非官方实现，预训练检查点在这里。

UnivNetConfig

class transformers.UnivNetConfig

<来源>

( model_in_channels = 64 model_hidden_channels = 32 num_mel_bins = 100 resblock_kernel_sizes = [3, 3, 3] resblock_stride_sizes = [8, 8, 4] resblock_dilation_sizes = [[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]] kernel_predictor_num_blocks = 3 kernel_predictor_hidden_channels = 64 kernel_predictor_conv_size = 3 kernel_predictor_dropout = 0.0 initializer_range = 0.01 leaky_relu_slope = 0.2 **kwargs )

参数

• model_in_channels（int，可选，默认为 64）- UnivNet 残差网络的输入通道数。这应该对应于noise_sequence.shape[1]和 UnivNetFeatureExtractor 类中使用的值。
• model_hidden_channels（int，可选，默认为 32）- UnivNet 残差网络中每个残差块的隐藏通道数。
• num_mel_bins（int，可选，默认为 100）- 条件对数梅尔频谱图中的频率箱数。这应该对应于 UnivNetFeatureExtractor 类中使用的值。
• resblock_kernel_sizes（Tuple[int]或List[int]，可选，默认为[3, 3, 3]）- 一个整数元组，定义了 UnivNet 残差网络中 1D 卷积层的内核大小。resblock_kernel_sizes的长度定义了 resnet 块的数量，并应与resblock_stride_sizes和resblock_dilation_sizes相匹配。
• resblock_stride_sizes（Tuple[int]或List[int]，可选，默认为[8, 8, 4]）- 一个整数元组，定义了 UnivNet 残差网络中 1D 卷积层的步幅大小。resblock_stride_sizes的长度应与resblock_kernel_sizes和resblock_dilation_sizes相匹配。
• resblock_dilation_sizes（Tuple[Tuple[int]]或List[List[int]]，可选，默认为[[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]）- 一个嵌套的整数元组，定义了 UnivNet 残差网络中扩张的 1D 卷积层的扩张率。resblock_dilation_sizes的长度应与resblock_kernel_sizes和resblock_stride_sizes相匹配。resblock_dilation_sizes中每个嵌套列表的长度定义了每个 resnet 块中的卷积层数量。
• kernel_predictor_num_blocks（int，可选，默认为 3）- 核预测网络中的残差块数量，用于计算 UnivNet 残差网络中每个位置变量卷积层的内核和偏置。
• kernel_predictor_hidden_channels（int，可选，默认为 64）- 核预测网络中每个残差块的隐藏通道数。
• kernel_predictor_conv_size（int，可选，默认为 3）- 核预测网络中每个 1D 卷积层的内核大小。
• kernel_predictor_dropout（float，可选，默认为 0.0）- 核预测网络中每个残差块的丢失概率。
• initializer_range（float，可选，默认为 0.01）- 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• leaky_relu_slope（float，可选，默认为 0.2）- leaky ReLU 激活函数使用的负斜率的角度。

这是一个配置类，用于存储 UnivNetModel 的配置。根据指定的参数实例化一个 UnivNet 声码器模型，定义模型架构。使用默认值实例化配置将产生类似于 UnivNet dg845/univnet-dev架构的配置，该架构对应于maum-ai/univnet中的‘c32’架构。

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

示例：

>>> from transformers import UnivNetModel, UnivNetConfig

>>> # Initializing a Tortoise TTS style configuration
>>> configuration = UnivNetConfig()

>>> # Initializing a model (with random weights) from the Tortoise TTS style configuration
>>> model = UnivNetModel(configuration)

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

UnivNetFeatureExtractor

class transformers.UnivNetFeatureExtractor

< source >

( feature_size: int = 1 sampling_rate: int = 24000 padding_value: float = 0.0 do_normalize: bool = False num_mel_bins: int = 100 hop_length: int = 256 win_length: int = 1024 win_function: str = 'hann_window' filter_length: Optional = 1024 max_length_s: int = 10 fmin: float = 0.0 fmax: Optional = None mel_floor: float = 1e-09 center: bool = False compression_factor: float = 1.0 compression_clip_val: float = 1e-05 normalize_min: float = -11.512925148010254 normalize_max: float = 2.3143386840820312 model_in_channels: int = 64 pad_end_length: int = 10 return_attention_mask = True **kwargs )

参数

• feature_size (int, optional, 默认为 1) — 提取特征的特征维度。
• sampling_rate (int, optional, 默认为 24000) — 音频文件应该以赫兹（Hz）表示的数字化采样率。
• padding_value (float, optional, 默认为 0.0) — 在应用由 padding 参数定义的填充策略时要填充的值，应与音频静音对应。__call__ 中的 pad_end 参数也将使用此填充值。
• do_normalize (bool, optional, 默认为 False) — 是否对输入执行 Tacotron 2 标准化。标准化可以帮助一些模型显著提高性能。
• num_mel_bins (int, optional, 默认为 100) — 提取的频谱图特征中的梅尔频率箱数。这应该与 UnivNetModel.config.num_mel_bins 匹配。
• hop_length (int, optional, 默认为 256) — 滑动窗口之间的直接样本数。在许多论文中也称为“shift”。请注意，这与其他音频特征提取器（如 SpeechT5FeatureExtractor — 每个滑动窗口的直接样本数。请注意，这与其他音频特征提取器（如 SpeechT5FeatureExtractor — 用于窗口化的窗口函数的名称，必须通过 torch.{win_function} 访问。
• filter_length (int, optional, 默认为 1024) — 要使用的 FFT 组件数。如果为 None，则使用 transformers.audio_utils.optimal_fft_length 来确定。
• max_length_s (int, optional, 默认为 10) — 模型的最大输入长度，以秒为单位。这用于填充音频。
• fmin (float, optional, 默认为 0.0) — 最小的梅尔频率，以赫兹为单位。
• fmax (float, optional) — 最大的梅尔频率，以赫兹为单位。如果未设置，默认为 sampling_rate / 2。
• mel_floor (float, optional, 默认为 1e-09) — 梅尔频率银行的最小值。请注意，UnivNetFeatureExtractor 使用 mel_floor 的方式与 transformers.audio_utils.spectrogram() 中的方式不同。
• center (bool, optional, 默认为 False) — 是否填充波形，使帧 t 围绕时间 t * hop_length 居中。如果为 False，帧 t 将从时间 t * hop_length 开始。
• compression_factor (float, optional, 默认为 1.0) — 动态范围压缩期间的乘法压缩因子。
• compression_clip_val (float, optional, 默认为 1e-05) — 在应用动态范围压缩期间应用于波形的剪切值。
• normalize_min (float, 可选, 默认为-11.512925148010254) — 用于 Tacotron 2 风格线性归一化的最小值。默认值是 Tacotron 2 实现的原始值。
• normalize_max (float, 可选, 默认为 2.3143386840820312) — 用于 Tacotron 2 风格线性归一化的最大值。默认值是 Tacotron 2 实现的原始值。
• model_in_channels (int, 可选, 默认为 64) — UnivNetModel 模型的输入通道数。这应该与UnivNetModel.config.model_in_channels匹配。
• pad_end_length (int, 可选, 默认为 10) — 如果在每个波形的末尾填充，要附加的样本的频谱图帧数。附加的样本数将为pad_end_length * hop_length。
• return_attention_mask (bool, 可选, 默认为True) — call()是否应返回attention_mask。

构建一个 UnivNet 特征提取器。

该类使用短时傅里叶变换（STFT）从原始语音中提取对数梅尔滤波器组特征。STFT 实现遵循 TacoTron 2 和 Hifi-GAN 的实现。

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

__call__

< source >

( raw_speech: Union sampling_rate: Optional = None padding: Union = True max_length: Optional = None truncation: bool = True pad_to_multiple_of: Optional = None return_noise: bool = True generator: Optional = None pad_end: bool = False pad_length: Optional = None do_normalize: Optional = None return_attention_mask: Optional = None return_tensors: Union = None )

参数

• raw_speech (np.ndarray, List[float], List[np.ndarray], List[List[float]]) — 要填充的序列或批次序列。每个序列可以是一个 numpy 数组，一个浮点值列表，一个 numpy 数组列表或一个浮点值列表的列表。必须是单声道音频，不是立体声，即每个时间步长一个浮点数。
• sampling_rate (int, 可选) — 输入raw_speech采样的采样率。强烈建议在前向调用时传递sampling_rate，以防止静默错误并允许自动语音识别流水线。
• padding (bool, str或 PaddingStrategy, 可选, 默认为True) — 选择一种策略来填充输入raw_speech波形（根据模型的填充方向和填充索引）：
  • True 或 'longest'：填充到批次中最长的序列（如果只提供一个序列，则不填充）。
  • 'max_length'：填充到指定的最大长度，该长度由参数max_length指定，或者如果未提供该参数，则填充到模型的最大可接受输入长度。
  • False 或 'do_not_pad'（默认）：不填充（即，可以输出具有不同长度序列的批次）。

  如果pad_end = True，则填充将在应用padding策略之前发生。

• max_length (int, 可选) — 返回列表的最大长度和可选填充长度（见上文）。
• truncation (bool, 可选, 默认为True) — 激活截断，将长于max_length的输入序列截断为max_length。
• pad_to_multiple_of (int, 可选) — 如果设置，将序列填充到提供的值的倍数。 这对于在 NVIDIA 硬件上启用 Tensor Cores 特别有用，其计算能力为>= 7.5（Volta），或者对于受益于序列长度为 128 的倍数的 TPU。
• return_noise (bool, 可选, 默认为True) — 是否生成并返回用于 UnivNetModel.forward()的噪声波形。
• generator (numpy.random.Generator, 可选, 默认为 None) — 生成噪音时要使用的可选 numpy.random.Generator 随机数生成器。
• pad_end (bool, 可选, 默认为 False) — 是否在每个波形的末尾填充静音。这可以帮助减少生成音频样本末尾的伪影。有关更多详细信息，请参阅 github.com/seungwonpark/melgan/issues/8。此填充将在执行 padding 中指定的填充策略之前完成。
• pad_length (int, 可选, 默认为 None) — 如果在每个波形的末尾填充，填充在频谱图帧中的长度。如果未设置，将默认为 self.config.pad_end_length。
• do_normalize (bool, 可选) — 是否对输入执行 Tacotron 2 标准化。标准化可以帮助显著提高某些模型的性能。如果未设置，将默认为 self.config.do_normalize。
• return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果保持默认设置，将根据特定的 feature_extractor 默认返回注意力掩码。 什么是注意力掩码？
• return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
  • 'tf': 返回 TensorFlow tf.constant 对象。
  • 'pt': 返回 PyTorch torch.np.array 对象。
  • 'np': 返回 Numpy np.ndarray 对象。

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

UnivNetModel

class transformers.UnivNetModel

<来源>

( config: UnivNetConfig )

参数

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

UnivNet GAN 语音合成器。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_features: FloatTensor noise_sequence: Optional = None padding_mask: Optional = None generator: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.univnet.modeling_univnet.UnivNetModelOutput or tuple(torch.FloatTensor)

参数

• input_features (torch.FloatTensor) — 包含对数梅尔频谱图的张量。可以是批处理的，形状为 (batch_size, sequence_length, config.num_mel_channels)，也可以是非批处理的，形状为 (sequence_length, config.num_mel_channels)。
• noise_sequence (torch.FloatTensor, 可选) — 包含标准高斯噪音的噪音序列的张量。可以是批处理的，形状为 (batch_size, sequence_length, config.model_in_channels)，或者非批处理的，形状为 (sequence_length, config.model_in_channels)。如果未提供，则将随机生成。
• padding_mask (torch.BoolTensor, 可选) — 指示每个序列的哪些部分被填充的掩码。掩码值在 [0, 1] 中选择：
  • 1 用于未被“masked”的标记
  • 对于被masked的标记

  掩码可以是批处理的，形状为 (batch_size, sequence_length)，也可以是非批处理的，形状为 (sequence_length,)。

• generator（torch.Generator，可选）— 一个用于使生成过程确定性的torch 生成器。return_dict — 是否返回一个 ModelOutput 子类而不是一个普通元组。

返回

transformers.models.univnet.modeling_univnet.UnivNetModelOutput或tuple(torch.FloatTensor)

一个transformers.models.univnet.modeling_univnet.UnivNetModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（UnivNetConfig）和输入的不同元素。

• waveforms（形状为(batch_size, sequence_length)的torch.FloatTensor）— 批量的 1D（单声道）输出音频波形。
• waveform_lengths（形状为(batch_size,)的torch.FloatTensor）— waveforms中每个未填充波形的批量长度（以样本为单位）。

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

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

将噪声波形和一个条件谱图转换为语音波形。传递一批 log-mel 谱图返回一批语音波形。传递一个单独的、未批处理的 log-mel 谱图返回一个单独的、未批处理的语音波形。

示例：

>>> from transformers import UnivNetFeatureExtractor, UnivNetModel
>>> from datasets import load_dataset, Audio

>>> model = UnivNetModel.from_pretrained("dg845/univnet-dev")
>>> feature_extractor = UnivNetFeatureExtractor.from_pretrained("dg845/univnet-dev")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> # Resample the audio to the feature extractor's sampling rate.
>>> ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
>>> inputs = feature_extractor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> audio = model(**inputs).waveforms
>>> list(audio.shape)
[1, 140288]

VITS

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

概述

VITS 模型是由 Jaehyeon Kim，Jungil Kong，Juhee Son 在端到端文本到语音的条件变分自动编码器与对抗学习中提出的。

VITS（端到端文本到语音的变分推断与对抗学习）是一种端到端语音合成模型，根据输入文本序列预测语音波形。它是由后验编码器、解码器和条件先验组成的条件变分自动编码器（VAE）。

基于流的模块预测了一组基于频谱图的声学特征，该模块由基于 Transformer 的文本编码器和多个耦合层组成。使用一堆转置卷积层对频谱图进行解码，这与 HiFi-GAN 声码器的风格非常相似。受 TTS 问题的一对多性质的启发，其中相同的文本输入可以以多种方式发音，该模型还包括一个随机持续时间预测器，允许模型从相同的输入文本中合成具有不同节奏的语音。

该模型通过从变分下界和对抗训练导出的损失的组合进行端到端训练。为了提高模型的表现力，将归一化流应用于条件先验分布。在推断过程中，基于持续时间预测模块对文本编码进行上采样，然后使用一系列流模块和 HiFi-GAN 解码器将其映射到波形中。由于持续时间预测器的随机性质，该模型是非确定性的，因此需要一个固定的种子来生成相同的语音波形。

论文的摘要如下：

最近提出了几种端到端文本到语音（TTS）模型，实现了单阶段训练和并行采样，但它们的样本质量不及两阶段 TTS 系统。在这项工作中，我们提出了一种并行端到端 TTS 方法，其生成的音频听起来比当前的两阶段模型更自然。我们的方法采用了变分推断，增加了归一化流和对抗训练过程，提高了生成建模的表现力。我们还提出了一个随机持续时间预测器，用于从输入文本中合成具有不同节奏的语音。通过对潜在变量进行不确定性建模和随机持续时间预测器，我们的方法表达了自然的一对多关系，即文本输入可以以不同的音高和节奏发音。对 LJ Speech（单个说话者数据集）的主观人类评估（平均意见分数，或 MOS）显示，我们的方法优于最佳公开可用的 TTS 系统，并实现了与地面真相相当的 MOS。

这个模型也可以与大规模多语言语音（MMS）的 TTS 检查点一起使用，因为这些检查点使用相同的架构和稍作修改的分词器。

这个模型是由Matthijs和sanchit-gandhi贡献的。原始代码可以在这里找到。

用法示例

VITS 和 MMS-TTS 检查点都可以使用相同的 API。由于基于流的模型是非确定性的，最好设置一个种子以确保输出的可重现性。对于使用罗马字母表的语言，如英语或法语，可以直接使用分词器对文本输入进行预处理。以下代码示例运行了一个前向传递，使用了 MMS-TTS 英语检查点：

import torch
from transformers import VitsTokenizer, VitsModel, set_seed

tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng")

inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")

set_seed(555)  # make deterministic

with torch.no_grad():
   outputs = model(**inputs)

waveform = outputs.waveform[0]

生成的波形可以保存为.wav文件：

import scipy

scipy.io.wavfile.write("techno.wav", rate=model.config.sampling_rate, data=waveform)

或在 Jupyter Notebook / Google Colab 中显示：

from IPython.display import Audio

Audio(waveform, rate=model.config.sampling_rate)

对于某些具有非罗马字母表的语言，如阿拉伯语、普通话或印地语，需要使用uroman perl 包对文本输入进行预处理，转换为罗马字母表。

您可以通过检查预训练的tokenizer的is_uroman属性来确定您的语言是否需要uroman包。

from transformers import VitsTokenizer

tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
print(tokenizer.is_uroman)

如果需要，应在将文本输入传递给VitsTokenizer之前先对其应用 uroman 包，因为目前分词器不支持执行预处理。

要执行此操作，首先将 uroman 存储库克隆到本地计算机，并将 bash 变量UROMAN设置为本地路径：

git clone https://github.com/isi-nlp/uroman.git
cd uroman
export UROMAN=$(pwd)

然后，您可以使用以下代码片段对文本输入进行预处理。您可以依赖使用 bash 变量UROMAN指向 uroman 存储库，或者将 uroman 目录作为参数传递给uromaize函数：

import torch
from transformers import VitsTokenizer, VitsModel, set_seed
import os
import subprocess

tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-kor")
model = VitsModel.from_pretrained("facebook/mms-tts-kor")

def uromanize(input_string, uroman_path):
    """Convert non-Roman strings to Roman using the `uroman` perl package."""
    script_path = os.path.join(uroman_path, "bin", "uroman.pl")

    command = ["perl", script_path]

    process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    # Execute the perl command
    stdout, stderr = process.communicate(input=input_string.encode())

    if process.returncode != 0:
        raise ValueError(f"Error {process.returncode}: {stderr.decode()}")

    # Return the output as a string and skip the new-line character at the end
    return stdout.decode()[:-1]

text = "이봐 무슨 일이야"
uromaized_text = uromanize(text, uroman_path=os.environ["UROMAN"])

inputs = tokenizer(text=uromaized_text, return_tensors="pt")

set_seed(555)  # make deterministic
with torch.no_grad():
   outputs = model(inputs["input_ids"])

waveform = outputs.waveform[0]

VitsConfig

class transformers.VitsConfig

< source >

( vocab_size = 38 hidden_size = 192 num_hidden_layers = 6 num_attention_heads = 2 window_size = 4 use_bias = True ffn_dim = 768 layerdrop = 0.1 ffn_kernel_size = 3 flow_size = 192 spectrogram_bins = 513 hidden_act = 'relu' hidden_dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 use_stochastic_duration_prediction = True num_speakers = 1 speaker_embedding_size = 0 upsample_initial_channel = 512 upsample_rates = [8, 8, 2, 2] upsample_kernel_sizes = [16, 16, 4, 4] resblock_kernel_sizes = [3, 7, 11] resblock_dilation_sizes = [[1, 3, 5], [1, 3, 5], [1, 3, 5]] leaky_relu_slope = 0.1 depth_separable_channels = 2 depth_separable_num_layers = 3 duration_predictor_flow_bins = 10 duration_predictor_tail_bound = 5.0 duration_predictor_kernel_size = 3 duration_predictor_dropout = 0.5 duration_predictor_num_flows = 4 duration_predictor_filter_channels = 256 prior_encoder_num_flows = 4 prior_encoder_num_wavenet_layers = 4 posterior_encoder_num_wavenet_layers = 16 wavenet_kernel_size = 5 wavenet_dilation_rate = 1 wavenet_dropout = 0.0 speaking_rate = 1.0 noise_scale = 0.667 noise_scale_duration = 0.8 sampling_rate = 16000 **kwargs )

参数

• vocab_size (int, optional, defaults to 38) — VITS 模型的词汇量。定义了可以由传递给 VitsModel 的inputs_ids表示的不同令牌数量。
• hidden_size (int, optional, defaults to 192) — 文本编码器层的维度。
• num_hidden_layers (int, optional, defaults to 6) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, optional, defaults to 2) — Transformer 编码器中每个注意力层的注意力头数。
• window_size (int, optional, defaults to 4) — Transformer 编码器中注意力层的相对位置嵌入的窗口大小。
• use_bias (bool, optional, defaults to True) — 是否在 Transformer 编码器中的键、查询、值投影层中使用偏置。
• ffn_dim (int, optional, defaults to 768) — Transformer 编码器中“中间”（即前馈）层的维度。
• layerdrop (float, optional, defaults to 0.1) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。
• ffn_kernel_size (int, optional, defaults to 3) — Transformer 编码器中前馈网络使用的 1D 卷积层的核大小。
• flow_size (int, optional, defaults to 192) — 流层的维度。
• spectrogram_bins (int, optional, defaults to 513) — 目标频谱图中的频率箱数。
• hidden_act (str or function, optional, defaults to "relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
• hidden_dropout (float, optional, defaults to 0.1) — 嵌入层和编码器中所有全连接层的 dropout 概率。
• attention_dropout (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
• activation_dropout (float, optional, defaults to 0.1) — 全连接层内激活的 dropout 比率。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。
• use_stochastic_duration_prediction (bool, optional, defaults to True) — 是否使用随机持续时间预测模块或常规持续时间预测器。
• num_speakers (int, optional, defaults to 1) — 如果这是多说话者模型，则说话者数量。
• speaker_embedding_size (int, optional, 默认为 0) — 说话者嵌入使用的通道数量。对于单说话者模型，该值为零。
• upsample_initial_channel (int, optional, 默认为 512) — HiFi-GAN 上采样网络的输入通道数。
• upsample_rates (Tuple[int] 或 List[int], optional, 默认为[8, 8, 2, 2]) — 一个整数元组，定义 HiFi-GAN 上采样网络中每个 1D 卷积层的步幅。upsample_rates的长度定义了卷积层的数量，并且必须与upsample_kernel_sizes的长度匹配。
• upsample_kernel_sizes (Tuple[int] 或 List[int], optional, 默认为[16, 16, 4, 4]) — 一个整数元组，定义 HiFi-GAN 上采样网络中每个 1D 卷积层的核大小。upsample_kernel_sizes的长度定义了卷积层的数量，并且必须与upsample_rates的长度匹配。
• resblock_kernel_sizes (Tuple[int] 或 List[int], optional, 默认为[3, 7, 11]) — 一个整数元组，定义 HiFi-GAN 多接受域融合（MRF）模块中 1D 卷积层的核大小。
• resblock_dilation_sizes (Tuple[Tuple[int]] 或 List[List[int]], optional, 默认为[[1, 3, 5], [1, 3, 5], [1, 3, 5]]) — 一个嵌套的整数元组，定义 HiFi-GAN 多接受域融合（MRF）模块中扩张 1D 卷积层的扩张率。
• leaky_relu_slope (float, optional, 默认为 0.1) — leaky ReLU 激活中使用的负斜率的角度。
• depth_separable_channels (int, optional, 默认为 2) — 每个深度可分离块中要使用的通道数。
• depth_separable_num_layers (int, optional, 默认为 3) — 每个深度可分离块中要使用的卷积层数量。
• duration_predictor_flow_bins (int, optional, 默认为 10) — 在持续时间预测模型中使用无约束有理样条映射的通道数量。
• duration_predictor_tail_bound (float, optional, 默认为 5.0) — 计算持续时间预测模型中无约束有理样条时的尾部区间边界值。
• duration_predictor_kernel_size (int, optional, 默认为 3) — 用于持续时间预测模型中的 1D 卷积层的核大小。
• duration_predictor_dropout (float, optional, 默认为 0.5) — 持续时间预测模型的丢失比率。
• duration_predictor_num_flows (int, optional, 默认为 4) — 持续时间预测模型使用的流阶段数量。
• duration_predictor_filter_channels (int, optional, 默认为 256) — 持续时间预测模型中使用的卷积层的通道数。
• prior_encoder_num_flows (int, optional, 默认为 4) — 先验编码器流模型使用的流阶段数量。
• prior_encoder_num_wavenet_layers (int, optional, 默认为 4) — 先验编码器流模型使用的 WaveNet 层数量。
• posterior_encoder_num_wavenet_layers (int, optional, 默认为 16) — 后验编码器模型使用的 WaveNet 层数量。
• wavenet_kernel_size (int, optional, 默认为 5) — WaveNet 模型中使用的 1D 卷积层的核大小。
• wavenet_dilation_rate (int, optional, 默认为 1) — WaveNet 模型中使用的扩张 1D 卷积层的扩张率。
• wavenet_dropout (float, optional, 默认为 0.0) — WaveNet 层的丢失比率。
• speaking_rate (float, optional, 默认为 1.0) — 说话速率。较大的值会导致合成语音速度更快。
• noise_scale (float, optional, 默认为 0.667) — 语音预测的随机程度。较大的值会导致预测语音的变化更大。
• noise_scale_duration (float, optional, 默认为 0.8) — 持续时间预测的随机程度。较大的值会导致预测持续时间的变化更大。
• sampling_rate (int, optional, 默认为 16000) — 输出音频波形的数字化采样率，以赫兹（Hz）表示。

这是用于存储 VitsModel 配置的配置类。它用于根据指定的参数实例化 VITS 模型，定义模型架构。使用默认值实例化配置将产生类似于VITS架构的配置。

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

示例:

>>> from transformers import VitsModel, VitsConfig

>>> # Initializing a "facebook/mms-tts-eng" style configuration
>>> configuration = VitsConfig()

>>> # Initializing a model (with random weights) from the "facebook/mms-tts-eng" style configuration
>>> model = VitsModel(configuration)

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

VitsTokenizer

class transformers.VitsTokenizer

< source >

( vocab_file pad_token = '<pad>' unk_token = '<unk>' language = None add_blank = True normalize = True phonemize = True is_uroman = False **kwargs )

参数

• vocab_file (str) — 词汇表文件的路径。
• language (str, optional) — 语言标识符。
• add_blank (bool, optional, 默认为True) — 是否在其他标记之间插入标记 id 0。
• normalize (bool, optional, 默认为True) — 是否通过删除所有大小写和标点来规范化输入文本。
• phonemize (bool, optional, 默认为True) — 是否将输入文本转换为音素。
• is_uroman (bool, optional, 默认为False) — 是否在分词之前需要将uroman罗马化器应用于输入文本。

构建一个 VITS 分词器。还支持 MMS-TTS。

此分词器继承自 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]], optional) — 要编码的序列或批量序列。每个序列可以是字符串或字符串列表（预分词字符串）。如果提供的序列是字符串列表（预分词），必须设置is_split_into_words=True（以消除与批量序列的歧义）。
• text_pair (str, List[str], List[List[str]], optional) — 要编码的序列或批量序列。每个序列可以是字符串或字符串列表（预分词字符串）。如果提供的序列是字符串列表（预分词），必须设置is_split_into_words=True（以消除与批量序列的歧义）。
• text_target (str, List[str], List[List[str]], optional) — 要编码为目标文本的序列或批量序列。每个序列可以是字符串或字符串列表（预分词字符串）。如果提供的序列是字符串列表（预分词），必须设置is_split_into_words=True（以消除与批量序列的歧义）。
• text_pair_target (str, List[str], List[List[str]], optional) — 要编码为目标文本的序列或批量序列。每个序列可以是字符串或字符串列表（预分词字符串）。如果提供的序列是字符串列表（预分词），必须设置is_split_into_words=True（以消除与批量序列的歧义）。
• add_special_tokens (bool, optional, 默认为True) — 在编码序列时是否添加特殊标记。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了自动添加到输入 id 的标记。如果要自动添加bos或eos标记，则这很有用。
• padding（bool，str或 PaddingStrategy，可选，默认为False）— 激活和控制填充。接受以下值：
  • True 或 'longest': 填充到批次中最长的序列（如果只提供单个序列，则不进行填充）。
  • 'max_length': 填充到指定的最大长度，该长度由参数max_length指定，或者如果未提供该参数，则填充到模型可接受的最大输入长度。
  • False 或 'do_not_pad'（默认）：不进行填充（即，可以输出具有不同长度序列的批次）。
• truncation（bool，str或 TruncationStrategy，可选，默认为False）— 激活和控制截断。接受以下值：
  • True 或 'longest_first': 仅截断到指定的最大长度，该长度由参数max_length指定，或者如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批序列），则将逐个标记截断，从一对序列中最长的序列中删除一个标记。
  • 'only_first': 仅截断到指定的最大长度，该长度由参数max_length指定，或者如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批序列），则仅会截断第一序列。
  • 'only_second': 仅截断到指定的最大长度，该长度由参数max_length指定，或者如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批序列），则仅会截断第二序列。
  • False 或 'do_not_truncate'（默认）：不截断（即，可以输出具有大于模型最大可接受输入大小的序列长度的批次）。
• max_length（int，可选）— 控制截断/填充参数使用的最大长度。 如果未设置或设置为None，则将使用预定义的模型最大长度，如果截断/填充参数中的一个需要最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将禁用截断/填充到最大长度。
• stride（int，可选，默认为 0）— 如果与max_length一起设置为一个数字，则当return_overflowing_tokens=True时返回的溢出标记将包含截断序列末尾的一些标记，以提供截断和溢出序列之间的一些重叠。此参数的值定义重叠标记的数量。
• is_split_into_words（bool，可选，默认为False）— 输入是否已经预分词（例如，已分割为单词）。如果设置为True，则分词器会假定输入已经分割为单词（例如，通过在空格上分割），然后对其进行分词。这对于 NER 或标记分类很有用。
• pad_to_multiple_of（int，可选）— 如果设置，将序列填充到提供的值的倍数。需要激活padding。这对于启用具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上的 Tensor Cores 特别有用。
• return_tensors（str或 TensorType，可选）— 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
  • 'tf': 返回 TensorFlow tf.constant对象。
  • 'pt': 返回 PyTorch torch.Tensor对象。
  • 'np': 返回 Numpy np.ndarray对象。
• return_token_type_ids（bool，可选）— 是否返回标记类型 ID。如果保持默认设置，将根据特定分词器的默认设置返回标记类型 ID，由return_outputs属性定义。 什么是标记类型 ID？
• return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果保持默认设置，将根据特定标记化器的默认值返回注意力掩码，由 return_outputs 属性定义。 什么是注意力掩码？
• return_overflowing_tokens (bool, 可选, 默认为 False) — 是否返回溢出的标记序列。如果提供了一对输入 ID 序列（或一批对）并且 truncation_strategy = longest_first 或 True，则会引发错误，而不是返回溢出的标记。
• return_special_tokens_mask (bool, 可选, 默认为 False) — 是否返回特殊标记掩码信息。
• return_offsets_mapping (bool, 可选, 默认为 False) — 是否返回每个标记的 (char_start, char_end)。 这仅适用于继承自 PreTrainedTokenizerFast 的快速标记化器，如果使用 Python 的标记化器，此方法将引发 NotImplementedError。
• return_length (bool, 可选, 默认为 False) — 是否返回编码输入的长度。
• verbose (bool, 可选, 默认为 True) — 是否打印更多信息和警告。**kwargs — 传递给 self.tokenize() 方法

返回

BatchEncoding

一个包含以下字段的 BatchEncoding：

• input_ids — 要提供给模型的标记 ID 列表。 什么是输入 IDs？
• token_type_ids — 要提供给模型的标记类型 ID 列表（当 return_token_type_ids=True 或 token_type_ids 在 self.model_input_names 中时）。 什么是 token type IDs？
• 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 时）

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

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

VitsModel

class transformers.VitsModel

<来源>

( config: VitsConfig )

参数

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

用于文本到语音合成的完整 VITS 模型。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None speaker_id: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.models.vits.modeling_vits.VitsModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。默认情况下将忽略填充。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选的) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]之间：
  • 1 表示未被掩码的标记，
  • 0 表示被掩码的标记。

  什么是注意力掩码？

• speaker_id (int, 可选的) — 要使用的说话者嵌入。仅用于多说话者模型。
• output_attentions (bool, 可选的) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool, 可选的) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool, 可选的) — 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels (torch.FloatTensor，形状为(batch_size, config.spectrogram_bins, sequence_length)，可选的) — 目标频谱图的浮点值。时间步设置为-100.0将被忽略（掩码）用于损失计算。

返回

transformers.models.vits.modeling_vits.VitsModelOutput或tuple(torch.FloatTensor)

一个transformers.models.vits.modeling_vits.VitsModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或者当config.return_dict=False时）包含根据配置（VitsConfig）和输入的各种元素。

• waveform (torch.FloatTensor，形状为(batch_size, sequence_length)) — 模型预测的最终音频波形。
• sequence_lengths (torch.FloatTensor，形状为(batch_size,)) — waveform批次中每个元素的样本长度。
• spectrogram (torch.FloatTensor，形状为(batch_size, sequence_length, num_bins)) — 在流模型输出处预测的对数梅尔频谱图。此频谱图传递给 Hi-Fi GAN 解码器模型以获得最终的音频波形。
• 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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import VitsTokenizer, VitsModel, set_seed
>>> import torch

>>> tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
>>> model = VitsModel.from_pretrained("facebook/mms-tts-eng")

>>> inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")

>>> set_seed(555)  # make deterministic

>>> with torch.no_grad():
...     outputs = model(inputs["input_ids"])
>>> outputs.waveform.shape
torch.Size([1, 45824])

Wav2Vec2

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

概述

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

论文摘要如下：

我们首次展示，仅通过从语音音频中学习强大的表示，然后在转录的语音上进行微调，可以胜过最佳的半监督方法，同时在概念上更简单。wav2vec 2.0 在潜在空间中屏蔽语音输入，并解决了一个在联合学习的潜在表示的量化上定义的对比任务。使用 Librispeech 的所有标记数据进行的实验在干净/其他测试集上实现了 1.8/3.3 的 WER。当将标记数据量降低到一小时时，wav2vec 2.0 在 100 小时子集上胜过了先前的最先进技术，同时使用的标记数据量减少了 100 倍。仅使用十分钟的标记数据并在 53k 小时的未标记数据上进行预训练仍然实现了 4.8/8.2 的 WER。这证明了在有限的标记数据量下进行语音识别的可行性。

此模型由patrickvonplaten贡献。

使用提示

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

资源

一份官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 Wav2Vec2。如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将进行审查！资源应该理想地展示一些新内容，而不是重复现有资源。

音频分类

• 一个关于如何利用预训练的 Wav2Vec2 模型进行情感分类的笔记本。🌎
• Wav2Vec2ForCTC 受到这个示例脚本和笔记本的支持。
• 音频分类任务指南

自动语音识别

• 一篇关于在🤗 Transformers 中使用 n-grams 增强 Wav2Vec2 的博客文章。
• 一篇关于如何使用🤗 Transformers 对英语 ASR 进行微调的博客文章。
• 一篇关于使用🤗 Transformers 对多语言 ASR 进行微调的博客文章。
• 一个关于如何通过使用 Wav2Vec2 转录音频从任何视频创建 YouTube 字幕的笔记本。🌎
• Wav2Vec2ForCTC 受到一篇关于如何在英语中微调语音识别模型的笔记本和如何在任何语言中微调语音识别模型的笔记本的支持。
• 自动语音识别任务指南

🚀 部署

• 关于如何在Hugging Face 的 Transformers 和 Amazon SageMaker 中部署 Wav2Vec2 进行自动语音识别的博文。

Wav2Vec2Config

class transformers.Wav2Vec2Config

<来源>

( 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 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 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 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 adapter_attn_dim = None **kwargs )

参数

• vocab_size (int, optional, defaults to 32) — Wav2Vec2 模型的词汇表大小。定义了在调用 Wav2Vec2Model 或 TFWav2Vec2Model 时可以表示的不同标记数量。模型的词汇表大小。定义了在调用 Wav2Vec2Model 的 forward 方法时可以表示的不同标记数量。
• hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。
• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
• hidden_dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有完全连接层的 dropout 概率。
• activation_dropout (float, optional, defaults to 0.1) — 完全连接层内激活的 dropout 比率。
• attention_dropout (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
• final_dropout (float, optional, defaults to 0.1) — Wav2Vec2ForCTC 最终投影层的 dropout 概率。
• layerdrop (float, optional, defaults to 0.1) — LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文)。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
• feat_extract_norm (str, optional, defaults to "group") — 应用于特征编码器中 1D 卷积层的规范化。"group"表示仅对第一个 1D 卷积层进行组归一化，"layer"表示对所有 1D 卷积层进行层归一化。
• feat_proj_dropout (float, optional, defaults to 0.0) — 特征编码器输出的 dropout 概率。
• feat_extract_activation (str, optional, defaults to “gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数（函数或字符串）。如果是字符串，支持“gelu”、“relu”、“selu”和“gelu_new”`。
• feat_quantizer_dropout (float, optional, defaults to 0.0) — 量化特征编码器状态的 dropout 概率。
• 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 为 True表示在注意力层之前应用层归一化，而do_stable_layer_norm 为 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) — 沿时间轴的所有特征向量中将被掩盖的百分比（介于 0 和 1 之间）。掩码过程在轴上生成”mask_time_problen(time_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选择为掩盖的向量跨度起始的概率推理， mask_time_prob *应为prob_vector_start*mask_time_length。请注意，重叠可能会降低实际掩盖向量的百分比。仅在apply_spec_augment 为 True时相关。
• mask_time_length (int, optional, defaults to 10) — 沿时间轴的向量跨度长度。
• mask_time_min_masks (int, optional, defaults to 2), — 沿时间轴生成的长度为mask_feature_length的最小掩码数量，每个时间步，与mask_feature_prob无关。仅在”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”时相关
• mask_feature_prob (float, optional, defaults to 0.0) — 沿特征轴的所有特征向量中将被掩盖的百分比（介于 0 和 1 之间）。掩码过程在轴上生成”mask_feature_problen(feature_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选择为掩盖的向量跨度起始的概率推理， mask_feature_prob *应为prob_vector_start*mask_feature_length。请注意，重叠可能会降低实际掩盖向量的百分比。仅在apply_spec_augment 为 True时相关。
• mask_feature_length (int, optional, defaults to 10) — 沿特征轴的向量跨度长度。
• mask_feature_min_masks (int, optional, defaults to 0), — 沿特征轴生成的长度为mask_feature_length的最小掩码数量，每个时间步，与mask_feature_prob无关。仅在”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”时相关
• num_codevectors_per_group (int, optional, defaults to 320) — 每个量化码书（组）中的条目数。
• num_codevector_groups (int, optional, defaults to 2) — 产品码矢量量化的码矢量组数。
• contrastive_logits_temperature (float, 可选, 默认为 0.1) — 对比损失中的温度 kappa。
• feat_quantizer_dropout (float, 可选, 默认为 0.0) — 用于量化器使用的特征编码器输出的丢弃概率。
• num_negatives (int, 可选, 默认为 100) — 对比损失的负样本数量。
• codevector_dim (int, 可选, 默认为 256) — 量化特征向量的维度。
• proj_codevector_dim (int, 可选, 默认为 256) — 最终投影的维度，包括量化特征和变换器特征。
• diversity_loss_weight (int, 可选, 默认为 0.1) — 代码本多样性损失组件的权重。
• ctc_loss_reduction (str, 可选, 默认为 "sum") — 指定应用于 torch.nn.CTCLoss 输出的减少方式。仅在训练 Wav2Vec2ForCTC 实例时相关。
• ctc_zero_infinity (bool, 可选, 默认为 False) — 是否将 torch.nn.CTCLoss 的无限损失和相关梯度置零。当输入太短无法与目标对齐时，主要会出现无限损失。仅在训练 Wav2Vec2ForCTC 实例时相关。
• use_weighted_layer_sum (bool, 可选, 默认为 False) — 是否使用具有学习权重的层输出的加权平均。仅在使用 Wav2Vec2ForSequenceClassification 实例时相关。
• classifier_proj_size (int, 可选, 默认为 256) — 用于分类的令牌均值池化之前的投影维度。
• tdnn_dim (Tuple[int] 或 List[int], 可选, 默认为 (512, 512, 512, 512, 1500)) — 一个整数元组，定义了 XVector 模型中 TDNN 模块中每个一维卷积层的输出通道数。tdnn_dim 的长度定义了 TDNN 层的数量。
• tdnn_kernel (Tuple[int] 或 List[int], 可选, 默认为 (5, 3, 3, 1, 1)) — 一个整数元组，定义了 XVector 模型中 TDNN 模块中每个一维卷积层的内核大小。tdnn_kernel 的长度必须与 tdnn_dim 的长度相匹配。
• tdnn_dilation (Tuple[int] 或 List[int], 可选, 默认为 (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 for SpeechEncoderDecoder 模型非常有用。
• adapter_kernel_size (int, 可选, 默认为 3) — 适配器网络中卷积层的内核大小。仅在 add_adapter 为 True 时相关。
• adapter_stride (int, 可选, 默认为 2) — 适配器网络中卷积层的步幅。仅在 add_adapter 为 True 时相关。
• num_adapter_layers (int, 可选, 默认为 3) — 适配器网络中应使用的卷积层数量。仅在 add_adapter 为 True 时相关。
• adapter_attn_dim (int, 可选) — 每个注意力块中要使用的注意力适配器权重的维度。使用注意力适配器的模型示例是 facebook/mms-1b-all。
• output_hidden_size (int, 可选) — 编码器输出层的维度。如果未定义，则默认为 hidden-size。仅在 add_adapter 为 True 时相关。

这是用于存储 Wav2Vec2Model 配置的配置类。它用于根据指定的参数实例化 Wav2Vec2 模型，定义模型架构。使用默认值实例化配置将产生类似于 Wav2Vec2 facebook/wav2vec2-base-960h 架构的配置。

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

示例：

>>> from transformers import Wav2Vec2Config, Wav2Vec2Model

>>> # Initializing a Wav2Vec2 facebook/wav2vec2-base-960h style configuration
>>> configuration = Wav2Vec2Config()

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

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

Wav2Vec2CTCTokenizer

class transformers.Wav2Vec2CTCTokenizer

< source >

( vocab_file bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' word_delimiter_token = '|' replace_word_delimiter_char = ' ' do_lower_case = False target_lang = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。
• bos_token (str, 可选, 默认为 "<s>") — 句子开头标记。
• eos_token (str, 可选, 默认为 "</s>") — 句子结束标记。
• unk_token (str, 可选, 默认为 "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
• pad_token (str, 可选, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• word_delimiter_token (str, 可选, 默认为 "|") — 用于定义单词结尾的标记。
• do_lower_case (bool, 可选, 默认为 False) — 是否接受小写输入并在解码时将输出转换为小写。
• target_lang (str, 可选) — 分词器应默认设置的目标语言。对于多语言、嵌套词汇表，如 facebook/mms-1b-all，必须定义 target_lang。 **kwargs — 传递给 PreTrainedTokenizer 的额外关键字参数

构建一个 Wav2Vec2CTC 分词器。

这个分词器继承自 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]], optional) — 要编码为目标文本的序列或批量序列。每个序列可以是一个字符串或一个字符串列表（预先标记化的字符串）。如果序列以字符串列表（预先标记化）的形式提供，则必须设置is_split_into_words=True（以消除批量序列的歧义）。
• add_special_tokens (bool, optional, 默认为True) — 在编码序列时是否添加特殊标记。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了自动添加到输入 id 的标记。如果要自动添加bos或eos标记，则这很有用。
• padding (bool, str 或 PaddingStrategy, optional, 默认为False) — 激活和控制填充。接受以下值：
  • True 或 'longest'：填充到批量中最长的序列（如果只提供单个序列，则不填充）。
  • 'max_length'：填充到由参数max_length指定的最大长度，或者填充到模型的最大可接受输入长度（如果未提供该参数）。
  • False 或 'do_not_pad'（默认）：不填充（即，可以输出长度不同的序列批次）。
• truncation (bool, str 或 TruncationStrategy, optional, 默认为False) — 激活和控制截断。接受以下值：
  • True 或 'longest_first'：截断到由参数max_length指定的最大长度，或者截断到模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对序列（或一批对），则将逐标记截断，从一对序列中最长的序列中删除一个标记。
  • 'only_first'：截断到由参数max_length指定的最大长度，或者截断到模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对序列（或一批对），则只会截断第一个序列。
  • 'only_second'：截断到由参数max_length指定的最大长度，或者截断到模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对序列（或一批对），则只会截断第二个序列。
  • False 或 'do_not_truncate'（默认）：不截断（即，可以输出长度大于模型最大可接受输入大小的序列批次）。
• max_length (int, optional) — 控制截断/填充参数之一使用的最大长度。 如果未设置或设置为None，则将使用预定义的模型最大长度（如果截断/填充参数之一需要最大长度）。如果模型没有特定的最大输入长度（如 XLNet），则将禁用截断/填充到最大长度。
• stride (int, optional, 默认为 0) — 如果与max_length一起设置为一个数字，则当return_overflowing_tokens=True时返回的溢出标记将包含从截断序列末尾返回的一些标记，以提供截断和溢出序列之间的一些重叠。该参数的值定义了重叠标记的数量。
• is_split_into_words (bool, optional, 默认为False) — 输入是否已经预标记化（例如，已分割为单词）。如果设置为True，则分词器会假定输入已经分割为单词（例如，通过在空格上分割），然后对其进行标记化。这对于命名实体识别或标记分类很有用。
• pad_to_multiple_of (int, 可选) — 如果设置，将序列填充到提供的值的倍数。需要激活padding。这对于在具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 特别有用。
• return_tensors (str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
  • 'tf': 返回 TensorFlow tf.constant对象。
  • 'pt': 返回 PyTorch torch.Tensor对象。
  • 'np': 返回 Numpy np.ndarray对象。
• return_token_type_ids (bool, 可选) — 是否返回 token type IDs。如果保持默认设置，将根据特定标记化器的默认值返回 token type IDs，由return_outputs属性定义。 什么是 token type IDs？
• return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果保持默认设置，将根据特定标记化器的默认值返回注意力掩码，由return_outputs属性定义。 什么是 attention masks？
• return_overflowing_tokens (bool, 可选, 默认为 False) — 是否返回溢出的 token 序列。如果提供了一对输入 id 序列（或一批对）并且truncation_strategy = longest_first或True，则会引发错误，而不是返回溢出的 tokens。
• return_special_tokens_mask (bool, 可选, 默认为 False) — 是否返回特殊 token 掩码信息。
• return_offsets_mapping (bool, 可选, 默认为 False) — 是否返回每个 token 的(char_start, char_end)。 这仅适用于继承自 PreTrainedTokenizerFast 的快速标记化器，如果使用 Python 的标记化器，此方法将引发NotImplementedError。
• return_length (bool, 可选, 默认为 False) — 是否返回编码输入的长度。
• verbose (bool, 可选, 默认为 True) — 是否打印更多信息和警告。**kwargs — 传递给self.tokenize()方法

返回

BatchEncoding

一个具有以下字段的 BatchEncoding：

• input_ids — 要提供给模型的 token id 列表。 什么是 input IDs？
• token_type_ids — 要提供给模型的 token type ids 列表（当return_token_type_ids=True或*token_type_ids*在self.model_input_names中时）。 什么是 token type IDs？
• attention_mask — 指定哪些 token 应该被模型关注的索引列表（当return_attention_mask=True或*attention_mask*在self.model_input_names中时）。 什么是 attention masks？
• overflowing_tokens — 溢出的 token 序列列表（当指定了max_length并且return_overflowing_tokens=True时）。
• num_truncated_tokens — 被截断的 token 数量（当指定了max_length并且return_overflowing_tokens=True时）。
• special_tokens_mask — 由 0 和 1 组成的列表，其中 1 指定添加的特殊 token，0 指定常规序列 token（当add_special_tokens=True且return_special_tokens_mask=True时）。
• length — 输入的长度（当return_length=True时）

将主要方法标记化并为模型准备一个或多个序列或一个或多个序列对。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

decode

<来源>

( token_ids: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None output_char_offsets: bool = False output_word_offsets: bool = False **kwargs ) → export const metadata = 'undefined';str or Wav2Vec2CTCTokenizerOutput

参数

• 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) — 是否输出字符偏移量。字符偏移量可以与采样率和模型下采样率结合使用，计算转录字符的时间戳。 请查看下面的示例，以更好地理解如何使用output_char_offsets。
• output_word_offsets (bool，可选，默认为False) — 是否输出单词偏移量。单词偏移量可以与采样率和模型下采样率结合使用，计算转录单词的时间戳。 请查看下面的示例，以更好地理解如何使用output_word_offsets。
• kwargs（其他关键字参数，可选） — 将传递给底层模型特定的解码方法。

返回

str或Wav2Vec2CTCTokenizerOutput

解码后的句子列表。当output_char_offsets == True或output_word_offsets == True时，将是Wav2Vec2CTCTokenizerOutput。

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

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

示例：

>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = feature_extractor(sample["audio"]["array"], return_tensors="pt").input_values
>>> logits = model(input_values).logits[0]
>>> pred_ids = torch.argmax(logits, axis=-1)

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = tokenizer.decode(pred_ids, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:3]
[{'word': 'THE', 'start_time': 0.7, 'end_time': 0.78}, {'word': 'TRICK', 'start_time': 0.88, 'end_time': 1.08}, {'word': 'APPEARS', 'start_time': 1.2, 'end_time': 1.64}]

batch_decode

<来源>

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

参数

• 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) — 是否输出字符偏移量。字符偏移量可以与采样率和模型下采样率结合使用，计算转录字符的时间戳。 请查看 decode()的示例，以更好地理解如何使用output_char_offsets。batch_decode()与批量输出的方式相同。
• output_word_offsets (bool，可选，默认为False) — 是否输出单词偏移量。单词偏移量可以与采样率和模型下采样率结合使用，计算转录单词的时间戳。 请查看 decode()的示例，以更好地理解如何使用output_word_offsets。batch_decode()与批量输出的方式相同。
• kwargs（其他关键字参数，可选） — 将传递给底层模型特定的解码方法。

返回

List[str]或Wav2Vec2CTCTokenizerOutput

解码后的句子列表。当output_char_offsets == True或output_word_offsets == True时，将是Wav2Vec2CTCTokenizerOutput。

通过调用解码函数，将一系列 token id 的列表转换为字符串列表。

set_target_lang

< source >

( target_lang: str )

设置嵌套多语言字典的目标语言

Wav2Vec2FeatureExtractor

class transformers.Wav2Vec2FeatureExtractor

< source >

( feature_size = 1 sampling_rate = 16000 padding_value = 0.0 return_attention_mask = False do_normalize = True **kwargs )

参数

• feature_size（int，默认为 1）— 提取特征的特征维度。
• sampling_rate（int，默认为 16000）— 应以赫兹（Hz）表示的音频文件数字化的采样率。
• padding_value（float，默认为 0.0）— 用于填充值的值。
• do_normalize（bool，可选，默认为True）— 是否对输入进行零均值单位方差归一化。归一化可以帮助一些模型显著提高性能，例如 wav2vec2-lv60。
• return_attention_mask（bool，可选，默认为False）— 是否 call() 应该返回 attention_mask。 设置了 config.feat_extract_norm == "group" 的 Wav2Vec2 模型，例如 wav2vec2-base，没有使用 attention_mask 进行训练。对于这样的模型，input_values 应该简单地用 0 填充，不应传递 attention_mask。 对于设置了 config.feat_extract_norm == "layer" 的 Wav2Vec2 模型，例如 wav2vec2-lv60，应该为批量推断传递 attention_mask。

构建一个 Wav2Vec2 特征提取器。

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

__call__

< source >

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

参数

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

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

Wav2Vec2Processor

class transformers.Wav2Vec2Processor

<来源>

( feature_extractor tokenizer )

参数

• feature_extractor (Wav2Vec2FeatureExtractor) — Wav2Vec2FeatureExtractor 的一个实例。特征提取器是必需的输入。
• tokenizer (PreTrainedTokenizer) — PreTrainedTokenizer 的一个实例。分词器是必需的输入。

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

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

__call__

<来源>

( *args **kwargs )

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

pad

<来源>

( *args **kwargs )

在正常模式下使用时，此方法将所有参数转发到 Wav2Vec2FeatureExtractor 的 pad()并返回其输出。如果在上下文as_target_processor()中使用，此方法将所有参数转发到 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，可选，默认为False）— 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用repo_id指定要推送到的存储库（将默认为您的命名空间中的save_directory名称）。
• kwargs（Dict[str, Any]，可选）— 传递给 push_to_hub()方法的额外关键字参数。

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

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

batch_decode

<来源>

( *args **kwargs )

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

decode

<来源>

( *args **kwargs )

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

Wav2Vec2ProcessorWithLM

class transformers.Wav2Vec2ProcessorWithLM

<来源>

( feature_extractor: FeatureExtractionMixin tokenizer: PreTrainedTokenizerBase decoder: BeamSearchDecoderCTC )

参数

• feature_extractor（Wav2Vec2FeatureExtractor 的一个实例。特征提取器是必需的输入。
• tokenizer（Wav2Vec2CTCTokenizer 的一个实例。分词器是必需的输入。
• decoder（pyctcdecode.BeamSearchDecoderCTC）— pyctcdecode.BeamSearchDecoderCTC的一个实例。解码器是必需的输入。

构建一个 Wav2Vec2 处理器，将 Wav2Vec2 特征提取器、Wav2Vec2 CTC 分词器和具有语言模型支持的解码器包装到一个单一的处理器中，用于语言模型增强的语音识别解码。

__call__

< source >

( *args **kwargs )

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

pad

< source >

( *args **kwargs )

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

from_pretrained

< source >

( pretrained_model_name_or_path **kwargs )

参数

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

从预训练的 Wav2Vec2 处理器实例化一个 Wav2Vec2ProcessorWithLM。

这个类方法只是调用了 Wav2Vec2FeatureExtractor 的 from_pretrained()，Wav2Vec2CTCTokenizer 的 from_pretrained()，以及pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub。

请参考上述方法的文档字符串以获取更多信息。

save_pretrained

< source >

( save_directory )

batch_decode

< source >

( logits: ndarray pool: Optional = None num_processes: Optional = None beam_width: Optional = None beam_prune_logp: Optional = None token_min_logp: Optional = None hotwords: Optional = None hotword_weight: Optional = None alpha: Optional = None beta: Optional = None unk_score_offset: Optional = None lm_score_boundary: Optional = None output_word_offsets: bool = False n_best: int = 1 )

参数

• logits (np.ndarray) — 模型输出的 logits 向量，表示每个标记的对数概率。
• pool (multiprocessing.Pool, optional) — 可选的用户管理的池。如果未设置，将自动创建并关闭一个池。池应在Wav2Vec2ProcessorWithLM之后实例化。否则，LM 将不可用于池的子进程。 目前，只有使用“fork”上下文创建的池才能使用。如果传递了“spawn”池，它将被忽略，而将使用顺序解码。
• num_processes (int, optional) — 如果未设置pool，则应该在哪些进程上并行化函数。默认为可用 CPU 的数量。
• beam_width (int, optional) — 解码过程中每一步的最大 beam 数。默认为 pyctcdecode 的 DEFAULT_BEAM_WIDTH。
• beam_prune_logp (int, optional) — 比最佳 beam 差很多的 beam 将被修剪。默认为 pyctcdecode 的 DEFAULT_PRUNE_LOGP。
• token_min_logp (int, optional) — 低于此 logp 的标记将被跳过，除非它们是帧的 argmax。默认为 pyctcdecode 的 DEFAULT_MIN_TOKEN_LOGP。
• hotwords (List[str], optional) — 具有额外重要性的单词列表，可以是 LM 的 OOV
• hotword_weight (int, optional) — 热词重要性的权重因子，默认为 pyctcdecode 的 DEFAULT_HOTWORD_WEIGHT。
• alpha (float, optional) — 浅融合期间语言模型的权重
• beta (float, optional) — 在评分过程中长度得分调整的权重
• unk_score_offset (float, optional) — 未知标记的对数分数偏移量
• lm_score_boundary (bool, optional) — 在评分时是否让 kenlm 尊重边界
• output_word_offsets (bool, optional, 默认为False) — 是否输出单词偏移量。单词偏移量可以与采样率和模型下采样率结合使用，以计算转录单词的时间戳。
• n_best (int, optional, 默认为1) — 要返回的最佳假设数量。如果n_best大于 1，则返回的text将是一个字符串列表的列表，logit_score将是一个浮点数列表的列表，lm_score将是一个浮点数列表的列表，外部列表的长度将对应批次大小，内部列表的长度将对应返回的假设数量。该值应 >= 1。 请查看 decode()的示例，以更好地理解如何使用output_word_offsets。batch_decode()与批量输出的方式相同。

批量解码输出 logits 以支持语言模型的音频转录。

此函数利用了 Python 的多进程。目前，多进程仅在 Unix 系统上可用（请参阅此问题）。

如果您正在解码多个批次，请考虑创建一个Pool并将其传递给batch_decode。否则，batch_decode将非常慢，因为它将为每次调用创建一个新的Pool。请参见下面的用法示例。

示例：请参见解码多个音频。

decode

<来源>

( logits: ndarray beam_width: Optional = None beam_prune_logp: Optional = None token_min_logp: Optional = None hotwords: Optional = None hotword_weight: Optional = None alpha: Optional = None beta: Optional = None unk_score_offset: Optional = None lm_score_boundary: Optional = None output_word_offsets: bool = False n_best: int = 1 )

参数

• logits (np.ndarray) — 代表每个标记的对数概率的模型输出向量。
• beam_width (int, optional) — 解码过程中每一步的最大 beam 数。默认为 pyctcdecode 的 DEFAULT_BEAM_WIDTH。
• beam_prune_logp (int, optional) — 一个用于修剪 log-probs 小于 best_beam_logp + beam_prune_logp 的阈值。该值应 <= 0。默认为 pyctcdecode 的 DEFAULT_PRUNE_LOGP。
• token_min_logp（int，optional） — log-probs 低于 token_min_logp 的标记将被跳过，除非它们是话语的最大 log-prob。默认为 pyctcdecode 的 DEFAULT_MIN_TOKEN_LOGP。
• hotwords（List[str]，optional） — 具有额外重要性的单词列表，可能不在 LM 的词汇表中，例如[“huggingface”]
• hotword_weight（int，optional） — 增强热词分数的权重乘数。默认为 pyctcdecode 的 DEFAULT_HOTWORD_WEIGHT。
• alpha（float，optional） — 浅融合期间语言模型的权重
• beta（float，optional） — 在评分过程中长度分数调整的权重
• unk_score_offset（float，optional） — 未知标记的 log 分数偏移量
• lm_score_boundary (bool, optional) — 是否在评分时让 kenlm 尊重边界
• output_word_offsets (bool, optional, 默认为 False) — 是否输出单词偏移量。单词偏移量可以与采样率和模型下采样率结合使用，计算转录单词的时间戳。
• n_best（int，optional，默认为1） — 要返回的最佳假设数量。如果n_best大于 1，则返回的text将是一个字符串列表，logit_score将是一个浮点数列表，lm_score将是一个浮点数列表，这些列表的长度将对应于返回的假设数量。该值应大于等于 1。 请查看下面的示例，以更好地理解如何使用output_word_offsets。

使用语言模型支持将输出逻辑解码为音频转录。

示例：

>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
...     logits = model(input_values).logits[0].cpu().numpy()

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]

解码多个音频

如果您计划解码多批音频，应考虑使用 batch_decode()并传递一个实例化的multiprocessing.Pool。否则，batch_decode()的性能将比为每个音频单独调用 decode()慢，因为它在每次调用时内部实例化一个新的Pool。请参阅下面的示例：

>>> # Let's see how to use a user-managed pool for batch decoding multiple audios
>>> from multiprocessing import get_context
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm").to("cuda")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

>>> # load example dataset
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))

>>> def map_to_array(batch):
...     batch["speech"] = batch["audio"]["array"]
...     return batch

>>> # prepare speech data for batch inference
>>> dataset = dataset.map(map_to_array, remove_columns=["audio"])

>>> def map_to_pred(batch, pool):
...     inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt")
...     inputs = {k: v.to("cuda") for k, v in inputs.items()}

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

...     transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
...     batch["transcription"] = transcription
...     return batch

>>> # note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
>>> #       otherwise, the LM won't be available to the pool's sub-processes
>>> # select number of processes and batch_size based on number of CPU cores available and on dataset size
>>> with get_context("fork").Pool(processes=2) as pool:
...     result = dataset.map(
...         map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
...     )

>>> result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]

Wav2Vec2 特定输出

class transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput

< source >

( text: Union logit_score: Union = None lm_score: Union = None word_offsets: Union = None )

参数

• text（str列表或str） — 文本中的解码逻辑。通常是语音转录。
• logit_score（float列表或float） — 与生成文本相关的 beam 的总 logit 分数。
• lm_score（float列表） — 与生成文本相关的 beam 的融合 lm_score。
• word_offsets（List[Dict[str, Union[int, str]]]或List[Dict[str, Union[int, str]]]列表 — 解码单词的偏移量。结合采样率和模型下采样率，单词偏移量可用于计算每个单词的时间戳。

Wav2Vec2DecoderWithLM的输出类型，带有转录。

class transformers.modeling_outputs.Wav2Vec2BaseModelOutput

< source >

( last_hidden_state: FloatTensor = None extract_features: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )

参数

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

使用 Wav2Vec2 损失目标进行训练的模型的基类。

class transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput

<来源>

( 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 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），如官方论文中所述。

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

class transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput

<来源>

( last_hidden_state: Array = None extract_features: Array = None hidden_states: Optional = None attentions: Optional = None )

参数

• last_hidden_state (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• extract_features (jnp.ndarray of shape (batch_size, sequence_length, last_conv_dim)) — 模型最后一个卷积层提取的特征向量序列，其中last_conv_dim是最后一个卷积层的维度。
• hidden_states (tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。 模型在每一层输出处的隐藏状态以及初始嵌入输出。
• attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

replace

<来源>

( **updates )

“返回一个用新值替换指定字段的新对象。

class transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput

<来源>

( projected_states: Array = None projected_quantized_states: Array = None codevector_perplexity: Array = None hidden_states: Optional = None attentions: Optional = None )

参数

• loss (可选, 当模型处于训练模式时返回，形状为(1,)的jnp.ndarray) — 总损失，作为对比损失（L_m）和多样性损失（L_d）的总和，如官方论文中所述。 (分类) 损失。
• projected_states (jnp.ndarray，形状为(batch_size, sequence_length, config.proj_codevector_dim)） — 模型的隐藏状态投影到config.proj_codevector_dim，可用于预测掩码投影量化状态。
• projected_quantized_states (jnp.ndarray，形状为(batch_size, sequence_length, config.proj_codevector_dim)） — 投影到config.proj_codevector_dim的量化提取特征向量，表示对比损失的正目标向量。
• hidden_states (tuple(jnp.ndarray), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。 模型在每一层输出处的隐藏状态以及初始嵌入输出。
• attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

replace

<来源>

( **updates )

“返回一个用新值替换指定字段的新对象。

PytorchHide Pytorch 内容

Wav2Vec2Model

class transformers.Wav2Vec2Model

<来源>

( config: Wav2Vec2Config )

参数

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

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

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

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

forward

< source >

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

参数

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

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

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

返回

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

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

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

Wav2Vec2Model 的 forward 方法，覆盖了 __call__ 特殊方法。

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

示例：

>>> from transformers import AutoProcessor, Wav2Vec2Model
>>> 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-base-960h")
>>> model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-base-960h")

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

Wav2Vec2ForCTC

class transformers.Wav2Vec2ForCTC

< source >

( config target_lang: Optional = None )

参数

• config (Wav2Vec2Config) — 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
• target_lang (str，可选的) — 适配器权重的语言 id。适配器权重存储在格式为 adapter..safetensors 或 adapter..bin 的文件中。仅在使用带有适配器的 Wav2Vec2ForCTC 实例时相关。默认使用 ‘eng’。

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

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

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

forward

< source >

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

参数

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

  什么是注意力掩码？ 只有当相应的处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如wav2vec2-base，在进行批量推断时，应避免传递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, target_length), 可选) — 连接主义时间分类的标签。请注意，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时）包含根据配置（Wav2Vec2Config）和输入的不同元素。

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

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

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

示例:

>>> from transformers import AutoProcessor, Wav2Vec2ForCTC
>>> 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-base-960h")
>>> model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")

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

load_adapter

<来源>

( target_lang: str force_load = True **kwargs )

参数

• target_lang (str) — 必须是现有适配器权重的语言 ID。适配器权重存储在格式 adapter..safetensors 或 adapter..bin。
• force_load (bool, 默认为 True) — 即使 target_lang 与 self.target_lang 匹配，也要加载权重。
• cache_dir (Union[str, os.PathLike], 可选) — 下载的预训练模型配置应该缓存在其中的目录路径，如果不使用标准缓存。
• force_download (bool, 可选, 默认为 False) — 是否强制（重新）下载模型权重和配置文件，覆盖缓存版本（如果存在）。
• resume_download (bool, 可选, 默认为 False) — 是否删除接收不完整的文件。如果存在这样的文件，将尝试恢复下载。
• proxies (Dict[str, str], 可选) — 一个按协议或端点使用的代理服务器字典，例如，{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}。每个请求都会使用代理。
• local_files_only(bool, 可选, 默认为 False) — 是否仅查看本地文件（即不尝试下载模型）。
• token (str 或 bool, 可选) — 用作远程文件的 HTTP bearer 授权的令牌。如果为 True，或未指定，将使用运行 huggingface-cli login 时生成的令牌（存储在 ~/.huggingface 中）。
• revision (str, 可选, 默认为 "main") — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID，因为我们在 huggingface.co 上使用基于 git 的系统存储模型和其他工件，所以 revision 可以是 git 允许的任何标识符。 要测试您在 Hub 上提交的拉取请求，可以传递 `revision=“refs/pr/<pr_number>“。</pr_number>
• mirror (str, 可选) — 将源镜像到中国以加速下载。如果您来自中国并且有访问问题，可以设置此选项以解决问题。请注意，我们不保证及时性或安全性。请参考镜像站点获取更多信息。

从预训练的适配器模型加载语言适配器模型。

激活特殊的“离线模式”以在防火墙环境中使用此方法。

示例:

>>> from transformers import Wav2Vec2ForCTC, AutoProcessor

>>> ckpt = "facebook/mms-1b-all"
>>> processor = AutoProcessor.from_pretrained(ckpt)
>>> model = Wav2Vec2ForCTC.from_pretrained(ckpt, target_lang="eng")
>>> # set specific language
>>> processor.tokenizer.set_target_lang("spa")
>>> model.load_adapter("spa")

Wav2Vec2ForSequenceClassification

class transformers.Wav2Vec2ForSequenceClassification

<来源>

( config )

参数

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

在顶部添加了一个序列分类头的 Wav2Vec2 模型（一个线性层在池化输出上方）用于 SUPERB 关键词识别等任务。

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

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

该模型是 PyTorch torch.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.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

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

  什么是注意力掩码？ 只有在相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如wav2vec2-base，在进行批量推断时，应避免传递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）包含根据配置（Wav2Vec2Config）和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（或如果config.num_labels==1则为回归）损失。
• logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）- 分类（如果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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForSequenceClassification
>>> 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("superb/wav2vec2-base-superb-ks")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("superb/wav2vec2-base-superb-ks")

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

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

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

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

Wav2Vec2ForAudioFrameClassification

class transformers.Wav2Vec2ForAudioFrameClassification

<来源>

( config )

参数

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

带有顶部帧分类头的 Wav2Vec2 模型，用于 Speaker Diarization 等任务。

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

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

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

forward

<来源>

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

参数

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

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

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

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

• loss (torch.FloatTensor，形状为 (1,)，optional，当提供 labels 时返回) — 分类损失。
• logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.num_labels)) — 分类分数（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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

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

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("anton-l/wav2vec2-base-superb-sd")
>>> model = Wav2Vec2ForAudioFrameClassification.from_pretrained("anton-l/wav2vec2-base-superb-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]

Wav2Vec2ForXVector

class transformers.Wav2Vec2ForXVector

< source >

( config )

参数

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

Wav2Vec2 模型在顶部具有 XVector 特征提取头，用于 Speaker Verification 等任务。

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

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

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

forward

<来源>

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

参数

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

  什么是注意力掩码？ 只有在相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如wav2vec2-base，在进行批量推断时应避免传递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 时）包含各种元素，具体取决于配置（Wav2Vec2Config）和输入。

• loss (torch.FloatTensor，形状为 (1,)，可选，当提供 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)，可选，当传递 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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

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

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

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("anton-l/wav2vec2-base-superb-sv")
>>> model = Wav2Vec2ForXVector.from_pretrained("anton-l/wav2vec2-base-superb-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.98

Wav2Vec2ForPreTraining

transformers.Wav2Vec2ForPreTraining 类

< source >

( config: Wav2Vec2Config )

参数

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

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

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

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

forward

< source >

( 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.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 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]中：
  • 对于未屏蔽的标记，
  • 对于被屏蔽的标记。

  什么是注意力掩码？ 只有当相应的处理器具有config.return_attention_mask == True时，才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，比如wav2vec2-base，在进行批量推理时，应不传递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（形状为(batch_size, sequence_length)的torch.BoolTensor，可选）— 用于对比损失中掩盖提取特征的索引。在训练模式下，模型学习在config.proj_codevector_dim空间中预测被掩盖的提取特征。
• sampled_negative_indices（形状为(batch_size, sequence_length, num_negatives)的torch.BoolTensor，可选）— 指示哪些量化目标向量在对比损失中用作负采样向量的索引。预训练所需的输入。

返回

transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 或tuple(torch.FloatTensor)

一个 transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（Wav2Vec2Config）和输入而异的各种元素。

• loss（可选，当传递sample_negative_indices时返回，形状为(1,)的torch.FloatTensor）— 总损失，作为对比损失（L_m）和多样性损失（L_d）的总和，如官方论文中所述。 （分类）损失。
• projected_states（形状为(batch_size, sequence_length, config.proj_codevector_dim)的torch.FloatTensor）— 模型投影到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），如官方论文中所述。

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

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

示例：

>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_wav2vec2 import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
>>> model = Wav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-base")

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

TensorFlow 隐藏 TensorFlow 内容

TFWav2Vec2Model

class transformers.TFWav2Vec2Model

<来源>

( config: Wav2Vec2Config *inputs **kwargs )

参数

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

裸 TFWav2Vec2 模型变压器输出原始隐藏状态，没有特定的头部。

该模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

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

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

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

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

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

call

<来源>

( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)

参数

• input_values（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为({0})）— 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• attention_mask（形状为({0})的np.ndarray或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
  • 对于未屏蔽的标记，
  • 对于被屏蔽的标记为 0。

  什么是注意力掩码？

• token_type_ids（形状为({0})的np.ndarray或tf.Tensor，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A标记。
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids（形状为({0})的np.ndarray或tf.Tensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选）— 用于使自注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：
  • 1 表示头部未被屏蔽，
  • 0 表示头部是屏蔽的。
• inputs_embeds（形状为({0}, hidden_size)的np.ndarray或tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_values。如果您想要更多控制权来将input_values索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
• training (bool, 可选，默认为`False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

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

一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置(Wav2Vec2Config)和输入的各种元素。

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

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

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

示例:

>>> from transformers import AutoProcessor, TFWav2Vec2Model
>>> from datasets import load_dataset
>>> import soundfile as sf

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = TFWav2Vec2Model.from_pretrained("facebook/wav2vec2-base-960h")

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

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

>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values  # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state

TFWav2Vec2ForSequenceClassification

class transformers.TFWav2Vec2ForSequenceClassification

<来源>

( config )

call

<来源>

( input_values: tf.Tensor attention_mask: tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False )

TFWav2Vec2ForCTC

class transformers.TFWav2Vec2ForCTC

<来源>

( config: Wav2Vec2Config *inputs **kwargs )

参数

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

TFWav2Vec2 模型，在 Connectionist Temporal Classification (CTC)顶部具有语言建模头。

这个模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

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

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

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

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

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

call

<来源>

( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None labels: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFCausalLMOutput or tuple(tf.Tensor)

参数

• input_values（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为({0})）—词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• attention_mask（形状为({0})的np.ndarray或tf.Tensor，可选）—用于避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：
  • 1 表示“未被掩码”的标记，
  • 0 表示“被掩码”的标记。

  什么是注意力掩码？

• token_type_ids（形状为({0})的np.ndarray或tf.Tensor，可选）—段标记索引，用于指示输入的第一部分和第二部分。索引选择在[0, 1]中：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids（形状为({0})的np.ndarray或tf.Tensor，可选）—每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选）—用于使自注意力模块中选择的头部失效的掩码。选择的掩码值为[0, 1]：
  • 1 表示头部是not masked。
  • 0 表示头部被masked。
• inputs_embeds（形状为({0}, hidden_size)的np.ndarray或tf.Tensor，可选） — 可选地，可以直接传递嵌入表示，而不是传递input_values。如果您想要更多控制如何将input_values索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
• return_dict（bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
• training（bool，可选，默认为False） — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
• labels（形状为(batch_size, sequence_length)的tf.Tensor或np.ndarray，可选） — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_values文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

返回

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

一个 transformers.modeling_tf_outputs.TFCausalLMOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（Wav2Vec2Config）和输入。

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

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

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

示例：

>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFWav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = TFWav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")

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

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

>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values  # Batch size 1
>>> logits = model(input_values).logits
>>> predicted_ids = tf.argmax(logits, axis=-1)

>>> transcription = processor.decode(predicted_ids[0])

>>> # compute loss
>>> target_transcription = "A MAN SAID TO THE UNIVERSE SIR I EXIST"

>>> # Pass transcription as `text` to encode labels
>>> labels = processor(text=transcription, return_tensors="tf").input_ids

>>> loss = model(input_values, labels=labels).loss

JAXHide JAX 内容

FlaxWav2Vec2Model

class transformers.FlaxWav2Vec2Model

<来源>

( config: Wav2Vec2Config input_shape: Tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config（Wav2Vec2Config）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。
• dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32）- 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。 这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的dtype执行。 请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。 如果要更改模型参数的 dtype，请参阅 to_fp16()和 to_bf16()。

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

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

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

最后，此模型支持 JAX 的固有功能，例如：

• 即时（JIT）编译
• 自动微分
• 矢量化
• 并行化

__call__

<来源>

( input_values attention_mask = None mask_time_indices = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None freeze_feature_encoder: bool = False return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput or tuple(torch.FloatTensor)

参数

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

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

• mask_time_indices（形状为(batch_size, sequence_length)的jnp.ndarray，可选）- 用于对比损失中掩码提取特征的索引。在训练模式下，模型学习在config.proj_codevector_dim空间中预测掩码提取特征。
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多细节，请查看返回的张量下的attentions。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多细节，请查看返回的张量下的hidden_states。
• return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput 或者tuple(torch.FloatTensor)

一个 transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者config.return_dict=False）包含不同的元素，取决于配置（<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray）- 模型最后一层的隐藏状态序列。
• extract_features（形状为(batch_size, sequence_length, last_conv_dim)的jnp.ndarray）- 模型最后一个卷积层的提取特征向量序列，其中last_conv_dim是最后一个卷积层的维度。
• hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或者config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每一层的输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(jnp.ndarray)，可选，当传递output_attentions=True或者config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, FlaxWav2Vec2Model
>>> from datasets import load_dataset
>>> import soundfile as sf

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-large-lv60")
>>> model = FlaxWav2Vec2Model.from_pretrained("facebook/wav2vec2-large-lv60")

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

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

>>> input_values = processor(
...     ds["speech"][0], sampling_rate=16_000, return_tensors="np"
... ).input_values  # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state

FlaxWav2Vec2ForCTC

class transformers.FlaxWav2Vec2ForCTC

<来源>

( config: Wav2Vec2Config input_shape: Tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config (Wav2Vec2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
• dtype（jax.numpy.dtype，可选，默认为 jax.numpy.float32） — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。 这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的 dtype 执行。 请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。 如果要更改模型参数的数据类型，请参阅 to_fp16() 和 to_bf16()。

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

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

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

最后，此模型支持 JAX 的内在特性，例如：

• 即时 (JIT) 编译
• 自动微分
• 矢量化
• 并行化

__call__

<来源>

( input_values attention_mask = None mask_time_indices = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None freeze_feature_encoder: bool = False return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxMaskedLMOutput or tuple(torch.FloatTensor)

参数

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

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

• mask_time_indices (jnp.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于对比损失掩盖提取特征的索引。在训练模式下，模型学习在 config.proj_codevector_dim 空间中预测掩盖的提取特征。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量下的 attentions。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量下的 hidden_states。
• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含不同元素，取决于配置（<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>）和输入。

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

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

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

示例：

>>> import jax.numpy as jnp
>>> from transformers import AutoProcessor, FlaxWav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-large-960h-lv60")
>>> model = FlaxWav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-large-960h-lv60")

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

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

>>> input_values = processor(
...     ds["speech"][0], sampling_rate=16_000, return_tensors="np"
... ).input_values  # Batch size 1
>>> logits = model(input_values).logits
>>> predicted_ids = jnp.argmax(logits, axis=-1)

>>> transcription = processor.decode(predicted_ids[0])
>>> # should give:  "A MAN SAID TO THE UNIVERSE SIR I EXIST"

FlaxWav2Vec2ForPreTraining

class transformers.FlaxWav2Vec2ForPreTraining

< source >

( config: Wav2Vec2Config input_shape: Tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config (Wav2Vec2Config) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。
• dtype (jax.numpy.dtype, 可选, 默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。 这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的dtype进行。 请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。 如果要更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

带有量化器和顶部VQ头的 Wav2Vec2 模型。Wav2Vec2 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 提出的wav2vec 2.0:自监督学习语音表示的框架。

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

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

最后，此模型支持 JAX 的固有特性，例如：

• 即时（JIT）编译
• 自动微分
• 矢量化
• 并行化

__call__

<来源>

( input_values attention_mask = None mask_time_indices = None gumbel_temperature: int = 1 params: dict = None dropout_rng: PRNGKey = None gumbel_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None freeze_feature_encoder: bool = False return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput or tuple(torch.FloatTensor)

参数

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

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

• mask_time_indices (jnp.ndarray，形状为(batch_size, sequence_length)，optional） — 用于对比损失中掩码提取特征的索引。在训练模式下，模型学习在config.proj_codevector_dim空间中预测掩码提取特征。
• output_attentions (bool, *optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions`。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional） — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)

transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>）和输入的不同元素。

• loss (optional，在训练模式下返回，形状为(1,)的jnp.ndarray) — 总损失，作为对比损失（L_m）和多样性损失（L_d）的总和，如官方论文中所述。 （分类）损失。
• projected_states (jnp.ndarray，形状为(batch_size, sequence_length, config.proj_codevector_dim)） — 模型的隐藏状态投影到config.proj_codevector_dim，可用于预测掩码的投影量化状态。
• projected_quantized_states (jnp.ndarray，形状为(batch_size, sequence_length, config.proj_codevector_dim)） — 量化提取的特征向量投影到config.proj_codevector_dim，表示对比损失的正目标向量。
• hidden_states (tuple(jnp.ndarray)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出，一个用于每一层的输出）。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions (tuple(jnp.ndarray)，optional，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import optax
>>> import numpy as np
>>> import jax.numpy as jnp
>>> from transformers import AutoFeatureExtractor, FlaxWav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_flax_wav2vec2 import _compute_mask_indices
>>> from datasets import load_dataset
>>> import soundfile as sf

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-large-lv60")
>>> model = FlaxWav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-large-lv60")

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

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

>>> input_values = feature_extractor(ds["speech"][0], return_tensors="np").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)
>>> mask_time_indices = _compute_mask_indices((batch_size, sequence_length), mask_prob=0.2, mask_length=2)

>>> outputs = model(input_values, mask_time_indices=mask_time_indices)

>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = optax.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states)

>>> # show that cosine similarity is much higher than random
>>> assert np.asarray(cosine_sim)[mask_time_indices].mean() > 0.5