Hugging Face 的 logo

Transformers 文档

Hubert

Hugging Face's logo
加入Hugging Face社区

并获得增强型文档体验

开始使用

Hubert

概述

Hubert 在 HuBERT：通过隐藏单元的掩码预测进行自监督语音表示学习 中提出，作者为 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov 和 Abdelrahman Mohamed。

论文摘要如下：

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

此模型由 patrickvonplaten 贡献。

使用技巧

  • Hubert 是一种语音模型，它接受一个浮点数组，该数组对应于语音信号的原始波形。
  • Hubert 模型使用连接时序分类 (CTC) 进行微调，因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。

使用 Flash Attention 2

Flash Attention 2 是模型的一个更快、更优化的版本。

安装

首先，检查您的硬件是否与 Flash Attention 2 兼容。最新的兼容硬件列表可以在官方文档中找到。如果您的硬件与 Flash Attention 2 不兼容，您仍然可以通过 Better Transformer 支持（在上面介绍）获得注意力内核优化的益处。

接下来，安装最新版本的 Flash Attention 2

pip install -U flash-attn --no-build-isolation

使用

下面是比较 `facebook/hubert-large-ls960-ft` 在 transformers 中的原生实现、flash-attention-2 和 sdpa（scale-dot-product-attention）版本之间纯推理时间的预期加速图。我们展示了在 `librispeech_asr` `clean` 验证集上获得的平均加速。

>>> from transformers import Wav2Vec2Model

