Transformers documentation
Wav2Vec2
该模型于 2020-06-20 在 HF papers 上发布，并于 2021-02-02 贡献给 Hugging Face Transformers。
Wav2Vec2
概述
Wav2Vec2 模型由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed 和 Michael Auli 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中提出。
该论文的摘要如下：
我们首次证明，仅从语音音频中学习强大的表示，随后在转录语音上进行微调，可以在概念上更简单的情况下，超越最佳的半监督方法。wav2vec 2.0 在潜在空间中掩蔽语音输入，并解决一个在潜在表示的量化上定义的对比任务，这些潜在表示是联合学习的。使用 Librispeech 的所有标注数据进行的实验，在 clean/other 测试集上分别实现了 1.8/3.3 的 WER。当将标注数据量降低到一小时时，wav2vec 2.0 在 100 小时子集上超越了之前的最先进水平，同时使用的标注数据减少了 100 倍。仅使用十分钟的标注数据，并在 53k 小时的无标注数据上进行预训练，仍然可以实现 4.8/8.2 的 WER。这证明了在有限标注数据量下进行语音识别的可行性。
该模型由 patrickvonplaten 贡献。
注意：Meta（FAIR）发布了 Wav2Vec2-BERT 2.0 的新版本——它在 450 万小时的音频上进行了预训练。我们特别推荐将其用于微调任务，例如按照此指南进行操作。
在 from_pretrained() 中设置
use_kernels=True，即可用 Hub 上的优化内核替换受支持的层。有关详细信息，请参阅 加载内核。
使用技巧
- Wav2Vec2 是一种语音模型，它接受一个浮点数数组，该数组对应于语音信号的原始波形。
- Wav2Vec2 模型使用连接时序分类（CTC）进行训练，因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。
使用 Flash Attention 2
Flash Attention 2 是该模型的更快、经过优化的版本。
安装
首先，检查您的硬件是否与 Flash Attention 2 兼容。最新的兼容硬件列表可在官方文档中查阅。
接下来，安装 Flash Attention 2 的最新版本：
pip install -U flash-attn --no-build-isolation
用法
要使用 Flash Attention 2 加载模型，我们可以将参数 attn_implementation="flash_attention_2" 传递给 from_pretrained()。我们还会以半精度（例如 torch.float16）加载模型，因为这样做几乎不会降低音频质量，但能显著降低内存占用并加快推理速度：
from transformers import Wav2Vec2Model
model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-large-960h-lv60-self", attn_implementation="flash_attention_2", device_map="auto")
...预期加速
下图展示了 facebook/wav2vec2-large-960h-lv60-self 模型在 librispeech_asr clean 验证集上，transformers 原生实现与 flash-attention-2 及 sdpa（scale-dot-product-attention）版本之间纯推理时间的预期加速比。我们展示的是在该验证集上获得的平均加速比：
资源
以下是 Hugging Face 官方和社区（以 🌎 标识）提供的资源列表，可帮助您快速上手 Wav2Vec2。如果您希望提交资源以收录在此处，欢迎随时发起 Pull Request，我们将进行审核！理想情况下，该资源应展示一些新内容，而非重复现有资源。
- 一个关于如何利用预训练的 Wav2Vec2 模型进行情感分类的笔记本。🌎
- Wav2Vec2ForCTC 受此 notebook 支持。
- 音频分类任务指南
- 一篇关于在 🤗 Transformers 中使用 n-gram 提升 Wav2Vec2 性能的博客文章。
- 一篇关于如何使用 🤗 Transformers 微调 Wav2Vec2 以进行英语 ASR 的博文。
- 一篇关于使用 🤗 Transformers 对 XLS-R 进行多语言 ASR 微调 的博文。
- 一个关于如何使用 Wav2Vec2 转录音频，从而为任意视频创建 YouTube 字幕的笔记本。🌎
- Wav2Vec2ForCTC 由以下两个笔记本提供支持：如何微调英语语音识别模型，以及 如何微调任意语言的语音识别模型。
- 自动语音识别任务指南
🚀 部署
- 一篇博客文章，介绍如何使用 Hugging Face 的 Transformers 和 Amazon SageMaker 部署 Wav2Vec2 进行自动语音识别。
Wav2Vec2Config
class transformers.Wav2Vec2Config
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int | None = 32hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1feat_proj_dropout: float | int = 0.0feat_quantizer_dropout: float | int = 0.0final_dropout: float | int = 0.1layerdrop: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05feat_extract_norm: str = 'group'feat_extract_activation: str = 'gelu'conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)conv_bias: bool = Falsenum_conv_pos_embeddings: int = 128num_conv_pos_embedding_groups: int = 16do_stable_layer_norm: bool = Falseapply_spec_augment: bool = Truemask_time_prob: float | int = 0.05mask_time_length: int = 10mask_time_min_masks: int = 2mask_feature_prob: float | int = 0.0mask_feature_length: int = 10mask_feature_min_masks: int = 0num_codevectors_per_group: int = 320num_codevector_groups: int = 2contrastive_logits_temperature: float = 0.1num_negatives: int = 100codevector_dim: int = 256proj_codevector_dim: int = 256diversity_loss_weight: float = 0.1ctc_loss_reduction: str = 'sum'ctc_zero_infinity: bool = Falseuse_weighted_layer_sum: bool = Falseclassifier_proj_size: int = 256tdnn_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 1500)tdnn_kernel: list[int] | tuple[int, ...] = (5, 3, 3, 1, 1)tdnn_dilation: list[int] | tuple[int, ...] = (1, 2, 3, 1, 1)xvector_output_dim: int = 512pad_token_id: int | None = 0bos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2add_adapter: bool = Falseadapter_kernel_size: int = 3adapter_stride: int = 2num_adapter_layers: int = 3output_hidden_size: int | None = Noneadapter_attn_dim: int | None = None )
参数
- vocab_size (
int，可选，默认为32) — 模型的词汇表大小。定义了input_ids可以表示的不同 token 数量。 - hidden_size (
int，可选，默认为768) — 隐藏表示的维度。 - num_hidden_layers (
int, 可选, 默认为12) — Transformer 解码器中的隐藏层数量。 - num_attention_heads (
int，可选，默认为12) — Transformer 解码器中每个注意力层的注意力头数量。 - intermediate_size (
int，可选，默认为3072) — MLP 表示的维度。 - hidden_act (
str，可选，默认为gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - hidden_dropout (
Union[float, int]，可选，默认为0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。 - activation_dropout (
Union[float, int]，可选，默认为0.1) — 全连接层内部激活值的 dropout 比率。 - attention_dropout (
Union[float, int]，可选，默认为0.1) — 注意力概率的 dropout 比率。 - feat_proj_dropout (
float, 可选，默认值为 0.0) — 特征编码器输出的 dropout 概率。 - feat_quantizer_dropout (
float, 可选，默认值为 0.0) — 用于量化器的特征编码器输出的 dropout 概率。 - final_dropout (
float，可选，默认值为 0.1) — Wav2Vec2ForCTC 最终投影层的 dropout 概率。 - layerdrop (
Union[float, int]，可选，默认为0.1) — LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](参见 https://huggingface.co/papers/1909.11556)。 - initializer_range (
float，可选，默认为0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float，可选，默认为1e-05) — 层归一化层所使用的 epsilon 值。 - feat_extract_norm (
str，可选，默认为"group") — 应用于特征编码器中一维卷积层的归一化方式。取值为"group"，表示仅对第一个一维卷积层应用组归一化；或取值为"layer"，表示对所有的一维卷积层应用层归一化。 - feat_extract_activation (
str,optional, defaults to“gelu”) -- The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string,“gelu”,“relu”,“selu”and“gelu_new”` are supported. - conv_dim (
tuple[int]或list[int]，可选，默认为(512, 512, 512, 512, 512, 512, 512)) — 一个整数元组，用于定义特征编码器中每个一维卷积层的输入和输出通道数。conv_dim 的长度决定了一维卷积层的数量。 - conv_stride (
tuple[int]或list[int]，可选，默认为(5, 2, 2, 2, 2, 2, 2)) — 一个整数元组，用于定义特征编码器中每个一维卷积层的步长。conv_stride 的长度定义了卷积层的数量，并且必须与 conv_dim 的长度相匹配。 - conv_kernel (
tuple[int]或list[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 is True表示在注意力层之前应用层归一化，而do_stable_layer_norm is False表示在注意力层之后应用层归一化。 - apply_spec_augment (
bool，可选，默认为True) — 是否对特征编码器的输出应用 SpecAugment 数据增强。参考 SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。 - mask_time_prob (
float, optional, defaults to 0.05) — Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking procedure generates ”mask_time_problen(time_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_time_prob should be `prob_vector_startmask_time_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant ifapply_spec_augment is 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, optional, defaults to 0.0) — Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The masking procedure generates ”mask_feature_problen(feature_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_feature_prob should be `prob_vector_startmask_feature_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant ifapply_spec_augment is True`. - mask_feature_prob (
Union[float, int]，可选，默认值为0.0) — 沿特征轴被掩码的所有特征向量的百分比（介于 0 和 1 之间）。掩码过程会在该轴上生成mask_feature_prob*len(feature_axis)/mask_time_length个独立的掩码。如果从每个特征向量被选为待掩码向量跨度起点的概率来推导，mask_feature_prob 应为prob_vector_start*mask_feature_length。请注意，重叠可能会降低实际被掩码的向量百分比。仅当apply_spec_augment为True时，此参数才相关。 - mask_feature_length (
int，可选，默认为 10) — 沿特征轴方向的向量跨度长度。 - mask_feature_min_masks (
int，可选，默认为 0)，— 沿特征轴生成的、长度为mask_feature_length的掩码的最小数量，每个时间步均适用，与mask_feature_prob无关。仅当 “mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks” 时相关。 - num_codevectors_per_group (
int，可选，默认值为 320) — 每个量化码本（组）中的条目数量。 - num_codevectors_per_group (
int，可选，默认值为 320) — 每个量化码本（组）中的条目数量。 - num_codevector_groups (
int, 可选，默认为 2) — 乘积码向量量化（product codevector quantization）的码向量组数。 - contrastive_logits_temperature (
float，可选，默认值为 0.1) — 对比损失中的温度 kappa。 - num_negatives (
int，可选，默认为 100) — 用于对比损失的负样本数量。 - codevector_dim (
int，可选，默认为 256) — 量化特征向量的维度。 - proj_codevector_dim (
int，可选，默认为 256) — 量化特征和 Transformer 特征最终投影的维度。 - diversity_loss_weight (
int, 可选，默认为 0.1) — 码本多样性损失项的权重。 - ctc_loss_reduction (
str，可选，默认为"sum") — 指定应用于torch.nn.CTCLoss输出的归约方式。仅在训练 Wav2Vec2ForCTC 实例时相关。 - ctc_zero_infinity (
bool，可选，默认为False) — 是否将torch.nn.CTCLoss的无穷大损失及其相关梯度置零。无穷大损失主要出现在输入过短、无法与目标对齐的情况下。仅在训练 Wav2Vec2ForCTC 实例时相关。 - use_weighted_layer_sum (
bool，可选，默认为False) — 是否使用带学习权重的层输出加权平均。仅在使用 Wav2Vec2ForSequenceClassification 实例时相关。 - classifier_proj_size (
int，可选，默认为 256) — 用于分类的 token 平均池化之前投影的维度。 - tdnn_dim (
tuple[int]或list[int]，可选，默认为(512, 512, 512, 512, 1500)) — 一个整数元组，用于定义 XVector 模型中 TDNN 模块内每个一维卷积层的输出通道数。tdnn_dim 的长度决定了 TDNN 层的数量。 - tdnn_kernel (
tuple[int]或list[int]，可选，默认为(5, 3, 3, 1, 1)) — 一个整数元组，用于定义 XVector 模型中 TDNN 模块内每个一维卷积层的核大小。tdnn_kernel 的长度必须与 tdnn_dim 的长度相匹配。 - tdnn_dilation (
tuple[int]或list[int]，可选，默认为(1, 2, 3, 1, 1)) — 一个整数元组，用于定义 XVector 模型中 TDNN 模块内每个一维卷积层的膨胀因子。tdnn_dilation 的长度必须与 tdnn_dim 的长度相匹配。 - xvector_output_dim (
int，可选，默认值为 512) — XVector 嵌入向量的维度。 - pad_token_id (
int, 可选，默认为0) — 词表中用于填充的 token id。 - bos_token_id (
int，可选，默认为1) — 词汇表中用于表示流起始的 token id。 - eos_token_id (
Union[int, list[int]]，可选，默认为2) — 词汇表中用于表示流结束（end-of-stream）的 token id。 - add_adapter (
bool，可选，默认为False) — 是否应在 Wav2Vec2 Encoder 之上堆叠一个卷积网络。对于为 SpeechEncoderDecoder 模型预热启动 Wav2Vec2 非常有用。 - adapter_kernel_size (
int，可选，默认为 3) — 适配器网络中卷积层的卷积核大小。仅当add_adapter is True时相关。 - adapter_stride (
int，可选，默认为 2) — 适配器网络中卷积层的步长。仅在add_adapter is True时相关。 - num_adapter_layers (
int，可选，默认为 3) — 适配器网络中应使用的卷积层数量。仅在add_adapter is True时相关。 - output_hidden_size (
int, 可选) — 编码器输出层的维度。如果未定义，则默认为 hidden-size。仅在add_adapter is True时相关。 - adapter_attn_dim (
int, 可选) — 每个注意力块中使用的注意力适配器权重的维度。使用注意力适配器的模型示例为 facebook/mms-1b-all。
这是用于存储 Wav2Vec2Model 配置的类。它根据指定的参数实例化 Wav2Vec2 模型，并定义模型架构。使用默认值实例化配置将得到与 facebook/wav2vec2-base-960h 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> from transformers import Wav2Vec2Config, Wav2Vec2Model
>>> # Initializing a Wav2Vec2 facebook/wav2vec2-base-960h style configuration
>>> configuration = Wav2Vec2Config()
>>> # Initializing a model (with random weights) from the facebook/wav2vec2-base-960h style configuration
>>> model = Wav2Vec2Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configWav2Vec2CTCTokenizer
class transformers.Wav2Vec2CTCTokenizer
< source >( vocab_filebos_token = '<s>'eos_token = '</s>'unk_token = '<unk>'pad_token = '<pad>'word_delimiter_token = '|'replace_word_delimiter_char = ' 'do_lower_case = Falsetarget_lang = None**kwargs )
参数
- vocab_file (
str) — 包含词汇表的文件。 - bos_token (
str，可选，默认为"<s>") — 句子起始标记。 - eos_token (
str，可选，默认为"</s>") — 句子结束标记。 - unk_token (
str，可选，默认为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，因此会被设置为该标记。 - pad_token (
str，可选，默认为"<pad>") — 用于填充的标记，例如在对长度不同的序列进行批处理时。 - word_delimiter_token (
str，可选，默认为"|") — 用于定义单词结束位置的标记。 - do_lower_case (
bool，可选，默认为False) — 是否接受小写输入，并在解码时将输出转换为小写。 - target_lang（
str，可选）— 分词器应默认设置的目标语言。对于 facebook/mms-1b-all 等多语言嵌套词汇表，必须定义target_lang。 - **kwargs — 传递给 PreTrainedTokenizer 的额外关键字参数
构建一个 Wav2Vec2CTC 分词器。
该分词器继承自 PreTrainedTokenizer，其中包含一些主要方法。有关这些方法的更多信息，请参阅其父类。
__call__
< source >( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**kwargs ) → BatchEncoding
参数
- text (
str、list[str]、list[list[str]]、可选) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果以字符串列表（预分词）形式提供序列，则必须设置is_split_into_words=True（以消除与序列批次的歧义）。 - text_pair (
str、list[str]、list[list[str]]、可选) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果以字符串列表（预分词）形式提供序列，则必须设置is_split_into_words=True（以消除与序列批次的歧义）。 - text_target (
str、list[str]、list[list[str]]、可选) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果以字符串列表（预分词）的形式提供序列，则必须设置is_split_into_words=True（以消除与序列批次的歧义）。 - text_pair_target (
str、list[str]、list[list[str]]、可选) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）的形式提供，则必须设置is_split_into_words=True（以消除与序列批次的歧义）。 - tokenizer_kwargs (
dict[str, Any], 可选) — 传递给 tokenizer 的额外 kwargs。这些 kwargs 将与显式参数及其他 kwargs 合并，其中显式参数具有更高的优先级。 - add_special_tokens (
bool，可选，默认为True) — 在编码序列时是否添加特殊标记。此操作将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了哪些标记会自动添加到输入 ID 中。如果您希望自动添加bos或eos标记，此功能非常有用。 - padding (
bool,str或 PaddingStrategy, ，可选, ，默认为False) — 启用并控制填充。接受以下值：True或'longest'：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。'max_length'：填充至由参数max_length指定的最大长度；若未提供该参数，则填充至模型可接受的最大输入长度。False或'do_not_pad'（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, ，可选, ，默认为False) — 启用并控制截断。接受以下值：True或'longest_first'：截断至由参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一批序列对），则会从该对中最长的序列中移除一个 token。'only_first'：截断至由参数max_length指定的最大长度，或者在未提供该参数时，截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断其中的第一个序列。'only_second'：截断至由参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。仅当提供了一对序列（或一批序列对）时，才会截断其中的第二个序列。False或'do_not_truncate'（默认值）：不进行截断（即，可以输出序列长度大于模型最大可接受输入大小的批次）。
- max_length (
int, 可选) — 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 None，则当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（如 XLNet），则禁用截断/填充到最大长度的功能。如果未设置或设置为
None，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。 - stride (
int，可选，默认为 0) — 如果与max_length一起设置为某个数值，则当return_overflowing_tokens=True时，返回的溢出 token 将包含截断序列末尾的若干 token，以在截断序列和溢出序列之间提供一定的重叠。此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool，可选，默认为False) — 输入是否已经预先分词（例如，已拆分为单词）。如果设置为True，分词器将假设输入已经拆分为单词（例如，通过按空白字符拆分），然后对其进行分词。这对于命名实体识别（NER）或 token 分类非常有用。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充为所提供值的倍数。需要启用padding。 这对于在计算能力为>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。 - padding_side (
str, 可选) — 模型应应用填充的一侧。应在 [‘right’, ‘left’] 之间进行选择。 默认值取自同名的类属性。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- return_token_type_ids (
bool, 可选) — 是否返回 token type ID。如果保持默认值，将根据特定分词器的默认设置返回 token type ID，该设置由return_outputs属性定义。 - return_attention_mask (
bool, 可选) — 是否返回注意力掩码。如果保持默认值，将根据特定分词器的默认设置返回注意力掩码，该设置由return_outputs属性定义。 - return_overflowing_tokens (
bool，可选，默认为False) — 是否返回溢出的 token 序列。如果提供了输入 id 的序列对（或序列对批次），且truncation_strategy = longest_first或True，则会抛出错误，而不是返回溢出的 token。 - return_special_tokens_mask (
bool，可选，默认为False) — 是否返回特殊 token 掩码信息。 - return_offsets_mapping (
bool, 可选, 默认为False) — 是否返回(char_start, char_end)每个 token 的。此功能仅在继承自 PreTrainedTokenizerFast 的快速分词器上可用。如果使用 Python 分词器，此方法将抛出
NotImplementedError。 - return_length (
bool，可选，默认为False) — 是否返回编码后输入的长度。 - verbose (
bool，可选，默认为True) — 是否打印更多信息和警告。 - **kwargs — 传递给
self.tokenize()方法
返回值
一个包含以下字段的 BatchEncoding：
-
input_ids — 要输入模型的 token id 列表。
-
token_type_ids — 要输入模型的 token 类型 ID 列表（当
return_token_type_ids=True或self.model_input_names中包含 “token_type_ids” 时）。 -
attention_mask — 索引列表，指定模型应关注哪些 token（当
return_attention_mask=True或 “attention_mask” 位于self.model_input_names中时）。 -
overflowing_tokens — 溢出 token 序列的列表（当指定了
max_length且return_overflowing_tokens=True时）。 -
num_truncated_tokens — 被截断的 token 数量（当指定了
max_length且return_overflowing_tokens=True时）。 -
special_tokens_mask — 由 0 和 1 组成的列表，其中 1 表示添加的特殊标记，0 表示常规序列标记（当
add_special_tokens=True且return_special_tokens_mask=True时）。 -
length — 输入的长度（当
return_length=True时）
用于对一条或多条序列，或一对或多对序列进行分词并准备输入模型的主要方法。
decode
< source >( token_ids: typing.Union[int, list[int], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = Noneoutput_char_offsets: bool = Falseoutput_word_offsets: bool = False**kwargs ) → str or Wav2Vec2CTCTokenizerOutput
参数
- token_ids (
Union[int, list[int], np.ndarray, torch.Tensor]) — 分词后的输入 ID 列表。可通过__call__方法获取。 - skip_special_tokens（
bool，可选，默认为False）— 是否在解码过程中移除特殊标记。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理分词空格。 - output_char_offsets (
bool, 可选, 默认值为False) — 是否输出字符偏移量。字符偏移量可与采样率和模型降采样率结合使用，以计算转录字符的时间戳。请查看下面的示例，以更好地理解如何使用
output_char_offsets。 - output_word_offsets (
bool, 可选, 默认值为False) — 是否输出单词偏移量。单词偏移量可与采样率和模型降采样率结合使用，以计算转录单词的时间戳。请查看下面的示例，以更好地理解如何使用
output_word_offsets。 - kwargs（额外的关键字参数，可选） — 将传递给底层模型特定的解码方法。
返回值
str 或 Wav2Vec2CTCTokenizerOutput
解码后的句子列表。当 output_char_offsets == True 或 output_word_offsets == True 时，将是一个 Wav2Vec2CTCTokenizerOutput。
使用分词器和词汇表将字符串中的 id 序列进行转换，并可选择移除特殊标记以及清理分词空格。
类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。
示例：
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)
>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = feature_extractor(sample["audio"]["array"], return_tensors="pt").input_values
>>> logits = model(input_values).logits[0]
>>> pred_ids = torch.argmax(logits, axis=-1)
>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = tokenizer.decode(pred_ids, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / feature_extractor.sampling_rate
>>> word_offsets = [
... {
... "word": d["word"],
... "start_time": round(d["start_offset"] * time_offset, 2),
... "end_time": round(d["end_offset"] * time_offset, 2),
... }
... for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:3]
[{'word': 'THE', 'start_time': 0.7, 'end_time': 0.78}, {'word': 'TRICK', 'start_time': 0.88, 'end_time': 1.08}, {'word': 'APPEARS', 'start_time': 1.2, 'end_time': 1.64}]batch_decode
< source >( sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = Noneoutput_char_offsets: bool = Falseoutput_word_offsets: bool = False**kwargs ) → list[str] or Wav2Vec2CTCTokenizerOutput
参数
- sequences (
Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — 分词后的输入 ID 列表。可通过__call__方法获取。 - skip_special_tokens（
bool，可选，默认为False）— 是否在解码过程中移除特殊标记。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理分词空格。 - output_char_offsets (
bool, 可选, 默认值为False) — 是否输出字符偏移量。字符偏移量可与采样率和模型降采样率结合使用，以计算转录字符的时间戳。请查看 decode() 的示例，以更好地理解如何使用
output_char_offsets。batch_decode() 在处理批量输出时的工作方式相同。 - output_word_offsets (
bool, 可选, 默认为False) — 是否输出单词偏移量。单词偏移量可与采样率和模型降采样率结合使用，以计算转录单词的时间戳。请查看 decode() 的示例，以更好地理解如何使用
output_word_offsets。batch_decode() 在处理批量输出时的工作方式相同。 - kwargs（额外的关键字参数，可选） — 将传递给底层模型特定的解码方法。
返回值
list[str] 或 Wav2Vec2CTCTokenizerOutput
解码后的句子列表。当 output_char_offsets == True 或 output_word_offsets == True 时，将是一个 Wav2Vec2CTCTokenizerOutput。
通过调用 decode，将 token id 的列表的列表转换为字符串列表。
设置嵌套多语言字典的目标语言
Wav2Vec2FeatureExtractor
class transformers.Wav2Vec2FeatureExtractor
< source >( feature_size = 1sampling_rate = 16000padding_value = 0.0return_attention_mask = Falsedo_normalize = True**kwargs )
参数
- feature_size (
int，可选，默认为 1) — 提取特征的维度。 - sampling_rate (
int，可选，默认为 16000) — 音频文件应被数字化时的采样率，以赫兹 (Hz) 为单位。 - padding_value (
float，可选，默认为 0.0) — 用于填充 padding 值的数值。 - do_normalize (
bool，可选，默认为True) — 是否对输入进行零均值单位方差归一化。归一化可以显著提升某些模型的性能，例如 wav2vec2-lv60。 - return_attention_mask (
bool, 可选, 默认值为False) — 是否 调用() 应返回attention_mask.对于设置了
config.feat_extract_norm == "group"的 Wav2Vec2 模型（例如 wav2vec2-base），并未使用attention_mask进行训练。对于此类模型，input_values应直接用 0 进行填充，且不应传入attention_mask。对于已设置
config.feat_extract_norm == "layer"的 Wav2Vec2 模型（例如 wav2vec2-lv60），在进行批量推理时应传入attention_mask。
构建 Wav2Vec2 特征提取器。
该特征提取器继承自 SequenceFeatureExtractor，其中包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。
__call__
< source >( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]padding: bool | str | transformers.utils.generic.PaddingStrategy = Falsemax_length: int | None = Nonetruncation: bool = Falsepad_to_multiple_of: int | None = Nonereturn_attention_mask: bool | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = None**kwargs )
参数
- raw_speech (
np.ndarray、list[float]、list[np.ndarray]、list[list[float]]) — 需要填充的序列或序列批次。每个序列可以是 numpy 数组、浮点值列表、numpy 数组列表或浮点值列表的列表。必须是单声道音频，而非立体声，即每个时间步对应一个浮点数。 - padding (
bool,str或 PaddingStrategy, 可选, 默认为False) — 选择一种策略，根据模型的填充侧和填充索引对返回的序列进行填充，可选策略如下：True或'longest'：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。'max_length'：填充至由参数max_length指定的最大长度；若未提供该参数，则填充至模型可接受的最大输入长度。False或'do_not_pad'（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。
- max_length (
int，可选) — 返回列表的最大长度，以及可选的填充长度（见上文）。 - truncation (
bool) — 启用截断，将长度超过 max_length 的输入序列截断为 max_length。 - pad_to_multiple_of (
int, 可选) — 如果设置，将把序列填充为所提供值的倍数。这在启用 NVIDIA 硬件（计算能力
>= 7.5，即 Volta 架构）上的 Tensor Cores 使用时尤为有用，或者在 TPU 上使用时也特别有益，因为 TPU 在序列长度为 128 的倍数时性能更佳。 - return_attention_mask (
bool, 可选) — 是否返回注意力掩码。如果保持默认值，则会根据特定 feature_extractor 的默认设置返回注意力掩码。对于设置了
config.feat_extract_norm == "group"的 Wav2Vec2 模型，例如 wav2vec2-base，在训练过程中未使用attention_mask。对于此类模型，input_values应仅使用 0 进行填充，且不应传入attention_mask。对于已设置
config.feat_extract_norm == "layer"的 Wav2Vec2 模型，例如 wav2vec2-lv60，在进行批量推理时应传入attention_mask。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- sampling_rate (
int, 可选) —raw_speech输入所使用的采样率。强烈建议在 forward 调用时传入sampling_rate，以避免静默错误。 - padding_value（
float，可选，默认值为 0.0）—
用于对一条或多条序列进行特征化并准备输入模型的主要方法。
Wav2Vec2Processor
类 transformers.Wav2Vec2Processor
< source >( feature_extractortokenizer )
构建一个 Wav2Vec2Processor，将特征提取器和分词器封装为单一处理器。
Wav2Vec2Processor 提供了 Wav2Vec2FeatureExtractor 和 Wav2Vec2CTCTokenizer 的所有功能。有关更多信息，请参阅 ~Wav2Vec2FeatureExtractor 和 ~Wav2Vec2CTCTokenizer。
__call__
< source >( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | None = None**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> )
参数
- audio (
Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]], 可选) — 要准备处理的音频或音频批次。每个音频可以是 NumPy 数组或 PyTorch 张量。 如果为 NumPy 数组/PyTorch 张量，每个音频的形状应为 (C, T)，其中 C 为通道数，T 为音频的采样长度。 - text (
Union[str, list[str]]，可选) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果传入预分词输入，请设置is_split_into_words=True，以避免与批量输入产生歧义。 - return_mm_token_type_ids (
bool, kwargs) — 是否返回多模态 token 类型 id，用于指示多模态占位符 token 的位置。 - return_text_replacement_offsets (
bool, kwargs) — 是否返回每个多模态占位符及其替换内容的字符偏移量。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 NumPynp.ndarray对象。
- **kwargs (ProcessingKwargs，可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。
填充
< source >( *args**kwargs )
参数
- input_features —
当第一个参数是包含一批张量的字典，或者存在
input_features参数时，它会传递给 Wav2Vec2FeatureExtractor.pad()。 - labels —
当存在
label参数时，它会传递给 PreTrainedTokenizer.pad()。
此方法处理提取的特征批次和/或分词后的文本。它根据输入模态将所有参数转发给 Wav2Vec2FeatureExtractor.pad() 和/或 PreTrainedTokenizer.pad()，并返回它们的输出。如果同时传入两种模态，则会调用 Wav2Vec2FeatureExtractor.pad() 和 PreTrainedTokenizer.pad()。
from_pretrained
< source >( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )
参数
- pretrained_model_name_or_path (
str或os.PathLike) — 可以是以下之一：- 一个字符串，即托管在 huggingface.co 上某个模型仓库中的预训练 feature_extractor 的 model id。
- 指向一个目录的路径，该目录包含使用 save_pretrained() 方法保存的特征提取器文件，例如
./my_model_directory/。 - 指向已保存的特征提取器 JSON 文件的路径，例如
./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
< source >( save_directorypush_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()。有关更多信息，请参阅上述方法的文档字符串。
此方法会将其所有参数转发给 PreTrainedTokenizer 的 batch_decode()。有关更多信息，请参阅该方法的文档字符串。
此方法会将其所有参数转发给 PreTrainedTokenizer 的 decode()。有关更多信息，请参阅该方法的文档字符串。
Wav2Vec2ProcessorWithLM
Wav2Vec2ProcessorWithLM 以及基于 pyctcdecode + kenlm 的 n-gram 语言模型解码已被弃用，并将在 Transformers v6 中移除。它们依赖 pyctcdecode 和 kenlm，而这两个库不再随
transformers[audio]一起安装。如需保留语言模型解码功能，请直接调用 pyctcdecode，参见 迁移到 pyctcdecode。
类 transformers.Wav2Vec2ProcessorWithLM
< source >( feature_extractor: FeatureExtractionMixintokenizer: PreTrainedTokenizerBasedecoder: BeamSearchDecoderCTC )
构建一个 Wav2Vec2ProcessorWithLM，它将特征提取器和分词器封装为单个处理器。
Wav2Vec2ProcessorWithLM 提供了 feature_extractor_class 和 tokenizer_class 的所有功能。有关更多信息，请参阅 ~feature_extractor_class 和 ~tokenizer_class。
__call__
< source >( *args**kwargs )
参数
- return_tensors (
str或 TensorType, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 NumPynp.ndarray对象。
在普通模式下使用时，此方法会将其所有参数转发给特征提取器的 ~FeatureExtractionMixin.pad，并返回其输出。如果在 ~Wav2Vec2ProcessorWithLM.as_target_processor 上下文中使用，此方法会将其所有参数转发给 Wav2Vec2CTCTokenizer 的 pad()。有关更多信息，请参阅上述两个方法的文档字符串。
from_pretrained
< source >( pretrained_model_name_or_path**kwargs )
参数
- pretrained_model_name_or_path (
str或os.PathLike) — 可以是以下之一：- 一个字符串，即托管在 huggingface.co 上某个模型仓库中的预训练 feature_extractor 的 model id。
- 指向一个目录的路径，该目录包含使用 save_pretrained() 方法保存的特征提取器文件，例如
./my_model_directory/。 - 指向已保存的特征提取器 JSON 文件的路径，例如
./my_model_directory/preprocessor_config.json。
- **kwargs — 同时传递给 SequenceFeatureExtractor 和 PreTrainedTokenizer 的额外关键字参数
从预训练的 Wav2Vec2 处理器实例化一个 Wav2Vec2ProcessorWithLM。
This class method is simply calling the feature extractor’s from_pretrained(), Wav2Vec2CTCTokenizer’s from_pretrained(), and
pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub.有关更多信息，请参阅上述方法的文档字符串。
batch_decode
< source >( logits: ndarraypool: multiprocessing.pool.Pool | None = Nonenum_processes: int | None = Nonebeam_width: int | None = Nonebeam_prune_logp: float | None = Nonetoken_min_logp: float | None = Nonehotwords: collections.abc.Iterable[str] | None = Nonehotword_weight: float | None = Nonealpha: float | None = Nonebeta: float | None = Noneunk_score_offset: float | None = Nonelm_score_boundary: bool | None = Noneoutput_word_offsets: bool = Falsen_best: int = 1 )
参数
- logits (
np.ndarray) — 模型的 logits 输出向量，表示每个 token 的对数概率。 - pool (
multiprocessing.Pool, 可选) — 可选的用户管理池。如果未设置，将自动创建并关闭一个池。该池应在 之后Wav2Vec2ProcessorWithLM. 实例化。否则，LM 将无法在池的子进程中可用。目前，仅支持使用 'fork' 上下文创建的池。如果传入 'spawn' 池，它将被忽略，并改用顺序解码。目前，仅支持使用以 ‘fork’ 上下文创建的进程池。如果传入 ‘spawn’ 进程池，它将被忽略，并改用顺序解码。
- num_processes (
int，可选) — 如果未设置pool，则指定用于并行化该函数的进程数。默认值为可用 CPU 的数量。 - beam_width (
int, 可选) — 解码过程中每一步的最大 beam 数量。默认值为 pyctcdecode 的 DEFAULT_BEAM_WIDTH。 - beam_prune_logp (
int, 可选) — 远差于最佳 beam 的 beam 将被剪枝。默认值为 pyctcdecode 的 DEFAULT_PRUNE_LOGP。 - token_min_logp (
int, 可选) — 低于此 logp 的 token 将被跳过，除非它们是帧的 argmax。默认值为 pyctcdecode 的 DEFAULT_MIN_TOKEN_LOGP。 - hotwords (
list[str]，可选) — 具有额外重要性的单词列表，对于语言模型（LM）而言可以是未登录词（OOV） - hotword_weight (
int, 可选) — 热词重要性的权重因子。默认值为 pyctcdecode 的 DEFAULT_HOTWORD_WEIGHT。 - alpha (
float, 可选) — 浅层融合期间语言模型的权重 - beta (
float, 可选) — 评分过程中用于长度分数调整的权重 - unk_score_offset (
float, 可选) — 未知令牌的 log score 偏移量 - lm_score_boundary (
bool，可选) — kenlm 在评分时是否遵循边界 - output_word_offsets (
bool，可选，默认为False) — 是否输出单词偏移量。单词偏移量可与采样率和模型降采样率结合使用，以计算转录单词的时间戳。 - n_best (
int, 可选, ，默认为1) — 要返回的最佳假设数量。如果n_best大于 1，则返回的text将是字符串列表的列表，logit_score将是浮点数列表的列表，而lm_score也将是浮点数列表的列表，其中外层列表的长度对应于批次大小，内层列表的长度对应于返回的假设数量。该值应 >= 1。请查看 decode() 的示例，以更好地理解如何使用
output_word_offsets。batch_decode() 在处理批量输出时的工作方式相同。
使用语言模型支持，将批量解码的输出 logits 转换为音频转录文本。
此函数使用了 Python 的 multiprocessing。目前，multiprocessing 仅在 Unix 系统上可用（参见此 issue）。
如果您正在解码多个批次，建议创建一个
Pool并将其传递给batch_decode。否则，batch_decode会非常慢，因为它会为每次调用创建一个新的Pool。用法示例见下文。
示例： 参见 解码多个音频。
decode
< source >( logits: ndarraybeam_width: int | None = Nonebeam_prune_logp: float | None = Nonetoken_min_logp: float | None = Nonehotwords: collections.abc.Iterable[str] | None = Nonehotword_weight: float | None = Nonealpha: float | None = Nonebeta: float | None = Noneunk_score_offset: float | None = Nonelm_score_boundary: bool | None = Noneoutput_word_offsets: bool = Falsen_best: int = 1 )
参数
- logits (
np.ndarray) — 模型的 logits 输出向量，表示每个 token 的对数概率。 - beam_width (
int, 可选) — 解码过程中每一步的最大 beam 数量。默认值为 pyctcdecode 的 DEFAULT_BEAM_WIDTH。 - beam_prune_logp (
int, 可选) — 用于剪除 log-probs 小于 best_beam_logp + beam_prune_logp 的 beam 的阈值。该值应 <= 0。默认为 pyctcdecode 的 DEFAULT_PRUNE_LOGP。 - token_min_logp (
int，可选) — log-prob 低于 token_min_logp 的 token 会被跳过，除非它们具有该 utterance 的最大 log-prob。默认值为 pyctcdecode 的 DEFAULT_MIN_TOKEN_LOGP。 - hotwords (
list[str]，可选) — 具有额外重要性的单词列表，这些单词可能不在 LM 的词汇表中，例如 [“huggingface”] - hotword_weight (
int，可选) — 用于提升热词得分的权重乘数。默认值为 pyctcdecode 的 DEFAULT_HOTWORD_WEIGHT。 - alpha (
float, 可选) — 浅层融合期间语言模型的权重 - beta (
float, 可选) — 评分过程中用于长度分数调整的权重 - unk_score_offset (
float, 可选) — 未知令牌的 log score 偏移量 - lm_score_boundary (
bool，可选) — kenlm 在评分时是否遵循边界 - output_word_offsets (
bool，可选，默认为False) — 是否输出单词偏移量。单词偏移量可与采样率和模型降采样率结合使用，以计算转录单词的时间戳。 - n_best (
int, 可选, ，默认为1) — 要返回的最佳假设数量。如果n_best大于 1，则返回的text将是字符串列表，logit_score将是浮点数列表，lm_score将是浮点数列表，这些列表的长度将与返回的假设数量相对应。该值应 >= 1。请查看下面的示例，以更好地理解如何使用
output_word_offsets。
使用语言模型支持将解码输出的 logits 转换为音频转录文本。
示例：
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)
>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
... logits = model(input_values).logits[0].cpu().numpy()
>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
>>> word_offsets = [
... {
... "word": d["word"],
... "start_time": round(d["start_offset"] * time_offset, 2),
... "end_time": round(d["end_offset"] * time_offset, 2),
... }
... for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]解码多个音频
此示例使用了已弃用的 Wav2Vec2ProcessorWithLM。对于新代码，请改为向 pyctcdecode 的
decode_beams_batch传入一个multiprocessing.Pool，参见 迁移到 pyctcdecode。
如果您计划解码多个音频批次，应考虑使用 batch_decode() 并传入一个已实例化的 multiprocessing.Pool。
否则，batch_decode() 的性能将慢于对每个音频单独调用 decode()，因为它在每次调用时都会内部实例化一个新的 Pool。请参见以下示例：
# Let's see how to use a user-managed pool for batch decoding multiple audios
from multiprocessing import get_context
import datasets
import torch
from datasets import load_dataset
from transformers import AutoModelForCTC, AutoProcessor
# import model, feature extractor, tokenizer
model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm", device_map="auto")
processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
# load example dataset
dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
def map_to_array(example):
example["speech"] = example["audio"]["array"]
return example
# prepare speech data for batch inference
dataset = dataset.map(map_to_array, remove_columns=["audio"])
def map_to_pred(batch, pool):
inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt").to(model.device)
inputs = {k: v.to(model.device) for k, v in inputs.items()}
with torch.no_grad():
logits = model(**inputs).logits
transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
batch["transcription"] = transcription
return batch
# note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
# otherwise, the LM won't be available to the pool's sub-processes
# select number of processes and batch_size based on number of CPU cores available and on dataset size
with get_context("fork").Pool(processes=2) as pool:
result = dataset.map(
map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
)
result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]迁移到 pyctcdecode
Wav2Vec2ProcessorWithLM 是 pyctcdecode 的轻量级封装。
使用 Wav2Vec2Processor 加载特征提取器和分词器，使用 pyctcdecode 加载语言模型，然后对 logits 调用
pyctcdecode。这将得到与 batch_decode() 相同的转录结果。它
需要 pyctcdecode 和 kenlm，
这些依赖项不再随 transformers[audio] 一起安装。
import torch
from pyctcdecode import BeamSearchDecoderCTC
from transformers import AutoModelForCTC, Wav2Vec2Processor
repo = "patrickvonplaten/wav2vec2-base-100h-with-lm"
model = AutoModelForCTC.from_pretrained(repo)
processor = Wav2Vec2Processor.from_pretrained(repo) # feature extractor + tokenizer
# only download the language model and the alphabet, not the model weights
decoder = BeamSearchDecoderCTC.load_from_hf_hub(repo, allow_patterns=["language_model/*", "alphabet.json"])
inputs = processor(audio, sampling_rate=16_000, padding=True, return_tensors="pt")
with torch.no_grad():
logits = model(**inputs).logits.cpu().numpy()
# was: processor_with_lm.batch_decode(logits, alpha=0.5, beta=1.0, beam_width=50).text
# `alpha`, `beta`, `unk_score_offset` and `lm_score_boundary` are set on the decoder (values that are not passed are kept)
decoder.reset_params(alpha=0.5, beta=1.0)
# drop the frames padded with -100, as `batch_decode` does
logits_list = [sample[(sample != -100.0).all(axis=-1)] for sample in logits]
# `beam_width`, `beam_prune_logp`, `token_min_logp`, `hotwords` and `hotword_weight` are decoding arguments
beams = decoder.decode_beams_batch(None, logits_list, beam_width=50)
transcription = [sample_beams[0][0] for sample_beams in beams]- 单个样本：
processor_with_lm.decode(logits[0]).text变为decoder.decode_beams(logits[0])[0][0]。 - 使用
decode_beams/decode_beams_batch，而不是decode/decode_batch：后者会修剪 beam 历史，并可能产生不同的转录结果。 - 并行解码：将使用
fork上下文创建的multiprocessing.Pool作为decode_beams_batch的第一个参数传入。 - Beams 按最优优先排序，并携带分数和单词偏移量：
decode_beams_batch:(text, word_offsets, logit_score, lm_score);decode_beams:(text, last_lm_state, word_offsets, logit_score, lm_score).
要在没有语言模型的情况下进行解码，请在每一帧选择最可能的 token：
transcription = processor.batch_decode(logits.argmax(-1))Wav2Vec2 特定输出
class transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput
< source >( text: list[list[str]] | list[str] | strlogit_score: list[list[float]] | list[float] | float = Nonelm_score: list[list[float]] | list[float] | float = Noneword_offsets: list[list[list[dict[str, int | str]]]] | list[list[dict[str, int | str]]] | list[dict[str, int | str]] = None )
decode() 和 batch_decode() 的输出类型。已弃用，将在 Transformers v6 中移除。
class transformers.modeling_outputs.Wav2Vec2BaseModelOutput
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Noneextract_features: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - extract_features (
torch.Tensor，形状为(batch_size, sequence_length, conv_dim[-1])) — 模型最后一个卷积层提取的特征向量序列。 - hidden_states (
tuple(torch.Tensor), 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（嵌入层输出一个 + 每层输出各一个），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
使用 Wav2Vec2 损失目标进行训练的模型基类。
class transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput
< source >( loss: typing.Optional[torch.Tensor] = Noneprojected_states: typing.Optional[torch.Tensor] = Noneprojected_quantized_states: typing.Optional[torch.Tensor] = Nonecodevector_perplexity: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = Nonecontrastive_loss: typing.Optional[torch.Tensor] = Nonediversity_loss: typing.Optional[torch.Tensor] = None )
参数
- loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the official paper. - projected_states（形状为
(batch_size, sequence_length, config.proj_codevector_dim)的torch.Tensor）— 模型隐藏状态投影到 config.proj_codevector_dim 后的结果，可用于预测被掩码的投影量化状态。 - projected_quantized_states (
torch.Tensor，形状为(batch_size, sequence_length, config.proj_codevector_dim)) — 量化后的提取特征向量，投影至 config.proj_codevector_dim，表示用于对比损失的阳性目标向量。 - codevector_perplexity (
torch.Tensor，形状为(1,)) — 码向量分布的困惑度，用于衡量码本（codebook）的多样性。 - hidden_states (
tuple[torch.Tensor], 可选, 当output_hidden_states=True被传入或config.output_hidden_states=True) — 元组，包含torch.Tensor(嵌入层输出（如果模型有嵌入层）+ 每层输出的张量，形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple[torch.Tensor], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
- contrastive_loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — The contrastive loss (L_m) as stated in the official paper. - diversity_loss (
*optional*, returned whensample_negative_indicesare passed,torch.Tensorof shape(1,)) — The diversity loss (L_d) as stated in the official paper.
Wav2Vec2ForPreTraining 的输出类型，可能包含隐藏状态和注意力。
Wav2Vec2Model
class transformers.Wav2Vec2Model
< source >( config: Wav2Vec2Config )
参数
- config (Wav2Vec2Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
输出原始隐藏状态、顶部未附加任何特定头部的裸 Wav2Vec2 模型。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonemask_time_indices: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Wav2Vec2BaseModelOutput or tuple(torch.Tensor)
参数
- input_values (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载为list[float]、numpy.ndarray或torch.Tensor类型的数组来获取这些值，例如 使用 torchcodec 库（pip install torchcodec）或 soundfile 库（pip install soundfile）。要将该数组准备为input_values，应使用 AutoProcessor 进行填充并转换为torch.Tensor类型的张量。详情请参见 Wav2Vec2Processor.call()。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- mask_time_indices (
torch.BoolTensor，形状为(batch_size, sequence_length)，可选) — 用于对比损失中掩码提取特征的索引。在训练模式下，模型学习在 config.proj_codevector_dim 空间中预测被掩码的提取特征。
返回值
Wav2Vec2BaseModelOutput 或 tuple(torch.Tensor)
一个 Wav2Vec2BaseModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（Wav2Vec2Config）和输入。
Wav2Vec2Model 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。extract_features（形状为
(batch_size, sequence_length, conv_dim[-1])的torch.Tensor）— 模型最后一个卷积层提取的特征向量序列。hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
Wav2Vec2ForCTC
class transformers.Wav2Vec2ForCTC
< source >( config: Wav2Vec2Configtarget_lang: str | None = None )
参数
- config (Wav2Vec2Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
- target_lang (
str, 可选) — 适配器权重的语言 ID。适配器权重以 adapter.<lang>.safetensors 或 adapter.<lang>.bin 格式存储。仅在使用带有适配器的 Wav2Vec2ForCTC 实例时相关。默认使用 ‘eng’。
带有 language modeling 头部的 Wav2Vec2 模型，用于连接主义时间分类（CTC）。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutput or tuple(torch.Tensor)
参数
- input_values (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载为list[float]、numpy.ndarray或torch.Tensor类型的数组来获取这些值，例如 使用 torchcodec 库（pip install torchcodec）或 soundfile 库（pip install soundfile）。要将该数组准备为input_values，应使用 AutoProcessor 进行填充并转换为torch.Tensor类型的张量。详情请参见 Wav2Vec2Processor.call()。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- labels (
torch.LongTensor，形状为(batch_size, target_length)，可选) — 用于连接时序分类的标签。请注意，target_length必须小于或等于输出 logits 的序列长度。索引的取值范围为[-100, 0, ..., config.vocab_size - 1]。 所有设置为-100的标签都会被忽略（即被掩码），损失仅针对[0, ..., config.vocab_size - 1]范围内的标签进行计算。
返回值
CausalLMOutput 或 tuple(torch.Tensor)
一个 CausalLMOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（Wav2Vec2Config）和输入。
Wav2Vec2ForCTC 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。logits（形状为
(batch_size, sequence_length, config.vocab_size)的torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> from transformers import AutoProcessor, Wav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...
>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...load_adapter
< source >( target_lang: strforce_load = True**kwargs )
参数
- target_lang (
str) — 必须是现有适配器权重的语言 ID。适配器权重以 adapter.<lang>.safetensors 或 adapter.<lang>.bin 格式存储 - force_load (
bool，默认为True) — 即使target_lang与self.target_lang匹配，是否仍强制加载权重。 - cache_dir (
Union[str, os.PathLike], 可选) — 如果不应使用标准缓存，则用于缓存已下载的预训练模型配置的目录路径。 - force_download (
bool，可选，默认为False) — 是否强制（重新）下载模型权重和配置文件，如果存在缓存版本则覆盖它们。 - proxies (
dict[str, str]，可选) — 按协议或端点使用的代理服务器字典，例如{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}。每次请求都会使用这些代理。 - local_files_only(
bool, 可选，默认为False) — 是否仅查看本地文件（即不尝试下载模型）。 - token (
str或bool，可选) — 用于远程文件的 HTTP bearer 授权令牌。如果为True或未指定，则使用运行hf auth login时生成的令牌（存储在~/.huggingface中）。 - revision (
str, 可选, 默认为"main") — 要使用的特定模型版本。由于我们在 huggingface.co 上使用基于 git 的系统来存储模型和其他工件，因此它可以是分支名称、标签名称或提交 ID，所以revision可以是 git 允许的任何标识符。要测试您在 Hub 上创建的拉取请求，可以传入
revision="refs/pr/<pr_number>"。 - mirror (
str，可选) — 用于加速中国境内下载的镜像源。如果您在中国且遇到访问问题，可以设置此选项来解决。请注意，我们不保证镜像源的时效性或安全性。有关更多信息，请参阅镜像站点。
从预训练的适配器模型加载语言适配器模型。
启用特殊的 “offline-mode”，以便在防火墙环境中使用此方法。
示例：
>>> from transformers import Wav2Vec2ForCTC, AutoProcessor
>>> ckpt = "facebook/mms-1b-all"
>>> processor = AutoProcessor.from_pretrained(ckpt)
>>> model = Wav2Vec2ForCTC.from_pretrained(ckpt, target_lang="eng")
>>> # set specific language
>>> processor.tokenizer.set_target_lang("spa")
>>> model.load_adapter("spa")Wav2Vec2ForSequenceClassification
class transformers.Wav2Vec2ForSequenceClassification
< source >( config: Wav2Vec2Config )
参数
- config (Wav2Vec2Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
在 Wav2Vec2 模型顶部添加一个序列分类头（在池化输出上应用一个线性层），用于 SUPERB 关键词检测等任务。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)
参数
- input_values (
torch.Tensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载为list[float]、numpy.ndarray或torch.Tensor类型的数组来获取这些值，例如 使用 torchcodec 库（pip install torchcodec）或 soundfile 库（pip install soundfile）。要将该数组准备为input_values，应使用 AutoProcessor 进行填充并转换为torch.Tensor类型的张量。详情请参见 Wav2Vec2Processor.call()。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回值
SequenceClassifierOutput 或 tuple(torch.Tensor)
一个 SequenceClassifierOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（Wav2Vec2Config）和输入。
Wav2Vec2ForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
单标签分类示例：
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多标签分类示例：
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained(
... "facebook/wav2vec2-base-960h", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossWav2Vec2ForAudioFrameClassification
class transformers.Wav2Vec2ForAudioFrameClassification
< source >( config: Wav2Vec2Config )
参数
- config (Wav2Vec2Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有帧分类头部的 Wav2Vec2 模型，用于说话人分离等任务。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.Tensor)
参数
- input_values (
torch.Tensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载为list[float]、numpy.ndarray或torch.Tensor类型的数组来获取这些值，例如 使用 torchcodec 库（pip install torchcodec）或 soundfile 库（pip install soundfile）。要将该数组准备为input_values，应使用 AutoProcessor 进行填充并转换为torch.Tensor类型的张量。详情请参见 Wav2Vec2Processor.call()。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回值
TokenClassifierOutput 或 tuple(torch.Tensor)
一个 TokenClassifierOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（Wav2Vec2Config）和输入。
Wav2Vec2ForAudioFrameClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss（形状为
(1,)的torch.Tensor，可选，在提供labels时返回） — 分类损失。logits（形状为
(batch_size, sequence_length, config.num_labels)的torch.Tensor）— 分类分数（SoftMax 之前）。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForAudioFrameClassification.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
...Wav2Vec2ForXVector
class transformers.Wav2Vec2ForXVector
< source >( config: Wav2Vec2Config )
参数
- config (Wav2Vec2Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
在 Wav2Vec2 模型顶部添加 XVector 特征提取头，用于说话人验证等任务。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → XVectorOutput or tuple(torch.Tensor)
参数
- input_values (
torch.Tensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载为list[float]、numpy.ndarray或torch.Tensor类型的数组来获取这些值，例如 使用 torchcodec 库（pip install torchcodec）或 soundfile 库（pip install soundfile）。要将该数组准备为input_values，应使用 AutoProcessor 进行填充并转换为torch.Tensor类型的张量。详情请参见 Wav2Vec2Processor.call()。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回值
XVectorOutput 或 tuple(torch.Tensor)
一个 XVectorOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（Wav2Vec2Config）和输入。
Wav2Vec2ForXVector 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss（形状为
(1,)的torch.Tensor，可选，在提供labels时返回） — 分类损失。logits（形状为
(batch_size, config.xvector_output_dim)的torch.Tensor）— AMSoftmax 之前的分类隐藏状态。嵌入（形状为
(batch_size, config.xvector_output_dim)的torch.Tensor）— 用于基于向量相似性检索的语句嵌入。hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（包含嵌入层的输出以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForXVector
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForXVector.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
... [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
... embeddings = model(**inputs).embeddings
>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()
>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7 # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
... print("Speakers are not the same!")
>>> round(similarity.item(), 2)
...Wav2Vec2ForPreTraining
class transformers.Wav2Vec2ForPreTraining
< source >( config: Wav2Vec2Config )
参数
- config (Wav2Vec2Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有量化器和顶部 VQ 头的 Wav2Vec2 模型。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonemask_time_indices: typing.Optional[torch.BoolTensor] = Nonesampled_negative_indices: typing.Optional[torch.BoolTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Wav2Vec2ForPreTrainingOutput or tuple(torch.Tensor)
参数
- input_values (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载为list[float]、numpy.ndarray或torch.Tensor类型的数组来获取这些值，例如 使用 torchcodec 库（pip install torchcodec）或 soundfile 库（pip install soundfile）。要将该数组准备为input_values，应使用 AutoProcessor 进行填充并转换为torch.Tensor类型的张量。详情请参见 Wav2Vec2Processor.call()。 - attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- mask_time_indices (
torch.BoolTensor，形状为(batch_size, sequence_length)，可选) — 用于对比损失中掩码提取特征的索引。在训练模式下，模型学习在 config.proj_codevector_dim 空间中预测被掩码的提取特征。 - sampled_negative_indices（形状为
(batch_size, sequence_length, num_negatives)的torch.BoolTensor，可选） — 指示哪些量化目标向量被用作对比损失中的负采样向量的索引。 预训练所需的输入。
返回值
Wav2Vec2ForPreTrainingOutput 或 tuple(torch.Tensor)
一个 Wav2Vec2ForPreTrainingOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），包含根据配置（Wav2Vec2Config）和输入而定的各种元素。
Wav2Vec2ForPreTraining 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
*optional*，在传入sample_negative_indices时返回，形状为(1,)的torch.Tensor) — 如官方 论文所述，总损失为对比损失 (L_m) 与多样性损失 (L_d) 之和。projected_states（形状为
(batch_size, sequence_length, config.proj_codevector_dim)的torch.Tensor）— 模型隐藏状态投影到 config.proj_codevector_dim 后的结果，可用于预测被掩码的投影量化状态。projected_quantized_states（形状为
(batch_size, sequence_length, config.proj_codevector_dim)的torch.Tensor）— 量化提取的特征向量，投影至 config.proj_codevector_dim，表示用于对比损失的阳性目标向量。codevector_perplexity（形状为
(1,)的torch.Tensor）— 码向量分布的困惑度，用于衡量码本（codebook）的多样性。hidden_states (
tuple[torch.Tensor]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple[torch.Tensor]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
contrastive_loss (
*optional*，在传入sample_negative_indices时返回，形状为(1,)的torch.Tensor) — 如官方论文中所述的对比损失 (L_m)。diversity_loss (
*optional*，在传入sample_negative_indices时返回，形状为(1,)的torch.Tensor) — 如官方论文中所述的多样性损失 (L_d)。
示例：
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_wav2vec2 import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
>>> model = Wav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values # Batch size 1
>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
... shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
... features_shape=(batch_size, sequence_length),
... num_negatives=model.config.num_negatives,
... mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
... data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )
>>> with torch.no_grad():
... outputs = model(input_values, mask_time_indices=mask_time_indices)
>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)
>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)
>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
... input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss