Transformers 4.37 中文文档（七十五）

原文：huggingface.co/docs/transformers

CLAP

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

概述

CLAP 模型由 Yusong Wu，Ke Chen，Tianyu Zhang，Yuchen Hui，Taylor Berg-Kirkpatrick，Shlomo Dubnov 在大规模对比语言音频预训练与特征融合和关键词到标题增强中提出。

CLAP（对比语言音频预训练）是一个神经网络，训练于各种（音频，文本）对。它可以被指示来预测最相关的文本片段，给定一个音频，而不是直接为任务进行优化。CLAP 模型使用 SWINTransformer 从对数 Mel 频谱图输入中获取音频特征，并使用 RoBERTa 模型获取文本特征。然后，文本和音频特征被投影到具有相同维度的潜在空间中。然后使用投影音频和文本特征之间的点积作为相似分数。

论文摘要如下：

对比学习在多模态表示学习领域取得了显著的成功。在本文中，我们提出了对比语言音频预训练的流水线，通过将音频数据与自然语言描述相结合来开发音频表示。为了实现这一目标，我们首先发布了 LAION-Audio-630K，一个包含来自不同数据源的 633,526 个音频文本对的大型集合。其次，我们通过考虑不同的音频编码器和文本编码器构建了对比语言音频预训练模型。我们将特征融合机制和关键词到标题增强纳入模型设计中，以进一步使模型能够处理长度可变的音频输入并增强性能。第三，我们进行了全面的实验来评估我们的模型在三个任务中的表现：文本到音频检索，零样本音频分类和监督音频分类。结果表明，我们的模型在文本到音频检索任务中取得了优越的性能。在音频分类任务中，该模型在零样本设置下取得了最先进的性能，并且能够获得与非零样本设置中模型结果相媲美的性能。LAION-Audio-6

该模型由Younes Belkada和Arthur Zucker贡献。原始代码可以在这里找到。

ClapConfig

class transformers.ClapConfig

<来源>

( text_config = None audio_config = None logit_scale_init_value = 14.285714285714285 projection_dim = 512 projection_hidden_act = 'relu' initializer_factor = 1.0 **kwargs )

参数

• text_config（dict，可选）— 用于初始化 ClapTextConfig 的配置选项字典。
• audio_config（dict，可选）— 用于初始化 ClapAudioConfig 的配置选项字典。
• logit_scale_init_value（float，可选，默认为 14.29）— logit_scale参数的初始值。默认值根据原始 CLAP 实现使用。
• projection_dim（int，可选，默认为 512）— 文本和音频投影层的维度。
• projection_hidden_act（str，可选，默认为"relu"）— 投影层的激活函数。
• initializer_factor（float，可选，默认为 1.0）— 用于缩放模型权重初始化的因子。
• kwargs（可选）— 关键字参数的字典。

ClapConfig 是用于存储 ClapModel 配置的配置类。根据指定的参数实例化一个 CLAP 模型，定义文本模型和音频模型配置。使用默认值实例化配置将产生与 CLAP laion/clap-htsat-fused 架构类似的配置。

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

示例：

>>> from transformers import ClapConfig, ClapModel

>>> # Initializing a ClapConfig with laion-ai/base style configuration
>>> configuration = ClapConfig()

>>> # Initializing a ClapModel (with random weights) from the laion-ai/base style configuration
>>> model = ClapModel(configuration)

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

>>> # We can also initialize a ClapConfig from a ClapTextConfig and a ClapAudioConfig
>>> from transformers import ClapTextConfig, ClapAudioConfig

>>> # Initializing a ClapText and ClapAudioConfig configuration
>>> config_text = ClapTextConfig()
>>> config_audio = ClapAudioConfig()

>>> config = ClapConfig.from_text_audio_configs(config_text, config_audio)

from_text_audio_configs

<来源>

( text_config: ClapTextConfig audio_config: ClapAudioConfig **kwargs ) → export const metadata = 'undefined';ClapConfig

返回

ClapConfig

一个配置对象的实例

从 clap 文本模型配置和 clap 音频模型配置实例化一个 ClapConfig（或派生类）。

ClapTextConfig

class transformers.ClapTextConfig

<来源>

( vocab_size = 50265 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 514 type_vocab_size = 1 initializer_factor = 1.0 layer_norm_eps = 1e-12 projection_dim = 512 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 position_embedding_type = 'absolute' use_cache = True projection_hidden_act = 'relu' **kwargs )

参数

