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

<来源>

代码语言：javascript复制

( 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 的文档以获取更多信息。

示例：

代码语言：javascript复制

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

<来源>

代码语言：javascript复制

( 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

<来源>

代码语言：javascript复制

( 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

<来源>

代码语言：javascript复制

( input_values: Optional attention_mask: Optional = None mask_time_indices: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.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实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

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

<来源>

代码语言：javascript复制

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

代码语言：javascript复制

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

参数

• input_values (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实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

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

代码语言：javascript复制

( 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

<来源>

代码语言：javascript复制

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

参数

• input_values (torch.FloatTensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得值，例如通过 soundfile 库(pip install soundfile)。要准备好数组以获得input_values，应使用 AutoProcessor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参见 Wav2Vec2Processor.call()。
• attention_mask (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充令牌索引上执行卷积和注意力的掩码。掩码值选在[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实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

代码语言：javascript复制

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

<来源>

代码语言：javascript复制

( 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

<来源>

代码语言：javascript复制

( 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实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

代码语言：javascript复制

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

<来源>

代码语言：javascript复制

( 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

<来源>

代码语言：javascript复制

( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.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实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

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

代码语言：javascript复制

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

代码语言：javascript复制

( 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实例，而不是这个函数，因为前者会负责运行前后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> 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来实现。更多细节请参见此问题。

用法示例：

代码语言：javascript复制

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

<来源>

代码语言：javascript复制

( 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 的文档以获取更多信息。

示例：

代码语言：javascript复制

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

代码语言：javascript复制

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

代码语言：javascript复制

( 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

<来源>

代码语言：javascript复制

( config: UnivNetConfig )

参数

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

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

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

forward

<来源>

代码语言：javascript复制

( 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 谱图返回一个单独的、未批处理的语音波形。

示例：

代码语言：javascript复制

>>> 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 英语检查点：

代码语言：javascript复制

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文件：

代码语言：javascript复制

import scipy

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

或在 Jupyter Notebook / Google Colab 中显示：

代码语言：javascript复制

from IPython.display import Audio

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

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

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

代码语言：javascript复制

from transformers import VitsTokenizer

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

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

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

代码语言：javascript复制

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

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

代码语言：javascript复制

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 >

代码语言：javascript复制

( 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 的文档以获取更多信息。

示例:

代码语言：javascript复制

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

代码语言：javascript复制

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

代码语言：javascript复制

( 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

<来源>

代码语言：javascript复制

( save_directory: str filename_prefix: Optional = None )

VitsModel

class transformers.VitsModel

<来源>

代码语言：javascript复制

( config: VitsConfig )

参数

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

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

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

forward

< source >

代码语言：javascript复制

( 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实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则会默默地忽略它们。

示例：

代码语言：javascript复制

>>> 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 和社区（由