model = Wav2Vec2Model.from_pretrained("facebook/hubert-large-ls960-ft", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to(device)
...

预期加速

下面是比较 `facebook/hubert-large-ls960-ft` 模型在 transformers 中的原生实现、flash-attention-2 和 sdpa（scale-dot-product-attention）版本之间纯推理时间的预期加速图。。我们展示了在 `librispeech_asr` `clean` 验证集上获得的平均加速。

资源

HubertConfig

类 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 时传递的 inputs_ids 可以表示的不同标记的数量。模型的词汇量大小。定义了传递给 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"。
  • 隐藏层dropout (float, 可选，默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的dropout概率。
  • 激活层dropout (float, 可选，默认为 0.1) — 全连接层内部激活的dropout比率。
  • 注意力dropout (float, 可选，默认为 0.1) — 注意力概率的dropout比率。
  • 最终dropout (float, 可选，默认为 0.1) — Wav2Vec2ForCTC 的最终投影层的dropout概率。
  • 层dropout (float, 可选，默认为 0.1) — 层dropout概率。更多详情请参阅[层dropout论文](参见 https://arxiv.org/abs/1909.11556)。
  • 初始化范围 (float, 可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化的标准差。
  • 层归一化ε (float, 可选，默认为 1e-12) — 层归一化层使用的ε。
  • 特征提取归一化 (str, 可选，默认为 "group") — 应用于特征编码器中一维卷积层的归一化类型。"group" 表示仅对第一个一维卷积层进行组归一化，"layer" 表示对所有一维卷积层进行层归一化。
  • 特征投影dropout (float, 可选，默认为 0.0) — 特征编码器输出的dropout概率。
  • 特征投影层归一化 (bool, 可选，默认为 True) — 是否将层归一化应用于特征编码器的输出。
  • conv_dim (Tuple[int]，可选，默认为 (512, 512, 512, 512, 512, 512, 512)) — 定义特征编码器中每个一维卷积层的输入和输出通道数的整数元组。conv_dim的长度定义了一维卷积层的数量。
  • conv_stride (Tuple[int]，可选，默认为 (5, 2, 2, 2, 2, 2, 2)) — 定义特征编码器中每个一维卷积层的步长的整数元组。conv_stride的长度定义了卷积层的数量，并且必须与conv_dim的长度匹配。
  • conv_kernel (Tuple[int]，可选，默认为 (10, 3, 3, 3, 3, 3, 3)) — 定义特征编码器中每个一维卷积层的核大小的整数元组。conv_kernel的长度定义了卷积层的数量，并且必须与conv_dim的长度匹配。
  • conv_bias (bool，可选，默认为 False) — 一维卷积层是否具有偏置。
  • num_conv_pos_embeddings (int，可选，默认为 128) — 卷积位置嵌入的数量。定义了一维卷积位置嵌入层的核大小。
  • num_conv_pos_embedding_groups (int，可选，默认为 16) — 一维卷积位置嵌入层的分组数。
  • do_stable_layer_norm (bool，可选，默认为 False) — 是否应用Transformer编码器的“稳定”层归一化架构。do_stable_layer_norm 为 True对应于在注意力层之前应用层归一化，而do_stable_layer_norm 为 False对应于在注意力层之后应用层归一化。
  • apply_spec_augment (bool，可选，默认为 True) — 是否将SpecAugment数据增强应用于特征编码器的输出。参考SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。
  • mask_time_prob (float，可选，默认为 0.05) — 沿时间轴将被掩蔽的所有特征向量的百分比（介于 0 和 1 之间）。掩蔽过程在轴上生成“mask_time_problen(time_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选为要掩蔽的向量跨度的起始点的概率进行推理，则mask_time_prob 应为 `prob_vector_startmask_time_length`。请注意，重叠可能会降低实际掩蔽向量的百分比。这仅在apply_spec_augment 为 True时才相关。
  • mask_time_length (int，可选，默认为 10) — 沿时间轴的向量跨度的长度。
  • mask_time_min_masks (int，可选，默认为 2)， — 沿时间轴生成的长度为mask_feature_length的掩码的最小数量，每个时间步，与mask_feature_prob无关。仅当“mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”时才相关
  • mask_feature_prob (float，可选，默认为 0.0) — 沿特征轴将被掩盖的所有特征向量的百分比（介于 0 和 1 之间）。掩盖过程在轴上生成“mask_feature_problen(feature_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选为要掩盖的向量跨度的起点的概率进行推理，则mask_feature_prob应为`prob_vector_startmask_feature_length`。请注意，重叠可能会降低实际被掩盖的向量的百分比。仅当apply_spec_augment is True时才相关。
  • mask_feature_length (int，可选，默认为 10) — 沿特征轴的向量跨度的长度。
  • mask_feature_min_masks (int，可选，默认为 0)， — 沿特征轴生成的长度为mask_feature_length的掩码的最小数量，每个时间步，与mask_feature_prob无关。仅当“mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”时才相关
  • ctc_loss_reduction (str，可选，默认为 "sum") — 指定应用于torch.nn.CTCLoss输出的缩减。仅当训练HubertForCTC的实例时才相关。
  • ctc_zero_infinity (bool，可选，默认为 False) — 是否将torch.nn.CTCLoss的无限损失及其相关梯度归零。当输入过短而无法与目标对齐时，主要会出现无限损失。仅当训练HubertForCTC的实例时才相关。
  • use_weighted_layer_sum (bool，可选，默认为 False) — 是否使用具有学习权重的层输出的加权平均值。仅当使用HubertForSequenceClassification的实例时才相关。
  • classifier_proj_size (int，可选，默认为 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
Pytorch
隐藏 Pytorch 内容

HubertModel

类 transformers.HubertModel

<

( config: HubertConfig )

参数

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

Hubert 模型的裸露 Transformer，输出原始隐藏状态，没有任何特定的头部。Hubert 在 HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units 中被提出，作者为 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov 和 Abdelrahman Mohamed。

此模型继承自 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 ) → transformers.modeling_outputs.BaseModelOutput 或 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 的模型，例如 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 时返回) — torch.FloatTensor 的元组（一个用于嵌入的输出，如果模型具有嵌入层，以及一个用于每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

HubertModel 的 forward 方法覆盖了 __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

类 transformers.HubertForCTC

< >

( config target_lang: Optional = None )

参数

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

带有连接时序分类（CTC）语言建模头的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中提出。

此模型继承自 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 ) → transformers.modeling_outputs.CausalLMOutput 或 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 的模型，例如 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, 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) 和输入而变化的各种元素。

  • loss (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 时返回) — torch.FloatTensor 的元组（一个用于嵌入的输出，如果模型具有嵌入层，以及一个用于每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

The 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", trust_remote_code=True)
>>> 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

类 transformers.HubertForSequenceClassification

< >

( config )

参数

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

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

Hubert 在 HuBERT：通过隐藏单元的掩码预测进行自监督语音表示学习 中提出，作者为 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov 和 Abdelrahman Mohamed。

此模型继承自 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 ) → transformers.modeling_outputs.SequenceClassifierOutput 或 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 的模型，例如 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 时返回) — torch.FloatTensor 的元组（一个用于嵌入的输出，如果模型具有嵌入层，以及一个用于每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。

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

    注意力 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", trust_remote_code=True)
>>> 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
TensorFlow
隐藏 TensorFlow 内容

TFHubertModel

类 transformers.TFHubertModel

< >

( config: HubertConfig *inputs **kwargs )

参数

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

不带任何特定头部输出原始隐藏状态的基本 TFHubert 模型转换器。

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

此模型也是keras.Model 的子类。将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解与一般用法和行为相关的所有事项。

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

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

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

调用

 < >

( 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 ) → transformers.modeling_tf_outputs.TFBaseModelOutput 或 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 表示未掩码的标记，
    • 0 表示已掩码的标记。

    什么是注意力掩码？

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

    • 0 对应于句子 A 标记，
    • 1 对应于句子 B 标记。

    什么是标记类型 ID？

  • position_ids (np.ndarray 或 tf.Tensor 形状为 ({0})，可选) — 输入序列中每个标记在位置嵌入中的位置索引。选择范围在 [0, config.max_position_embeddings - 1] 内。

    什么是位置 ID？

  • head_mask (np.ndarray 或 tf.Tensor 形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：

    • 1 表示头部未掩码，
    • 0 表示头部已掩码。
  • inputs_embeds (np.ndarray 或 tf.Tensor 形状为 ({0}, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_values。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_values 索引转换为关联的向量，这将非常有用。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。此参数仅可在急切模式下使用，在图模式下，将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下，其值始终设置为 True。
  • training (bool, 可选，默认为 `False`) — 是否以训练模式使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。

返回值

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

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

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

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

    模型在每一层输出处的隐藏状态加上初始嵌入输出。

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

    注意力 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

类 transformers.TFHubertForCTC

< >

( config: HubertConfig *inputs **kwargs )

参数

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

带有用于连接时序分类 (CTC) 的 语言建模 头的 TFHubert 模型。

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

此模型也是keras.Model 的子类。将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解与一般用法和行为相关的所有事项。

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

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

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

调用

< >

( 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 ) → transformers.modeling_tf_outputs.TFCausalLMOutput 或 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 表示未掩盖的标记，
    • 0 表示掩盖的标记。

    什么是注意力掩码？

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

    • 0 对应于 句子 A token，
    • 1 对应于 句子 B token。

    什么是 token 类型 ID？

  • position_ids (np.ndarray 或 tf.Tensor 形状为 ({0})，可选) — 位置嵌入中每个输入序列 token 的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。

    什么是位置 ID？

  • head_mask (np.ndarray 或 tf.Tensor 形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选定的 head 失效的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示 head 未被掩码，
    • 0 表示 head 被掩码。
  • inputs_embeds (np.ndarray 或 tf.Tensor 形状为 ({0}, hidden_size)，可选) — 可选地，而不是传递 input_values，您可以选择直接传递嵌入表示。如果您希望对如何将 input_values 索引转换为关联向量进行比模型内部嵌入查找矩阵更多的控制，这将非常有用。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。此参数仅可在急切模式下使用，在图形模式下，将使用配置中的值。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。此参数仅可在急切模式下使用，在图形模式下，将使用配置中的值。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图形模式下，值将始终设置为 True。
  • training (bool，可选，默认为 `False`) — 是否以训练模式使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
  • labels (tf.Tensor 或 np.ndarray 形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中（参见 input_values 文档字符串）索引设置为 -100 的 token 将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的 token 计算

返回值

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,)，可选，其中 n 是非掩码标签的数量，在提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。

  • logits (tf.Tensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇 token 的分数）。

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

    模型在每一层输出处的隐藏状态加上初始嵌入输出。

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

    注意力 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
< > 在 GitHub 上更新

←Hiera MCTCT→