• vocab_size (int, 可选, 默认为 30522) — CLAP 模型的词汇表大小。定义了在调用 ClapTextModel 时可以表示的不同标记的数量。
• hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
• num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数。
• num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
• hidden_act (str 或 Callable, 可选, 默认为"relu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果是字符串，支持"relu"、"relu"、"silu"和"relu_new"。
• hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢弃概率。
• attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的丢弃比例。
• max_position_embeddings (int, 可选, 默认为 512) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512 或 1024 或 2048）。
• type_vocab_size (int, 可选, 默认为 2) — 在调用 ClapTextModel 时传递的token_type_ids的词汇表大小。
• layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon。
• position_embedding_type (str, 可选, 默认为"absolute") — 位置嵌入的类型。选择"absolute"、"relative_key"、"relative_key_query"中的一个。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参考Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"的更多信息，请参考[Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)]中的Method 4 (https://arxiv.org/abs/2009.13658)。
• is_decoder (bool, 可选, 默认为False) — 模型是否用作解码器。如果为False，则模型用作编码器。
• use_cache (bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。
• projection_hidden_act (str, 可选, 默认为"relu") — 投影层中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• projection_dim (int, 可选, 默认为 512) — ClapTextModelWithProjection的投影头的维度。

这是一个配置类，用于存储 ClapTextModel 的配置。根据指定的参数实例化一个 CLAP 模型，定义模型架构。使用默认值实例化配置将产生类似于 CLAP calp-hsat-fused架构的配置。

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

示例:

>>> from transformers import ClapTextConfig, ClapTextModel

>>> # Initializing a CLAP text configuration
>>> configuration = ClapTextConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = ClapTextModel(configuration)

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

ClapAudioConfig

class transformers.ClapAudioConfig

<来源>

( window_size = 8 num_mel_bins = 64 spec_size = 256 hidden_act = 'gelu' patch_size = 4 patch_stride = [4, 4] num_classes = 527 hidden_size = 768 projection_dim = 512 depths = [2, 2, 6, 2] num_attention_heads = [4, 8, 16, 32] enable_fusion = False hidden_dropout_prob = 0.1 fusion_type = None patch_embed_input_channels = 1 flatten_patch_embeds = True patch_embeds_hidden_size = 96 enable_patch_layer_norm = True drop_path_rate = 0.0 attention_probs_dropout_prob = 0.0 qkv_bias = True mlp_ratio = 4.0 aff_block_r = 4 num_hidden_layers = 4 projection_hidden_act = 'relu' layer_norm_eps = 1e-05 initializer_factor = 1.0 **kwargs )

参数

• window_size (int, 可选, 默认为 8) — 频谱图的图像大小
• num_mel_bins (int, 可选, 默认为 64) — 每帧使用的 mel 特征数。应与ClapProcessor类中使用的值对应。
• spec_size (int, 可选, 默认为 256) — 模型支持的频谱图的期望输入大小。它可以与ClapFeatureExtractor的输出不同，此时输入特征将被调整大小。对应于音频模型的image_size。
• hidden_act (str, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• patch_size (int, 可选, 默认为 4) — 音频频谱图的补丁大小
• patch_stride (list, 可选, 默认为[4, 4]) — 音频频谱图的补丁步幅
• num_classes (int, 可选, 默认为 527) — 用于头部训练的类别数
• hidden_size (int, 可选, 默认为 768) — 音频编码器输出的隐藏大小。对应于倒数第二层输出的维度，发送到投影 MLP 层。
• projection_dim (int, 可选, 默认为 512) — 投影层的隐藏大小。
• depths (list, 可选, 默认为[2, 2, 6, 2]) — 用于音频模型的 Swin 层的深度
• num_attention_heads (list, 可选, 默认为[4, 8, 16, 32]) — 用于音频模型的 Swin 层的注意力头数。
• enable_fusion (bool, 可选, 默认为False) — 是否启用补丁融合。这是作者的主要贡献，应该能够获得最佳结果。
• hidden_dropout_prob (float, 可选, 默认为 0.1) — 编码器中所有全连接层的丢失概率。
• fusion_type ([type], 可选) — 用于补丁融合的融合类型。
• patch_embed_input_channels (int, 可选, 默认为 1) — 用于输入频谱图的通道数
• flatten_patch_embeds (bool, 可选, 默认为True) — 是否展平补丁嵌入
• patch_embeds_hidden_size (int, optional, 默认为 96) — 补丁嵌入的隐藏大小。它用作输出通道数。
• enable_patch_layer_norm (bool, optional, 默认为True) — 是否启用补丁嵌入的层归一化
• drop_path_rate (float, optional, 默认为 0.0) — 用于补丁融合的 Drop path 率。
• attention_probs_dropout_prob (float, optional, 默认为 0.0) — 注意力概率的 dropout 比率。
• qkv_bias (bool, optional, 默认为True) — 是否向查询、键、值投影添加偏置。
• mlp_ratio (float, optional, 默认为 4.0) — MLP 隐藏维度与嵌入维度的比率。
• aff_block_r (int, optional, 默认为 4) — AudioFF 块中使用的 downsize_ratio。
• num_hidden_layers (int, optional, 默认为 4) — Transformer 编码器中的隐藏层数量。
• projection_hidden_act (str, optional, 默认为"relu") — 投影层中的非线性激活函数（函数或字符串）。如果是字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。
• layer_norm_eps ([type], optional, 默认为 1e-05) — 层归一化层使用的 epsilon。
• initializer_factor (float, optional, 默认为 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1，内部用于初始化测试）。

这是用于存储 ClapAudioModel 配置的配置类。根据指定的参数实例化一个 CLAP 音频编码器，定义模型架构。使用默认值实例化配置将产生类似于 CLAP laion/clap-htsat-fused架构的音频编码器的配置。

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

示例：

>>> from transformers import ClapAudioConfig, ClapAudioModel

>>> # Initializing a ClapAudioConfig with laion/clap-htsat-fused style configuration
>>> configuration = ClapAudioConfig()

>>> # Initializing a ClapAudioModel (with random weights) from the laion/clap-htsat-fused style configuration
>>> model = ClapAudioModel(configuration)

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

ClapFeatureExtractor

class transformers.ClapFeatureExtractor

< source >

( feature_size = 64 sampling_rate = 48000 hop_length = 480 max_length_s = 10 fft_window_size = 1024 padding_value = 0.0 return_attention_mask = False frequency_min: float = 0 frequency_max: float = 14000 top_db: int = None truncation: str = 'fusion' padding: str = 'repeatpad' **kwargs )

参数

• feature_size (int, optional, 默认为 64) — 提取的 Mel 频谱图的特征维度。这对应于 Mel 滤波器的数量（n_mels）。
• sampling_rate (int, optional, 默认为 48000) — 音频文件应数字化的采样率，以赫兹（Hz）表示。这仅用于警告用户，如果输入到特征提取器的音频采样率不同。
• hop_length (int,optional, 默认为 480) — 用于获取 Mel Spectrogram 的 STFT 中重叠窗口的长度。音频将被分割成较小的frames，每个帧之间的步长为hop_length。
• max_length_s (int, optional, 默认为 10) — 模型的最大输入长度（以秒为单位）。这用于填充音频。
• fft_window_size (int, optional, 默认为 1024) — 应用傅立叶变换的窗口大小（以样本为单位）。这控制了频谱图的频率分辨率。400 表示傅立叶变换在 400 个样本的窗口上计算。
• padding_value (float, optional, 默认为 0.0) — 用于填充音频的填充值。应对应于静音。
• return_attention_mask (bool, optional, 默认为False) — 模型是否应返回与输入对应的注意力掩码。
• frequency_min (float, optional, 默认为 0) — 感兴趣的最低频率。对于低于此值的频率，将不计算 STFT。
• frequency_max（float，可选，默认为 14000）- 感兴趣的最高频率。对于超过此值的值，STFT 将不会计算。
• top_db（float，可选）- 用于将 mel 频谱图转换为对数刻度的最高分贝值。有关更多详细信息，请参阅audio_utils.power_to_db函数
• truncation（str，可选，默认为"fusion"）- 用于长音频输入的截断模式。有两种模式可用：
  • fusion将使用_random_mel_fusion，它堆叠了来自 mel 频谱图的 3 个随机裁剪和整个 mel 频谱图的降采样版本。如果config.fusion设置为 True，则较短的音频也需要返回 4 个 mel，这将只是从填充音频中获得的原始 mel 的副本。
  • rand_trunc将选择 mel 频谱图的随机裁剪。
• padding（str，可选，默认为"repeatpad"）- 用于较短音频输入的填充模式。最初实现了三种模式：
  • repeatpad：音频被重复，然后被填充以适应max_length。
  • repeat：音频被重复，然后被裁剪以适应max_length
  • pad：音频被填充。

构建一个 CLAP 特征提取器。

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

这个类使用自定义的 numpy 实现短时傅里叶变换（STFT）从原始语音中提取 mel 滤波器组特征，这应该与 pytorch 的torch.stft等效。

to_dict

< source >

( ) → export const metadata = 'undefined';Dict[str, Any]

返回

Dict[str, Any]

构成此配置实例的所有属性的字典，除了 mel 滤波器组，它们不需要被保存或打印，因为它们太长。

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

ClapProcessor

class transformers.ClapProcessor

< source >

( feature_extractor tokenizer )

参数

• feature_extractor（ClapFeatureExtractor）- 音频处理器是必需的输入。
• tokenizer（RobertaTokenizerFast）- 分词器是必需的输入。

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

ClapProcessor 提供了 ClapFeatureExtractor 和 RobertaTokenizerFast 的所有功能。有关更多信息，请参阅__call__()和 decode()。

batch_decode

< source >

( *args **kwargs )

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

decode

< source >

( *args **kwargs )

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

ClapModel

class transformers.ClapModel

<来源>

( config: ClapConfig )

参数

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

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

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

forward

<来源>

( input_ids: Optional = None input_features: Optional = None is_longer: Optional = None attention_mask: Optional = None position_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.clap.modeling_clap.ClapOutput or tuple(torch.FloatTensor)

参数

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

  注意力掩码是什么？

• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 位置 ID 是什么？
• input_features (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 输入音频特征。这应该由 ClapFeatureExtractor 类返回，您也可以从 AutoFeatureExtractor 中检索。有关详细信息，请参阅ClapFeatureExtractor.__call__()。
• return_loss (bool, 可选) — 是否返回对比损失。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.clap.modeling_clap.ClapOutput 或 tuple(torch.FloatTensor)

一个transformers.models.clap.modeling_clap.ClapOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（<class 'transformers.models.clap.configuration_clap.ClapConfig'>）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), 可选, 当 return_loss 为 True 时返回) — 音频-文本相似性的对比损失。
• logits_per_audio:(torch.FloatTensor of shape (audio_batch_size, text_batch_size)) — audio_embeds 和 text_embeds 之间的缩放点积分数。这代表了音频-文本相似度分数。
• logits_per_text:(torch.FloatTensor of shape (text_batch_size, audio_batch_size)) — text_embeds 和 audio_embeds 之间的缩放点积分数。这代表了文本-音频相似度分数。
• text_embeds(torch.FloatTensor of shape (batch_size, output_dim) — 通过将 ClapTextModel 的汇聚输出应用到投影层而获得的文本嵌入。
• audio_embeds(torch.FloatTensor of shape (batch_size, output_dim) — 通过将 ClapAudioModel 的汇聚输出应用到投影层而获得的音频嵌入。
• text_model_output(BaseModelOutputWithPooling): ClapTextModel 的输出。
• audio_model_output(BaseModelOutputWithPooling): ClapAudioModel 的输出。

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

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

示例：

>>> from datasets import load_dataset
>>> from transformers import AutoProcessor, ClapModel

>>> dataset = load_dataset("ashraq/esc50")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
>>> processor = AutoProcessor.from_pretrained("laion/clap-htsat-unfused")

>>> input_text = ["Sound of a dog", "Sound of vaccum cleaner"]

>>> inputs = processor(text=input_text, audios=audio_sample, return_tensors="pt", padding=True)

>>> outputs = model(**inputs)
>>> logits_per_audio = outputs.logits_per_audio  # this is the audio-text similarity score
>>> probs = logits_per_audio.softmax(dim=-1)  # we can take the softmax to get the label probabilities

get_text_features

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

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

  什么是注意力掩码？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID？
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

text_features (torch.FloatTensor of shape (batch_size, output_dim)

通过将 ClapTextModel 的汇聚输出应用到投影层而获得的文本嵌入。

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

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

示例:

>>> from transformers import AutoTokenizer, ClapModel

>>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
>>> tokenizer = AutoTokenizer.from_pretrained("laion/clap-htsat-unfused")

>>> inputs = tokenizer(["the sound of a cat", "the sound of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)

get_audio_features

< source >

( input_features: Optional = None is_longer: Optional = None attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';audio_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

• input_features (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 输入音频特征。这应该由 ClapFeatureExtractor 类返回，您也可以从 AutoFeatureExtractor 中检索。有关详细信息，请参阅 ClapFeatureExtractor.__call__()。
• is_longer (torch.FloatTensor，形状为 (batch_size, 1)，可选) — 音频片段是否比 max_length 更长。如果为 True，将启用特征融合以增强特征。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

audio_features (torch.FloatTensor，形状为 (batch_size, output_dim))

通过将投影层应用于 ClapAudioModel 的汇聚输出获得的音频嵌入。

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

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

示例:

>>> from transformers import AutoFeatureExtractor, ClapModel
>>> import torch

>>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused")
>>> random_audio = torch.rand((16_000))
>>> inputs = feature_extractor(random_audio, return_tensors="pt")
>>> audio_features = model.get_audio_features(**inputs)

ClapTextModel

class transformers.ClapTextModel

< source >

( config add_pooling_layer = True )

该模型可以作为编码器（仅具有自注意力）以及解码器的行为，此时在自注意力层之间添加了一层交叉注意力，遵循 Attention is all you need_ 中描述的架构，作者为 Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin。

要使模型行为像一个解码器，需要使用配置中的 is_decoder 参数设置为 True 来初始化模型。要在 Seq2Seq 模型中使用，模型需要使用 is_decoder 参数和 add_cross_attention 都设置为 True 来初始化；然后预期在前向传递中输入一个 encoder_hidden_states。

… _注意力就是你所需要的: arxiv.org/abs/1706.03762

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）：编码器最后一层的隐藏状态序列。如果模型配置为解码器，则用于交叉注意力。encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）：避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选择在[0, 1]之间：

• 对于未被masked的标记为 1，
• 对于被masked的标记为 0。past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量）：包含注意力块的预计算键和值隐藏状态。可用于加速解码。

如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。use_cache（bool，可选）：如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

ClapTextModelWithProjection

class transformers.ClapTextModelWithProjection

<来源>

( config: ClapTextConfig )

参数

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

带有顶部投影层的 CLAP 文本模型（在汇总输出的顶部有一个线性层）。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.clap.modeling_clap.ClapTextModelOutput or tuple(torch.FloatTensor)

参数

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

  什么是注意力掩码？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.clap.modeling_clap.ClapTextModelOutput或tuple(torch.FloatTensor)

一个transformers.models.clap.modeling_clap.ClapTextModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置(<class 'transformers.models.clap.configuration_clap.ClapTextConfig'>)和输入的各种元素。

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

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

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

示例：

>>> from transformers import AutoTokenizer, ClapTextModelWithProjection

>>> model = ClapTextModelWithProjection.from_pretrained("laion/clap-htsat-unfused")
>>> tokenizer = AutoTokenizer.from_pretrained("laion/clap-htsat-unfused")

>>> inputs = tokenizer(["a sound of a cat", "a sound of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> text_embeds = outputs.text_embeds

ClapAudioModel

class transformers.ClapAudioModel

< source >

( config: ClapAudioConfig )

forward

< source >

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

参数

• input_features (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 输入音频特征。这应该由 ClapFeatureExtractor 类返回，您也可以从 AutoFeatureExtractor 中检索。有关详细信息，请参阅ClapFeatureExtractor.__call__()。
• is_longer (torch.FloatTensor, 形状为(batch_size, 1), optional) — 音频剪辑是否比max_length更长。如果为True，将启用特征融合以增强特征。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包括各种元素，取决于配置（<class 'transformers.models.clap.configuration_clap.ClapAudioConfig'>）和输入。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列输出。
• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）- 经过用于辅助预训练任务的层进一步处理后的序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from datasets import load_dataset
>>> from transformers import AutoProcessor, ClapAudioModel

>>> dataset = load_dataset("ashraq/esc50")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model = ClapAudioModel.from_pretrained("laion/clap-htsat-fused")
>>> processor = AutoProcessor.from_pretrained("laion/clap-htsat-fused")

>>> inputs = processor(audios=audio_sample, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state

ClapAudioModelWithProjection

class transformers.ClapAudioModelWithProjection

<来源>

( config: ClapAudioConfig )

参数

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

在顶部具有投影层的 CLAP 音频模型（在池化输出的顶部有一个线性层）。

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

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

前进

<来源>

( input_features: Optional = None is_longer: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.clap.modeling_clap.ClapAudioModelOutput or tuple(torch.FloatTensor)

参数

• input_features（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—输入音频特征。这应该由您可以从 AutoFeatureExtractor 中检索的 ClapFeatureExtractor 类返回。有关详细信息，请参阅ClapFeatureExtractor.__call__()。
• is_longer（形状为(batch_size, 1)的torch.FloatTensor，可选）—音频剪辑是否比max_length更长。如果为True，将启用特征融合以增强特征。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.models.clap.modeling_clap.ClapAudioModelOutput或tuple(torch.FloatTensor)

一个transformers.models.clap.modeling_clap.ClapAudioModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包括根据配置（<class 'transformers.models.clap.configuration_clap.ClapAudioConfig'>）和输入的不同元素。

• audio_embeds（形状为(batch_size, hidden_size)的torch.FloatTensor）—通过将投影层应用于 pooler_output 获得的音频嵌入。
• last_hidden_state（形状为(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 之后的注意力权重，用于计算自注意力头中的加权平均值。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）—形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

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

示例：

>>> from datasets import load_dataset
>>> from transformers import ClapAudioModelWithProjection, ClapProcessor

>>> model = ClapAudioModelWithProjection.from_pretrained("laion/clap-htsat-fused")
>>> processor = ClapProcessor.from_pretrained("laion/clap-htsat-fused")

>>> dataset = load_dataset("ashraq/esc50")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> inputs = processor(audios=audio_sample, return_tensors="pt")
>>> outputs = model(**inputs)
>>> audio_embeds = outputs.audio_embeds

EnCodec

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

概述

EnCodec 神经编解码器模型由 Alexandre Défossez、Jade Copet、Gabriel Synnaeve 和 Yossi Adi 在High Fidelity Neural Audio Compression中提出。

论文摘要如下：

我们引入了一种基于神经网络的最先进的实时、高保真音频编解码器。它由一个流式编码器-解码器架构组成，具有量化的潜在空间，以端到端的方式进行训练。我们通过使用一个多尺度频谱对抗器简化和加速训练，有效减少了伪影并产生高质量样本。我们引入了一种新颖的损失平衡机制来稳定训练：损失的权重现在定义了它应该代表整体梯度的比例，从而将这个超参数的选择与典型损失的规模分离。最后，我们研究了轻量级 Transformer 模型如何进一步压缩获得的表示，最多可减少 40%，同时保持快于实时。我们提供了对所提出模型的关键设计选择的详细描述，包括：训练目标、架构变化以及各种感知损失函数的研究。我们进行了广泛的主观评估（MUSHRA 测试），并对一系列带宽和音频领域进行了消融研究，包括语音、嘈杂混响语音和音乐。我们的方法在所有评估设置中优于基线方法，考虑到 24 kHz 单声道和 48 kHz 立体声音频。

该模型由Matthijs、Patrick Von Platen和Arthur Zucker贡献。原始代码可在此处找到。

用法示例

以下是使用该模型对音频进行编码和解码的快速示例：

>>> from datasets import load_dataset, Audio
>>> from transformers import EncodecModel, AutoProcessor
>>> librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> model = EncodecModel.from_pretrained("facebook/encodec_24khz")
>>> processor = AutoProcessor.from_pretrained("facebook/encodec_24khz")
>>> librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=processor.sampling_rate))
>>> audio_sample = librispeech_dummy[-1]["audio"]["array"]
>>> inputs = processor(raw_audio=audio_sample, sampling_rate=processor.sampling_rate, return_tensors="pt")

>>> encoder_outputs = model.encode(inputs["input_values"], inputs["padding_mask"])
>>> audio_values = model.decode(encoder_outputs.audio_codes, encoder_outputs.audio_scales, inputs["padding_mask"])[0]
>>> # or the equivalent with a forward pass
>>> audio_values = model(inputs["input_values"], inputs["padding_mask"]).audio_values

EncodecConfig

class transformers.EncodecConfig

< source >

( target_bandwidths = [1.5, 3.0, 6.0, 12.0, 24.0] sampling_rate = 24000 audio_channels = 1 normalize = False chunk_length_s = None overlap = None hidden_size = 128 num_filters = 32 num_residual_layers = 1 upsampling_ratios = [8, 5, 4, 2] norm_type = 'weight_norm' kernel_size = 7 last_kernel_size = 7 residual_kernel_size = 3 dilation_growth_rate = 2 use_causal_conv = True pad_mode = 'reflect' compress = 2 num_lstm_layers = 2 trim_right_ratio = 1.0 codebook_size = 1024 codebook_dim = None use_conv_shortcut = True **kwargs )

参数

• target_bandwidths (List[float], optional, defaults to [1.5, 3.0, 6.0, 12.0, 24.0]) — 模型可以对音频进行编码的不同带宽范围。
• sampling_rate (int, optional, defaults to 24000) — 音频波形应数字化的采样率，以赫兹（Hz）表示。
• audio_channels (int, optional, defaults to 1) — 音频数据中的通道数。单声道为 1，立体声为 2。
• normalize (bool, optional, defaults to False) — 传递音频时是否应该进行归一化。
• chunk_length_s (float, optional) — 如果定义了，音频将被预处理成长度为chunk_length_s的块，然后进行编码。
• overlap (float, optional) — 定义每个块之间的重叠。用于计算chunk_stride的公式为：int((1.0 - self.overlap) * self.chunk_length)。
• hidden_size (int, optional, defaults to 128) — 中间表示维度。
• num_filters (int, optional, defaults to 32) — 第一个EncodecConv1d下采样层的卷积核数量。
• num_residual_layers (int, optional, defaults to 1) — 残差层的数量。
• upsampling_ratios (Sequence[int] , optional, defaults to [8, 5, 4, 2]) — 核大小和步幅比例。编码器使用下采样比率而不是上采样比率，因此将使用与此处指定的相反顺序的比率，这些比率必须与解码器顺序匹配。
• norm_type (str, optional, defaults to "weight_norm") — 归一化方法。应为["weight_norm", "time_group_norm"]之一。
• kernel_size (int, optional, defaults to 7) — 初始卷积的核大小。
• last_kernel_size (int, 可选, 默认为 7) — 最后一个卷积层的核大小。
• residual_kernel_size (int, 可选, 默认为 3) — 残差层的核大小。
• dilation_growth_rate (int, 可选, 默认为 2) — 每层增加膨胀的量。
• use_causal_conv (bool, 可选, 默认为True) — 是否使用完全因果卷积。
• pad_mode (str, 可选, 默认为"reflect") — 卷积的填充模式。
• compress (int, 可选, 默认为 2) — 在残差分支中的降维度（来自 Demucs v3）。
• num_lstm_layers (int, 可选, 默认为 2) — 编码器末端的 LSTM 层数。
• trim_right_ratio (float, 可选, 默认为 1.0) — 在use_causal_conv = True设置下对转置卷积右侧进行修剪的比例。如果等于 1.0，则表示所有修剪都在右侧完成。
• codebook_size (int, 可选, 默认为 1024) — 组成 VQVAE 的离散代码的数量。
• codebook_dim (int, 可选) — 代码书向量的维度。如果未定义，则使用hidden_size。
• use_conv_shortcut (bool, 可选, 默认为True) — 是否在EncodecResnetBlock块中使用卷积层作为“跳过”连接。如果为 False，将使用一个恒等函数，提供一个通用的残差连接。

这是用于存储 EncodecModel 配置的配置类。它用于根据指定的参数实例化一个 Encodec 模型，定义模型架构。使用默认值实例化配置将产生类似于facebook/encodec_24khz架构的配置。

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

示例：

>>> from transformers import EncodecModel, EncodecConfig

>>> # Initializing a "facebook/encodec_24khz" style configuration
>>> configuration = EncodecConfig()

>>> # Initializing a model (with random weights) from the "facebook/encodec_24khz" style configuration
>>> model = EncodecModel(configuration)

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

EncodecFeatureExtractor

class transformers.EncodecFeatureExtractor

<来源>

( feature_size: int = 1 sampling_rate: int = 24000 padding_value: float = 0.0 chunk_length_s: float = None overlap: float = None **kwargs )

参数

• feature_size (int, 可选, 默认为 1) — 提取特征的特征维度。对于单声道使用 1，立体声使用 2。
• sampling_rate (int, 可选, 默认为 24000) — 音频波形应数字化的采样率，以赫兹（Hz）表示。
• padding_value (float, 可选, 默认为 0.0) — 用于填充值的值。
• chunk_length_s (float, 可选) — 如果定义了，则音频将被预处理成长度为chunk_length_s的块，然后进行编码。
• overlap (float, 可选) — 定义每个块之间的重叠。用于计算chunk_stride的公式为：int((1.0 - self.overlap) * self.chunk_length)。

构建一个 EnCodec 特征提取器。

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

使用默认值实例化特征提取器将产生类似于facebook/encodec_24khz架构的配置。

__call__

<来源>

( raw_audio: Union padding: Union = None truncation: Optional = False max_length: Optional = None return_tensors: Union = None sampling_rate: Optional = None )

参数

• raw_audio (np.ndarray，List[float]，List[np.ndarray]，List[List[float]]) — 要处理的序列或序列批次。每个序列可以是一个 numpy 数组，一个浮点值列表，一个 numpy 数组列表或一个浮点值列表的列表。对于单声道音频（feature_size = 1），numpy 数组的形状必须为(num_samples,)，对于立体声音频（feature_size = 2），形状为(2, num_samples)。
• padding (bool，str或 PaddingStrategy，可选，默认为True) — 选择一种策略来填充返回的序列（根据模型的填充方向和填充索引）：
  • True或'longest'：填充到批次中最长的序列（如果只提供单个序列，则不填充）。
  • 'max_length'：填充到指定的最大长度（使用参数max_length）或模型的最大可接受输入长度（如果未提供该参数）。
  • False或'do_not_pad'（默认）：无填充（即，可以输出长度不同的序列批次）。
• truncation (bool，可选，默认为False) — 激活截断，将长于max_length的输入序列截断为max_length。
• max_length (int, 可选) — 返回列表的最大长度，可选填充长度（见上文）。
• return_tensors (str或 TensorType，可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
  • 'tf'：返回 TensorFlow tf.constant对象。
  • 'pt'：返回 PyTorch torch.Tensor对象。
  • 'np'：返回 Numpy np.ndarray对象。
• sampling_rate (int，可选) — 对audio输入进行采样的采样率。强烈建议在前向调用时传递sampling_rate以防止潜在错误。

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

EncodecModel

class transformers.EncodecModel

<来源>

( config: EncodecConfig )

参数

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

EnCodec 神经音频编解码器模型。该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

decode

<来源>

( audio_codes: Tensor audio_scales: Tensor padding_mask: Optional = None return_dict: Optional = None )

参数

• audio_codes (torch.FloatTensor，形状为(batch_size, nb_chunks, chunk_length)，可选) — 使用model.encode计算的离散码嵌入。
• audio_scales (torch.Tensor，形状为(batch_size, nb_chunks)，可选) — 每个audio_codes输入的缩放因子。
• padding_mask (torch.Tensor，形状为(batch_size, channels, sequence_length)） — 用于填充input_values的填充蒙版。
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

将给定的帧解码为输出音频波形。

请注意，输出可能比输入大一点。在这种情况下，可以裁剪末尾的任何额外步骤。

encode

<来源>

( input_values: Tensor padding_mask: Tensor = None bandwidth: Optional = None return_dict: Optional = None )

参数

• input_values (torch.Tensor of shape (batch_size, channels, sequence_length)) — 输入音频波形的浮点值。
• padding_mask (torch.Tensor of shape (batch_size, channels, sequence_length)) — 用于填充input_values的填充掩码。
• bandwidth (float, optional) — 目标带宽。必须是config.target_bandwidths之一。如果为None，则使用最小可能的带宽。带宽表示为其千分之一，例如 6kbps 带宽表示为bandwidth == 6.0

将输入音频波形编码为离散代码。

forward

<来源>

( input_values: Tensor padding_mask: Optional = None bandwidth: Optional = None audio_codes: Optional = None audio_scales: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.encodec.modeling_encodec.EncodecOutput or tuple(torch.FloatTensor)

参数

• input_values (torch.FloatTensor of shape (batch_size, channels, sequence_length), optional) — 将原始音频输入转换为 Float 并填充到适当的长度，以便使用长度为 self.chunk_length 的块和config.chunk_stride的步长进行编码。
• padding_mask (torch.BoolTensor of shape (batch_size, channels, sequence_length), optional) — 用于避免在填充标记索引上计算缩放因子的掩码（我们可以避免在这些上计算卷积+）。掩码值选择在[0, 1]之间：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  应始终传递padding_mask，除非输入被截断或未填充。这是因为为了有效处理张量，输入音频应该被填充，以便input_length % stride = step，其中step = chunk_length-stride。这确保所有块具有相同的形状

• bandwidth (float, optional) — 目标带宽。必须是config.target_bandwidths之一。如果为None，则使用最小可能的带宽。带宽表示为其千分之一，例如 6kbps 带宽表示为bandwidth == 6.0
• audio_codes (torch.FloatTensor of shape (batch_size, nb_chunks, chunk_length), optional) — 使用model.encode计算的离散代码嵌入。
• audio_scales (torch.Tensor of shape (batch_size, nb_chunks), optional) — 每个audio_codes输入的缩放因子。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.encodec.modeling_encodec.EncodecOutput或tuple(torch.FloatTensor)

一个transformers.models.encodec.modeling_encodec.EncodecOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（EncodecConfig）和输入的各种元素。

• audio_codes (torch.FloatTensor of shape (batch_size, nb_chunks, chunk_length), optional) — 使用model.encode计算的离散代码嵌入。
• audio_values (torch.FlaotTensor of shape (batch_size, sequence_length), optional) 解码音频值，使用 Encodec 的解码器部分获得。

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

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

示例：

>>> from datasets import load_dataset
>>> from transformers import AutoProcessor, EncodecModel

>>> dataset = load_dataset("ashraq/esc50")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model_id = "facebook/encodec_24khz"
>>> model = EncodecModel.from_pretrained(model_id)
>>> processor = AutoProcessor.from_pretrained(model_id)

>>> inputs = processor(raw_audio=audio_sample, return_tensors="pt")

>>> outputs = model(**inputs)
>>> audio_codes = outputs.audio_codes
>>> audio_values = outputs.audio_values

Hubert

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

概述

Hubert 是由 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov、Abdelrahman Mohamed 在《HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units》中提出的。

该论文的摘要如下：

自监督语音表示学习面临三个独特问题的挑战：（1）每个输入话语中有多个声音单元，（2）在预训练阶段没有输入声音单元的词典，（3）声音单元具有可变长度且没有明确的分割。为了解决这三个问题，我们提出了 Hidden-Unit BERT（HuBERT）方法，用于自监督语音表示学习，该方法利用离线聚类步骤为类似 BERT 的预测损失提供对齐的目标标签。我们方法的一个关键组成部分是仅在掩码区域上应用预测损失，这迫使模型在连续输入上学习组合声学和语言模型。HuBERT 主要依赖于无监督聚类步骤的一致性，而不是分配的簇标签的内在质量。从一个简单的 100 个簇的 k-means 教师开始，并使用两次聚类迭代，HuBERT 模型在 Librispeech（960h）和 Libri-light（60,000h）基准测试中的 10min、1h、10h、100h 和 960h 微调子集上要么与 wav2vec 2.0 的最新性能相匹配，要么有所提升。使用 1B 参数模型，HuBERT 在更具挑战性的 dev-other 和 test-other 评估子集上显示出高达 19%和 13%的相对 WER 降低。

该模型由patrickvonplaten贡献。

使用提示

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

资源

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

HubertConfig

class transformers.HubertConfig

<来源>

( 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_layer_norm = True feat_proj_dropout = 0.0 final_dropout = 0.1 layerdrop = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 feat_extract_norm = 'group' feat_extract_activation = 'gelu' conv_dim = (512, 512, 512, 512, 512, 512, 512) conv_stride = (5, 2, 2, 2, 2, 2, 2) conv_kernel = (10, 3, 3, 3, 3, 2, 2) conv_bias = False num_conv_pos_embeddings = 128 num_conv_pos_embedding_groups = 16 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 ctc_loss_reduction = 'sum' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 **kwargs )

参数

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

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

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

示例：

>>> from transformers import HubertModel, HubertConfig

>>> # Initializing a Hubert facebook/hubert-base-ls960 style configuration
>>> configuration = HubertConfig()

>>> # Initializing a model from the facebook/hubert-base-ls960 style configuration
>>> model = HubertModel(configuration)

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

PytorchHide Pytorch content

HubertModel

class transformers.HubertModel

<来源>

( config: HubertConfig )

参数

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

裸的 Hubert 模型变压器输出原始隐藏状态，没有特定的顶部头。Hubert 是由 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov、Abdelrahman Mohamed 在《HuBERT:通过隐藏单元的屏蔽预测进行自监督语音表示学习》中提出的。

这个模型继承自 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.BaseModelOutput or tuple(torch.FloatTensor)

参数

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

  什么是注意力掩码？ 只有当相应的处理器具有config.return_attention_mask == True时才应传递attention_mask。对于所有处理器具有config.return_attention_mask == False的模型，例如hubert-base，在进行批量推理时，应避免传递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.BaseModelOutput 或 tuple(torch.FloatTensor)

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

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• 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 之后的注意力权重。

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = HubertModel.from_pretrained("facebook/hubert-large-ls960-ft")

>>> 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="pt").input_values  # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state

HubertForCTC

class transformers.HubertForCTC

<来源>

( config target_lang: Optional = None )

参数

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

带有顶部语言建模头部的 Hubert 模型，用于连接主义时间分类（CTC）。Hubert 是由 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov、Abdelrahman Mohamed 在《HuBERT:通过隐藏单元的掩码预测进行自监督语音表示学习》中提出的。

这个模型继承自 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.CausalLMOutput or tuple(torch.FloatTensor)

参数

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

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

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
• 标签 (torch.LongTensor，形状为(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 时）包含根据配置（HubertConfig）和输入而异的各种元素。

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

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

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

示例：

>>> from transformers import AutoProcessor, HubertForCTC
>>> 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/hubert-large-ls960-ft")
>>> model = HubertForCTC.from_pretrained("facebook/hubert-large-ls960-ft")

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

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

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

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

HubertForSequenceClassification

class transformers.HubertForSequenceClassification

< source >

( config )

参数

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

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

Hubert 是由 Wei-Ning Hsu, Benjamin Bolte, Yao-Hung Hubert Tsai, Kushal Lakhotia, Ruslan Salakhutdinov, Abdelrahman Mohamed 在 HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units 中提出的。

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

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

forward

< source >

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

参数

• input_values (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将 .flac 或 .wav 音频文件加载到类型为 List[float] 或 numpy.ndarray 的数组中获得，例如通过 soundfile 库（pip install soundfile）。为准备好输入值数组，应使用 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 的模型，例如 hubert-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）包含各种元素，取决于配置（HubertConfig）和输入。

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

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

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

示例：

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

TensorFlowHide TensorFlow 内容

TFHubertModel

class transformers.TFHubertModel

< source >

( config: HubertConfig *inputs **kwargs )

参数

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

裸的 TFHubert 模型变换器输出原始隐藏状态，没有特定的头部在顶部。

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

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

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

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

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。 由于有此支持，当使用 model.fit() 等方法时，应该可以正常工作 - 只需以 model.fit() 支持的任何格式传递输入和标签！ 但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 Keras Functional 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

< source >

( 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 (np.ndarray 或 tf.Tensor，形状为 ({0})，可选) — 用于避免在填充标记索引上执行注意力的掩码。 选择的掩码值在 [0, 1] 中：
  • 1 表示未被 masked 的标记，
  • 0 表示被 masked 的标记。

  什么是注意力掩码？

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

  什么是标记类型 ID？

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

返回

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

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

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

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = TFHubertModel.from_pretrained("facebook/hubert-large-ls960-ft")

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

TFHubertForCTC

class transformers.TFHubertForCTC

<来源>

( config: HubertConfig *inputs **kwargs )

参数

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

带有顶部“语言建模”头的 TFHubert 模型，用于连接主义时间分类（CTC）。

此模型继承自 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 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 (np.ndarray或tf.Tensor，形状为({0}), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应一个sentence A标记，
  • 1 对应一个sentence B标记。

  什么是标记类型 ID？

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

• loss (tf.Tensor，形状为(n,), optional, 当提供labels时返回，其中 n 是非掩码标签的数量) — 语言建模损失（用于下一个标记预测）。
• logits (tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states (tuple(tf.Tensor), optional, 当传递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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = TFHubertForCTC.from_pretrained("facebook/hubert-large-ls960-ft")

>>> 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 the transcription as text to encode labels
>>> labels = processor(text=transcription, return_tensors="tf").input_values

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

M-CTC-T

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

该模型目前仅处于维护模式，因此我们不会接受任何更改其代码的新 PR。

如果您在运行此模型时遇到任何问题，请重新安装支持此模型的最后一个版本：v4.30.0。您可以通过运行以下命令来执行：pip install -U transformers==4.30.0。

概述

M-CTC-T 模型是由 Loren Lugosch、Tatiana Likhomanenko、Gabriel Synnaeve 和 Ronan Collobert 在Pseudo-Labeling For Massively Multilingual Speech Recognition中提出的。该模型是一个 10 亿参数的 Transformer 编码器，具有 8065 个字符标签的 CTC 头部和 60 个语言 ID 标签的语言识别头部。它在 Common Voice（版本 6.1，2020 年 12 月发布）和 VoxPopuli 上进行训练。在对 Common Voice 和 VoxPopuli 进行训练后，该模型仅在 Common Voice 上进行训练。标签是未归一化的字符级转录（标点符号和大写字母未删除）。该模型接受来自 16KHz 音频信号的 Mel 滤波器特征作为输入。

论文摘要如下：

通过伪标记进行半监督学习已成为最先进的单语音识别系统的基本技术。在这项工作中，我们将伪标记扩展到包含 60 种语言的大规模多语音识别。我们提出了一个简单的伪标记配方，即使在资源稀缺的语言中也能很好地工作：训练一个监督的多语言模型，用半监督学习在目标语言上微调它，为该语言生成伪标签，并使用所有语言的伪标签训练最终模型，可以从头开始或通过微调。在标记的 Common Voice 和未标记的 VoxPopuli 数据集上的实验表明，我们的配方可以产生性能更好的模型，对许多语言也具有良好的迁移性能，可以转移到 LibriSpeech。

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

使用提示

此模型的 PyTorch 版本仅在 torch 1.9 及更高版本中可用。

资源

• 自动语音识别任务指南

MCTCTConfig

class transformers.MCTCTConfig

<来源>

( vocab_size = 8065 hidden_size = 1536 num_hidden_layers = 36 intermediate_size = 6144 num_attention_heads = 4 attention_head_dim = 384 max_position_embeddings = 920 layer_norm_eps = 1e-05 layerdrop = 0.3 hidden_act = 'relu' initializer_range = 0.02 hidden_dropout_prob = 0.3 attention_probs_dropout_prob = 0.3 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 conv_glu_dim = 1 conv_dropout = 0.3 num_conv_layers = 1 conv_kernel = (7,) conv_stride = (3,) input_feat_per_channel = 80 input_channels = 1 conv_channels = None ctc_loss_reduction = 'sum' ctc_zero_infinity = False **kwargs )

参数

• vocab_size (int, optional, 默认为 8065) — M-CTC-T 模型的词汇量。定义了在调用 MCTCTModel 时可以由inputs_ids表示的不同标记数量。
• hidden_size (int, optional, 默认为 1536) — 编码器层和池化器层的维度。
• num_hidden_layers (int, optional, 默认为 36) — Transformer 编码器中的隐藏层数量。
• intermediate_size (int, optional, 默认为 6144) — Transformer 编码器中“中间”（即前馈）层的维度。
• num_attention_heads (int, optional, 默认为 4) — Transformer 编码器中每个注意力层的注意力头数量。
• attention_head_dim (int, optional, 默认为 384) — Transformer 编码器中每个注意力层的每个注意力头的维度。
• max_position_embeddings (int, optional, 默认为 920) — 该模型可能会与之一起使用的最大序列长度（在对数梅尔频谱提取之后）。
• layer_norm_eps (float, optional, 默认为 1e-05) — 层归一化层使用的 epsilon 值。
• layerdrop (float, optional, 默认为 0.3) — 训练过程中丢弃编码器层的概率。默认值 0.3 在原始实现中使用。
• hidden_act (str or function, optional, defaults to "relu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• hidden_dropout_prob (float, optional, defaults to 0.3) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。
• attention_probs_dropout_prob (float, optional, defaults to 0.3) — 注意力概率的丢失比例。
• pad_token_id (int, optional, defaults to 1) — 填充标记的分词器索引。
• bos_token_id (int, optional, defaults to 0) — bos 标记的分词器索引。
• eos_token_id (int, optional, defaults to 2) — eos 标记的分词器索引。
• conv_glu_dim (int, optional, defaults to 1) — 在应用 GLU 的Conv1dSubsampler层的输出维度。尽管原始的 Flashlight 代码使用值为 2，但这里由于转置差异，将其调整为 1。
• conv_dropout (int, optional, defaults to 0.3) — 训练期间随机丢弃Conv1dSubsampler层的概率。
• num_conv_layers (int, optional, defaults to 1) — 在应用变换器编码器层之前的卷积层数。
• conv_kernel (Sequence[int], optional, defaults to (7,)) — 在变换器层之前应用的 1D 卷积的内核大小。conv_kernel的长度必须等于num_conv_layers。
• conv_stride (Sequence[int], optional, defaults to (3,)) — 在变换器层之前应用的 1D 卷积的步长长度。conv_stride的长度必须等于num_conv_layers。
• input_feat_per_channel (int, optional, defaults to 80) — 输入到 Conv1D 层通道的特征维度。
• input_channels (int, optional, defaults to 1) — 输入到 Conv1D 层的输入通道数。
• conv_channels (List[int], optional) — 中间 Conv1D 层的通道大小。
• ctc_loss_reduction (str, optional, defaults to "sum") — 指定应用于torch.nn.CTCLoss输出的减少方式。仅在训练 MCTCTForCTC 实例时相关。
• ctc_zero_infinity (bool, optional, defaults to False) — 是否将torch.nn.CTCLoss的无限损失和相关梯度归零。当输入太短无法与目标对齐时，主要会出现无限损失。仅在训练 MCTCTForCTC 实例时相关。

这是用于存储 MCTCTModel 配置的配置类。根据指定的参数实例化一个 M-CTC-T 模型，定义模型架构。使用默认值实例化配置将产生类似于 M-CTC-T speechbrain/m-ctc-t-large架构的配置。

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

示例：

>>> from transformers import MCTCTConfig, MCTCTModel

>>> # Initializing a M-CTC-T mctct-large style configuration
>>> configuration = MCTCTConfig()

>>> # Initializing a model (with random weights) from the mctct-large style configuration
>>> model = MCTCTModel(configuration)

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

MCTCTFeatureExtractor

class transformers.MCTCTFeatureExtractor

< source >

( feature_size = 80 sampling_rate = 16000 padding_value = 0.0 hop_length = 10 win_length = 25 win_function = 'hamming_window' frame_signal_scale = 32768.0 preemphasis_coeff = 0.97 mel_floor = 1.0 normalize_means = True normalize_vars = True return_attention_mask = False **kwargs )

参数

• feature_size (int, defaults to 80) — 提取特征的特征维度。这是梅尔频率的数量
• sampling_rate（int，默认为 16000）— 音频文件应数字化的采样率，以赫兹（Hz）表示。
• padding_value（float，默认为 0.0）— 用于填充值的值。
• hop_length（int，默认为 10）— 窗口之间的音频样本数。在许多论文中也称为“shift”。
• win_length（int，默认为 25）— 每个窗口的毫秒数。
• win_function（str，默认为 "hamming_window"）— 用于窗口化的窗口函数的名称，必须可以通过 torch.{win_function} 访问。
• frame_signal_scale（float，默认为 32768.0）— 在应用 DFT 之前创建帧时乘以的常数。
• preemphasis_coeff（float，默认为 0.97）— 在应用 DFT 之前乘以的常数。
• mel_floor（float，默认为 1.0）— Mel 频率组的最小值。
• normalize_means（bool，可选，默认为 True）— 是否对提取的特征进行零均值归一化。
• normalize_vars（bool，可选，默认为 True）— 是否对提取的特征进行单位方差归一化。

构建 M-CTC-T 特征提取器。

此特征提取器继承自 SequenceFeatureExtractor，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。此代码已从 Flashlight 的 C++ 代码进行了调整。有关实现的更多信息，用户可以参考这个 笔记本，该笔记本逐步引导用户进行实现。

__call__

<来源>

( 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（torch.Tensor，np.ndarray，List[float]，List[torch.Tensor]，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 的 TPUs。
• return_attention_mask（bool，可选）— 是否返回注意力掩码。如果保持默认设置，将根据特定 feature_extractor 的默认设置返回注意力掩码。 什么是注意力掩码？
• 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) —

对一个或多个序列进行特征化和准备模型的主要方法。它返回输入音频的对数梅尔频谱图，这是在原始 Flashlight MFSC 特征提取代码中实现的。

MCTCTProcessor

class transformers.MCTCTProcessor

< source >

( feature_extractor tokenizer )

参数

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

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

MCTCTProcessor 提供了 MCTCTFeatureExtractor 和 AutoTokenizer 的所有功能。查看 call() 和 decode() 获取更多信息。

__call__

< source >

( *args **kwargs )

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

from_pretrained

< source >

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

参数

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

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

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

save_pretrained

<来源>

( save_directory push_to_hub: bool = False **kwargs )

参数

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

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

此类方法只是调用 save_pretrained()和 save_pretrained()。请参考上述方法的文档字符串以获取更多信息。

batch_decode

<来源>

( *args **kwargs )

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

decode

<来源>

( *args **kwargs )

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

MCTCTModel

class transformers.MCTCTModel

<来源>

( config )

参数

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

M-CTC-T 模型变压器裸露输出原始隐藏状态，没有任何特定的头部。这个模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

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

参数

• input_features (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列令牌的索引。 可以使用 Wav2Vec2CTCTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 避免在填充令牌索引上执行注意力的掩码。掩码值在[0, 1]中选择：
  • 1 表示未被masked的令牌，
  • 0 表示被masked的令牌。

  什么是注意力掩码？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

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

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

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

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

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

示例：

>>> from transformers import AutoProcessor, MCTCTModel
>>> 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("speechbrain/m-ctc-t-large")
>>> model = MCTCTModel.from_pretrained("speechbrain/m-ctc-t-large")

>>> # 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]
[1, 195, 1536]

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

>>> # compute loss
>>> loss = model(**inputs).loss

MCTCTForCTC

class transformers.MCTCTForCTC

< source >

( config )

参数

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

使用带有顶部语言建模头的 MCTCT 模型，用于连接主义时间分类（CTC）。这个模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

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

参数

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

  什么是注意力掩码？

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

返回

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

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

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

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

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

示例：

>>> from transformers import AutoProcessor, MCTCTForCTC
>>> 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("speechbrain/m-ctc-t-large")
>>> model = MCTCTForCTC.from_pretrained("speechbrain/m-ctc-t-large")

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

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
"Mr. Quilter is the apostle of the middle classes, and we're 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)
1885.65