Wav2Vec2
概述
Wav2Vec2 模型在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中被提出,作者是 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli。
论文的摘要如下
我们首次展示了仅从语音音频中学习强大的表示,然后对转录的语音进行微调,可以胜过最佳的半监督方法,同时在概念上更简单。 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 万小时的音频上进行了预训练。 我们特别建议将其用于微调任务,例如按照 本指南 进行操作。
使用技巧
- Wav2Vec2 是一个语音模型,它接受与语音信号原始波形相对应的浮点数组。
- Wav2Vec2 模型是使用连接时序分类 (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
使用方法
要使用 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", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to(device)
...
预期加速
下图是预期加速图,比较了 facebook/wav2vec2-large-960h-lv60-self
模型在 transformers 中的原生实现与 flash-attention-2 和 sdpa (scale-dot-product-attention) 版本之间的纯推理时间。 我们展示了在 librispeech_asr
clean
验证集上获得的平均加速

资源
以下是官方 Hugging Face 和社区 (🌎 符号表示) 资源的列表,可帮助您开始使用 Wav2Vec2。如果您有兴趣提交资源以包含在此处,请随时打开 Pull Request,我们将进行审核!理想情况下,资源应展示一些新的内容,而不是重复现有资源。
- 一个关于如何利用预训练的 Wav2Vec2 模型进行情感分类的 notebook。 🌎
- Wav2Vec2ForCTC 由此示例脚本和notebook支持。
- 音频分类任务指南
- 一篇关于在 🤗 Transformers 中使用 n-grams 提升 Wav2Vec2 性能的博文。
- 一篇关于如何使用 🤗 Transformers 微调 Wav2Vec2 以进行英语 ASR 的博文。
- 一篇关于使用 🤗 Transformers 微调 XLS-R 以进行多语言 ASR 的博文。
- 一个关于如何通过使用 Wav2Vec2 转录音频,从任何视频创建 YouTube 字幕的 notebook。 🌎
- Wav2Vec2ForCTC 由关于 如何在英语中微调语音识别模型 和 如何在任何语言中微调语音识别模型 的 notebook 支持。
- 自动语音识别任务指南
🚀 部署
- 一篇关于如何使用 Hugging Face 的 Transformers 和 Amazon SageMaker 部署 Wav2Vec2 以进行自动语音识别的博文。
Wav2Vec2Config
class transformers.Wav2Vec2Config
< 源码 >( vocab_size = 32 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout = 0.1 activation_dropout = 0.1 attention_dropout = 0.1 feat_proj_dropout = 0.0 feat_quantizer_dropout = 0.0 final_dropout = 0.1 layerdrop = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 feat_extract_norm = 'group' feat_extract_activation = 'gelu' conv_dim = (512, 512, 512, 512, 512, 512, 512) conv_stride = (5, 2, 2, 2, 2, 2, 2) conv_kernel = (10, 3, 3, 3, 3, 2, 2) conv_bias = False num_conv_pos_embeddings = 128 num_conv_pos_embedding_groups = 16 do_stable_layer_norm = False apply_spec_augment = True mask_time_prob = 0.05 mask_time_length = 10 mask_time_min_masks = 2 mask_feature_prob = 0.0 mask_feature_length = 10 mask_feature_min_masks = 0 num_codevectors_per_group = 320 num_codevector_groups = 2 contrastive_logits_temperature = 0.1 num_negatives = 100 codevector_dim = 256 proj_codevector_dim = 256 diversity_loss_weight = 0.1 ctc_loss_reduction = 'sum' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 tdnn_dim = (512, 512, 512, 512, 1500) tdnn_kernel = (5, 3, 3, 1, 1) tdnn_dilation = (1, 2, 3, 1, 1) xvector_output_dim = 512 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 add_adapter = False adapter_kernel_size = 3 adapter_stride = 2 num_adapter_layers = 3 output_hidden_size = None adapter_attn_dim = None **kwargs )
参数
- vocab_size (
int
, 可选, 默认为 32) — Wav2Vec2 模型的词汇表大小。定义了在调用 Wav2Vec2Model 或 TFWav2Vec2Model 时,可以通过inputs_ids
传递的不同 token 的数量。模型的词汇表大小。定义了可以通过传递给 Wav2Vec2Model 的 forward 方法的 inputs_ids 表示的不同 token。 - hidden_size (
int
, 可选, 默认为 768) — 编码器层和池化器层的维度。 - num_hidden_layers (
int
, 可选, 默认为 12) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int
, 可选, 默认为 12) — Transformer 编码器中每个 attention 层的 attention head 数量。 - intermediate_size (
int
, 可选, 默认为 3072) — Transformer 编码器中“中间”(即,前馈)层的维度。 - hidden_act (
str
或function
, 可选, 默认为"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 - hidden_dropout (
float
, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 - activation_dropout (
float
, 可选, 默认为 0.1) — 全连接层内部激活的 dropout 比率。 - attention_dropout (
float
, 可选, 默认为 0.1) — attention 概率的 dropout 比率。 - final_dropout (
float
, 可选, 默认为 0.1) — Wav2Vec2ForCTC 的最终投影层的 dropout 概率。 - layerdrop (
float
, 可选, 默认为 0.1) — LayerDrop 概率。有关更多详细信息,请参见 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。 - initializer_range (
float
, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float
, 可选, 默认为 1e-05) — layer normalization 层使用的 epsilon 值。 - feat_extract_norm (
str
, 可选, 默认为"group"
) — 要应用于特征编码器中 1D 卷积层的 norm。可以是"group"
(仅对第一个 1D 卷积层进行 group normalization)或"layer"
(对所有 1D 卷积层进行 layer normalization)之一。 - feat_proj_dropout (
float
, 可选, 默认为 0.0) — 特征编码器输出的 dropout 概率。 - feat_extract_activation (
str,
可选,
默认为“gelu”
) -- 特征提取器的 1D 卷积层中的非线性激活函数(函数或字符串)。如果为字符串,则支持“gelu”
、“relu”
、“selu”
和“gelu_new”
。 - feat_quantizer_dropout (
float
, 可选, 默认为 0.0) — 量化特征编码器状态的 dropout 概率。 - conv_dim (
Tuple[int]
orList[int]
, optional, defaults to(512, 512, 512, 512, 512, 512, 512)
) — 一个整数元组,定义特征编码器中每个 1D 卷积层的输入和输出通道数。conv_dim
的长度定义了 1D 卷积层的数量。 - conv_stride (
Tuple[int]
orList[int]
, optional, defaults to(5, 2, 2, 2, 2, 2, 2)
) — 一个整数元组,定义特征编码器中每个 1D 卷积层的步幅。conv_stride
的长度定义了卷积层的数量,并且必须与conv_dim
的长度匹配。 - conv_kernel (
Tuple[int]
orList[int]
, optional, defaults to(10, 3, 3, 3, 3, 3, 3)
) — 一个整数元组,定义特征编码器中每个 1D 卷积层的内核大小。conv_kernel
的长度定义了卷积层的数量,并且必须与conv_dim
的长度匹配。 - conv_bias (
bool
, optional, defaults toFalse
) — 1D 卷积层是否具有偏置。 - num_conv_pos_embeddings (
int
, optional, defaults to 128) — 卷积位置嵌入的数量。定义 1D 卷积位置嵌入层的内核大小。 - num_conv_pos_embedding_groups (
int
, optional, defaults to 16) — 1D 卷积位置嵌入层的组数。 - do_stable_layer_norm (
bool
, optional, defaults toFalse
) — 是否应用 Transformer 编码器的 *stable* 层归一化架构。do_stable_layer_norm is True
对应于在注意力层之前应用层归一化,而do_stable_layer_norm is False
对应于在注意力层之后应用层归一化。 - apply_spec_augment (
bool
, optional, defaults toTrue
) — 是否将 *SpecAugment* 数据增强应用于特征编码器的输出。有关参考,请参阅 SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。 - mask_time_prob (
float
, optional, defaults to 0.05) — 沿时间轴将被屏蔽的所有特征向量的百分比(介于 0 和 1 之间)。屏蔽过程在轴上生成 “mask_time_prob*len(time_axis)/mask_time_length” 个独立的掩码。如果从每个特征向量被选为要屏蔽的向量跨度的开始的概率来推断,mask_time_prob
应该为prob_vector_start*mask_time_length
。请注意,重叠可能会减少实际屏蔽向量的百分比。这仅在apply_spec_augment is True
时相关。 - mask_time_length (
int
, optional, defaults to 10) — 沿时间轴的向量跨度长度。 - mask_time_min_masks (
int
, optional, defaults to 2), — 沿时间轴生成的长度为mask_feature_length
的掩码的最小数量,每个时间步,与mask_feature_prob
无关。仅在 “mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks” 时相关 - mask_feature_prob (
float
, optional, defaults to 0.0) — 沿特征轴将被屏蔽的所有特征向量的百分比(介于 0 和 1 之间)。屏蔽过程在轴上生成 “mask_feature_prob*len(feature_axis)/mask_time_length” 个独立的掩码。如果从每个特征向量被选为要屏蔽的向量跨度的开始的概率来推断,mask_feature_prob
应该为prob_vector_start*mask_feature_length
。请注意,重叠可能会减少实际屏蔽向量的百分比。这仅在apply_spec_augment is True
时相关。 - mask_feature_length (
int
, optional, defaults to 10) — 沿特征轴的向量跨度长度。 - mask_feature_min_masks (
int
, optional, defaults to 0), — 沿特征轴生成的长度为mask_feature_length
的掩码的最小数量,每个时间步,与mask_feature_prob
无关。仅在 “mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks” 时相关 - num_codevectors_per_group (
int
, optional, defaults to 320) — 每个量化码本(组)中的条目数。 - num_codevector_groups (
int
, optional, defaults to 2) — 用于乘积码向量量化的码向量组数。 - contrastive_logits_temperature (
float
, optional, defaults to 0.1) — 对比损失中的温度 kappa。 - feat_quantizer_dropout (
float
, optional, defaults to 0.0) — 特征编码器输出的 dropout 概率,该输出由量化器使用。 - num_negatives (
int
, optional, defaults to 100) — 对比损失的负样本数。 - codevector_dim (
int
, optional, defaults to 256) — 量化特征向量的维度。 - proj_codevector_dim (
int
, optional, defaults to 256) — 量化特征和 Transformer 特征的最终投影的维度。 - diversity_loss_weight (
int
, optional, defaults to 0.1) — 码本多样性损失分量的权重。 - ctc_loss_reduction (
str
, optional, defaults to"sum"
) — 指定应用于torch.nn.CTCLoss
输出的缩减方式。仅在训练 Wav2Vec2ForCTC 的实例时相关。 - ctc_zero_infinity (
bool
, optional, defaults toFalse
) — 是否将torch.nn.CTCLoss
的无限损失和相关的梯度置零。当输入太短而无法与目标对齐时,主要会发生无限损失。仅在训练 Wav2Vec2ForCTC 的实例时相关。 - use_weighted_layer_sum (
bool
, optional, defaults toFalse
) — 是否使用层输出的加权平均值以及学习到的权重。仅在使用 Wav2Vec2ForSequenceClassification 的实例时相关。 - classifier_proj_size (
int
, optional, defaults to 256) — 分类前令牌均值池化之前的投影维度。 - tdnn_dim (
Tuple[int]
或List[int]
, 可选, 默认为(512, 512, 512, 512, 1500)
) — 一个整数元组,定义了 XVector 模型的 TDNN 模块中每个 1D 卷积层的输出通道数。tdnn_dim 的长度定义了 TDNN 层的数量。 - tdnn_kernel (
Tuple[int]
或List[int]
, 可选, 默认为(5, 3, 3, 1, 1)
) — 一个整数元组,定义了 XVector 模型的 TDNN 模块中每个 1D 卷积层的内核大小。tdnn_kernel 的长度必须与 tdnn_dim 的长度匹配。 - tdnn_dilation (
Tuple[int]
或List[int]
, 可选, 默认为(1, 2, 3, 1, 1)
) — 一个整数元组,定义了 XVector 模型的 TDNN 模块中每个 1D 卷积层的扩张因子。tdnn_dilation 的长度必须与 tdnn_dim 的长度匹配。 - xvector_output_dim (
int
, 可选, 默认为 512) — XVector 嵌入向量的维度。 - add_adapter (
bool
, 可选, 默认为False
) — 是否应在 Wav2Vec2 编码器之上堆叠卷积网络。对于 SpeechEncoderDecoder 模型的热启动 Wav2Vec2 非常有用。 - adapter_kernel_size (
int
, 可选, 默认为 3) — 适配器网络中卷积层的内核大小。仅当add_adapter
为True
时相关。 - adapter_stride (
int
, 可选, 默认为 2) — 适配器网络中卷积层的步幅。仅当add_adapter
为True
时相关。 - num_adapter_layers (
int
, 可选, 默认为 3) — 适配器网络中应使用的卷积层数。仅当add_adapter
为True
时相关。 - adapter_attn_dim (
int
, 可选) — 每个注意力块中要使用的注意力适配器权重的维度。使用注意力适配器的模型示例为 facebook/mms-1b-all。 - output_hidden_size (
int
, 可选) — 编码器输出层的维度。如果未定义,则默认为 hidden-size。仅当add_adapter
为True
时相关。
这是用于存储 Wav2Vec2Model 配置的配置类。它用于根据指定的参数实例化 Wav2Vec2 模型,从而定义模型架构。使用默认值实例化配置将产生与 Wav2Vec2 facebook/wav2vec2-base-960h 架构类似的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。有关更多信息,请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import Wav2Vec2Config, Wav2Vec2Model
>>> # Initializing a Wav2Vec2 facebook/wav2vec2-base-960h style configuration
>>> configuration = Wav2Vec2Config()
>>> # Initializing a model (with random weights) from the facebook/wav2vec2-base-960h style configuration
>>> model = Wav2Vec2Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
Wav2Vec2CTCTokenizer
class transformers.Wav2Vec2CTCTokenizer
< source >( vocab_file bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' word_delimiter_token = '|' replace_word_delimiter_char = ' ' do_lower_case = False target_lang = None **kwargs )
参数
- vocab_file (
str
) — 包含词汇表的文件。 - bos_token (
str
, 可选, 默认为"<s>"
) — 句子的起始标记。 - eos_token (
str
, 可选, 默认为"</s>"
) — 句子的结束标记。 - unk_token (
str
, 可选, 默认为"<unk>"
) — 未知标记。词汇表中不存在的标记无法转换为 ID,而是设置为此标记。 - pad_token (
str
, 可选, 默认为"<pad>"
) — 用于填充的标记,例如在批量处理不同长度的序列时。 - word_delimiter_token (
str
, 可选, 默认为"|"
) — 用于定义单词结尾的标记。 - do_lower_case (
bool
, 可选, 默认为False
) — 是否接受小写输入并在解码时将输出转换为小写。 - target_lang (
str
, 可选) — 分词器应默认设置的目标语言。对于多语言嵌套词汇表(例如 facebook/mms-1b-all),必须定义target_lang
。**kwargs — 传递给 PreTrainedTokenizer 的其他关键字参数。
构建 Wav2Vec2CTC 分词器。
此分词器继承自 PreTrainedTokenizer,其中包含一些主要方法。用户应参考超类以获取有关此类方法的更多信息。
__call__
< source >( text: Union = None text_pair: Union = None text_target: Union = None text_pair_target: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 is_split_into_words: bool = False pad_to_multiple_of: Optional = None padding_side: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → 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
(以消除与序列批次的歧义)。 - add_special_tokens (
bool
, 可选, 默认为True
) — 是否在编码序列时添加特殊 token。 这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens
函数,该函数定义了哪些 token 会自动添加到 input ids 中。 如果您想自动添加bos
或eos
token,这将非常有用。 - 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),则将停用截断/填充到最大长度的功能。 - stride (
int
, 可选, 默认为 0) — 如果与max_length
一起设置为数字,则当return_overflowing_tokens=True
时返回的溢出 token 序列将包含来自截断序列末尾的一些 token,以便在截断序列和溢出序列之间提供一些重叠。 此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool
, 可选, 默认为False
) — 输入是否已预先分词(例如,拆分为单词)。 如果设置为True
,则 tokenizer 假定输入已拆分为单词(例如,通过在空格上拆分),它将对其进行 token 化。 这对于 NER 或 token 分类非常有用。 - pad_to_multiple_of (
int
, 可选) — 如果设置,则将序列填充到提供值的倍数。 需要激活padding
。 这对于在计算能力>= 7.5
(Volta) 的 NVIDIA 硬件上启用 Tensor Core 的使用尤其有用。 - padding_side (
str
, 可选) — 模型应在其上应用填充的一侧。应从 [‘right’, ‘left’] 中选择。 默认值从同名类属性中选取。 - return_tensors (
str
或 TensorType, 可选) — 如果设置,将返回 tensor 而不是 python 整数列表。 可接受的值为:'tf'
: 返回 TensorFlowtf.constant
对象。'pt'
: 返回 PyTorchtorch.Tensor
对象。'np'
: 返回 Numpynp.ndarray
对象。
- return_token_type_ids (
bool
, 可选) — 是否返回 token 类型 ID。 如果保留为默认值,将根据特定 tokenizer 的默认值返回 token 类型 ID,由return_outputs
属性定义。 - return_attention_mask (
bool
, 可选) — 是否返回 attention mask。 如果保留为默认值,将根据特定 tokenizer 的默认值返回 attention mask,由return_outputs
属性定义。 - return_overflowing_tokens (
bool
, 可选, 默认为False
) — 是否返回溢出的 token 序列。 如果提供了一对输入 id 序列(或一批对)并且truncation_strategy = longest_first
或True
,则会引发错误,而不是返回溢出的 token。 - return_special_tokens_mask (
bool
, 可选, 默认为False
) — 是否返回特殊 token mask 信息。 - return_offsets_mapping (
bool
, 可选, 默认为False
) — 是否返回每个 token 的(char_start, char_end)
。这仅在继承自 PreTrainedTokenizerFast 的快速 tokenizer 上可用,如果使用 Python 的 tokenizer,此方法将引发
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
或如果 “token_type_ids” 在self.model_input_names
中时)。 -
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 指定添加的特殊 token,0 指定常规序列 token (当
add_special_tokens=True
并且return_special_tokens_mask=True
时)。 -
length — 输入的长度 (当
return_length=True
时)
对一个或多个序列或一对或多对序列进行 token 化和为模型准备的主要方法。
decode
< source >( token_ids: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None output_char_offsets: bool = False output_word_offsets: bool = False **kwargs ) → str
或 Wav2Vec2CTCTokenizerOutput
参数
- token_ids (
Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]
) — token 化的输入 id 列表。 可以使用__call__
方法获得。 - skip_special_tokens (
bool
, 可选, 默认为False
) — 是否在解码中移除特殊 token。 - clean_up_tokenization_spaces (
bool
, optional) — 是否清理分词空格。 - output_char_offsets (
bool
, optional, defaults toFalse
) — 是否输出字符偏移量。字符偏移量可以与采样率和模型下采样率结合使用,以计算转录字符的时间戳。请查看以下示例,以更好地理解如何使用
output_char_offsets
。 - output_word_offsets (
bool
, optional, defaults toFalse
) — 是否输出词偏移量。词偏移量可以与采样率和模型下采样率结合使用,以计算转录词的时间戳。请查看以下示例,以更好地理解如何使用
output_word_offsets
。 - kwargs (附加关键字参数, optional) — 将传递给底层模型特定的解码方法。
返回值
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, trust_remote_code=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: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None output_char_offsets: bool = False output_word_offsets: bool = False **kwargs ) → List[str]
或 Wav2Vec2CTCTokenizerOutput
参数
- sequences (
Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]
) — 分词后的输入 id 列表。可以使用__call__
方法获得。 - skip_special_tokens (
bool
, optional, defaults toFalse
) — 是否在解码中移除特殊符号。 - clean_up_tokenization_spaces (
bool
, optional) — 是否清理分词空格。 - output_char_offsets (
bool
, optional, defaults toFalse
) — 是否输出字符偏移量。字符偏移量可以与采样率和模型下采样率结合使用,以计算转录字符的时间戳。请查看 decode() 的示例,以更好地理解如何使用
output_char_offsets
。batch_decode() 的工作方式与批量输出相同。 - output_word_offsets (
bool
, optional, defaults toFalse
) — 是否输出词偏移量。词偏移量可以与采样率和模型下采样率结合使用,以计算转录词的时间戳。请查看 decode() 的示例,以更好地理解如何使用
output_word_offsets
。batch_decode() 的工作方式与批量输出相同。 - kwargs (附加关键字参数, optional) — 将传递给底层模型特定的解码方法。
返回值
List[str]
或 Wav2Vec2CTCTokenizerOutput
解码句子的列表。当 output_char_offsets == True
或 output_word_offsets == True
时,将为 Wav2Vec2CTCTokenizerOutput
。
通过调用 decode 将 token id 列表的列表转换为字符串列表。
设置嵌套多语言字典的目标语言
Wav2Vec2FeatureExtractor
class transformers.Wav2Vec2FeatureExtractor
< source >( feature_size = 1 sampling_rate = 16000 padding_value = 0.0 return_attention_mask = False do_normalize = True **kwargs )
参数
- feature_size (
int
, optional, defaults to 1) — 提取特征的特征维度。 - sampling_rate (
int
, optional, defaults to 16000) — 音频文件应数字化的采样率,以赫兹 (Hz) 表示。 - padding_value (
float
, optional, defaults to 0.0) — 用于填充 padding 值的数值。 - do_normalize (
bool
, optional, defaults toTrue
) — 是否对输入进行零均值单位方差归一化。归一化可以显著提高某些模型的性能,例如,wav2vec2-lv60。 - return_attention_mask (
bool
, optional, defaults toFalse
) — 是否 call() 应该返回attention_mask
。已设置
config.feat_extract_norm == "group"
的 Wav2Vec2 模型,例如 wav2vec2-base,没有使用attention_mask
进行训练。对于此类模型,input_values
应仅使用 0 填充,并且不应传递attention_mask
。对于已设置
config.feat_extract_norm == "layer"
的 Wav2Vec2 模型,例如 wav2vec2-lv60,应为批量推理传递attention_mask
。
构建 Wav2Vec2 特征提取器。
此特征提取器继承自 SequenceFeatureExtractor,后者包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
__call__
< source >( raw_speech: Union padding: Union = False max_length: Optional = None truncation: bool = False pad_to_multiple_of: Optional = None return_attention_mask: Optional = None return_tensors: Union = None sampling_rate: Optional = None **kwargs )
参数
- raw_speech (
np.ndarray
,List[float]
,List[np.ndarray]
,List[List[float]]
) — 要填充的序列或批量序列。每个序列可以是 numpy 数组、浮点值列表、numpy 数组列表或浮点值列表的列表。必须是单声道音频,而不是立体声,即每个时间步单个浮点数。 - padding (
bool
,str
或 PaddingStrategy, 可选, 默认为False
) — 选择一种策略来填充返回的序列(根据模型的填充侧和填充索引),选项包括:True
或'longest'
: 填充到批次中最长的序列(如果仅提供单个序列,则不填充)。'max_length'
: 填充到使用参数max_length
指定的最大长度,或者如果未提供该参数,则填充到模型可接受的最大输入长度。False
或'do_not_pad'
(默认): 不填充(即,可以输出具有不同长度序列的批次)。
- max_length (
int
, 可选) — 返回列表的最大长度,并且可以选择作为填充长度(见上文)。 - truncation (
bool
) — 激活截断以将长于 max_length 的输入序列剪切到 max_length。 - pad_to_multiple_of (
int
, 可选) — 如果设置,则将序列填充到所提供值的倍数。这对于在计算能力
>= 7.5
(Volta) 的 NVIDIA 硬件或在受益于序列长度为 128 倍数的 TPU 上启用 Tensor Cores 的使用尤其有用。 - return_attention_mask (
bool
, 可选) — 是否返回 attention mask。如果保留为默认值,将根据特定 feature_extractor 的默认值返回 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
。 - return_tensors (
str
或 TensorType, 可选) — 如果设置,将返回 tensors 而不是 python 整数列表。可接受的值为:'tf'
: 返回 TensorFlowtf.constant
对象。'pt'
: 返回 PyTorchtorch.Tensor
对象。'np'
: 返回 Numpynp.ndarray
对象。
- sampling_rate (
int
, 可选) —raw_speech
输入被采样的采样率。强烈建议在前向调用时传递sampling_rate
以防止静默错误。 - padding_value (
float
, 可选, 默认为 0.0) —
用于特征化并为模型准备一个或多个序列的主要方法。
Wav2Vec2Processor
类 transformers.Wav2Vec2Processor
< source >( feature_extractor tokenizer )
参数
- feature_extractor (
Wav2Vec2FeatureExtractor
) — Wav2Vec2FeatureExtractor 的一个实例。feature extractor 是必需的输入。 - tokenizer (PreTrainedTokenizer) — PreTrainedTokenizer 的一个实例。tokenizer 是必需的输入。
构建一个 Wav2Vec2 processor,它将 Wav2Vec2 feature extractor 和 Wav2Vec2 CTC tokenizer 包装到单个 processor 中。
Wav2Vec2Processor 提供了 Wav2Vec2FeatureExtractor 和 PreTrainedTokenizer 的所有功能。有关更多信息,请参阅 call() 和 decode() 的文档字符串。
当在正常模式下使用时,此方法将其所有参数转发到 Wav2Vec2FeatureExtractor 的 call() 并返回其输出。如果在 as_target_processor()
上下文中使用,则此方法将其所有参数转发到 PreTrainedTokenizer 的 call()。有关更多信息,请参阅上述两种方法的文档字符串。
当在正常模式下使用时,此方法将其所有参数转发到 Wav2Vec2FeatureExtractor 的 pad() 并返回其输出。如果在 as_target_processor()
上下文中使用,则此方法将其所有参数转发到 PreTrainedTokenizer 的 pad()。有关更多信息,请参阅上述两种方法的文档字符串。
save_pretrained
< source >( save_directory push_to_hub: bool = False **kwargs )
参数
- save_directory (
str
或os.PathLike
) — 将保存 feature extractor JSON 文件和 tokenizer 文件的目录(如果目录不存在,则将创建目录)。 - push_to_hub (
bool
, 可选, 默认为False
) — 是否在保存模型后将其推送到 Hugging Face 模型中心。您可以使用repo_id
指定要推送到的存储库(默认为您命名空间中save_directory
的名称)。 - kwargs (
Dict[str, Any]
, 可选) — 传递给 push_to_hub() 方法的其他关键字参数。
将此 processor 的属性(feature extractor、tokenizer...)保存在指定目录中,以便可以使用 from_pretrained() 方法重新加载。
此类方法只是调用 save_pretrained() 和 save_pretrained()。有关更多信息,请参阅上述方法的文档字符串。
此方法将其所有参数转发到 PreTrainedTokenizer 的 batch_decode()。有关更多信息,请参阅此方法的文档字符串。
此方法将其所有参数转发到 PreTrainedTokenizer 的 decode()。有关更多信息,请参阅此方法的文档字符串。
Wav2Vec2ProcessorWithLM
类 transformers.Wav2Vec2ProcessorWithLM
< source >( feature_extractor: FeatureExtractionMixin tokenizer: PreTrainedTokenizerBase decoder: BeamSearchDecoderCTC )
参数
- feature_extractor (Wav2Vec2FeatureExtractor 或 SeamlessM4TFeatureExtractor) — Wav2Vec2FeatureExtractor 或 SeamlessM4TFeatureExtractor 的实例。 特征提取器是必需的输入。
- tokenizer (Wav2Vec2CTCTokenizer) — Wav2Vec2CTCTokenizer 的实例。 分词器是必需的输入。
- decoder (
pyctcdecode.BeamSearchDecoderCTC
) —pyctcdecode.BeamSearchDecoderCTC
的实例。 解码器是必需的输入。
构建一个 Wav2Vec2 处理器,该处理器将 Wav2Vec2 特征提取器、Wav2Vec2 CTC 分词器和一个支持语言模型的解码器封装到一个单独的处理器中,用于语言模型增强的语音识别解码。
当在正常模式下使用时,此方法将其所有参数转发到特征提取器的 __call__()
并返回其输出。如果在 as_target_processor()
上下文中使用,此方法将其所有参数转发到 Wav2Vec2CTCTokenizer 的 call()。 更多信息请参考以上两个方法的文档字符串。
当在正常模式下使用时,此方法将其所有参数转发到特征提取器的 ~FeatureExtractionMixin.pad
并返回其输出。如果在 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 的 *模型 ID*。
- 一个指向 *目录* 的路径,该目录包含使用 save_pretrained() 方法保存的特征提取器文件,例如,
./my_model_directory/
。 - 一个指向已保存的特征提取器 JSON *文件* 的路径或 URL,例如,
./my_model_directory/preprocessor_config.json
。 **kwargs — 传递给 SequenceFeatureExtractor 和 PreTrainedTokenizer 的附加关键字参数
从预训练的 Wav2Vec2 处理器实例化一个 Wav2Vec2ProcessorWithLM。
此类方法只是在调用特征提取器的 from_pretrained()、Wav2Vec2CTCTokenizer 的 from_pretrained() 和 pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub
。
更多信息请参考以上方法的文档字符串。
batch_decode
< source >( logits: ndarray pool: Optional = None num_processes: Optional = None beam_width: Optional = None beam_prune_logp: Optional = None token_min_logp: Optional = None hotwords: Optional = None hotword_weight: Optional = None alpha: Optional = None beta: Optional = None unk_score_offset: Optional = None lm_score_boundary: Optional = None output_word_offsets: bool = False n_best: int = 1 )
参数
- logits (
np.ndarray
) — 模型的 logits 输出向量,表示每个 token 的对数概率。 - pool (
multiprocessing.Pool
, 可选) — 一个可选的用户管理池。如果未设置,将自动创建和关闭一个池。该池应在Wav2Vec2ProcessorWithLM
之后实例化。否则,LM 将不可用于池的子进程。当前,仅可以使用使用 'fork' 上下文创建的池。如果传递了 'spawn' 池,它将被忽略,并将改为使用顺序解码。
- num_processes (
int
, 可选) — 如果未设置pool
,则函数应在其上并行化的进程数。默认为可用 CPU 的数量。 - beam_width (
int
, 可选) — 解码中每一步的最大束数量。默认为 pyctcdecode 的 DEFAULT_BEAM_WIDTH。 - beam_prune_logp (
int
, 可选) — 比最佳束差很多的束将被剪枝。默认为 pyctcdecode 的 DEFAULT_PRUNE_LOGP。 - token_min_logp (
int
, 可选) — 低于此 logp 的 tokens 将被跳过,除非它们是帧的最大值。默认为 pyctcdecode 的 DEFAULT_MIN_TOKEN_LOGP。 - hotwords (
List[str]
, 可选) — 具有额外重要性的单词列表,可以是 LM 的 OOV - hotword_weight (
int
, 可选) — hotword 重要性的权重因子。默认为 pyctcdecode 的 DEFAULT_HOTWORD_WEIGHT。 - alpha (
float
, 可选) — 浅融合期间语言模型的权重 - beta (
float
, 可选) — 评分期间长度分数调整的权重 - unk_score_offset (
float
, 可选) — 未知 tokens 的对数分数偏移量 - lm_score_boundary (
bool
, 可选) — 是否让 kenlm 在评分时考虑边界 - output_word_offsets (
bool
, 可选, 默认为False
) — 是否输出词偏移量。词偏移量可以与采样率和模型下采样率结合使用,以计算转录词的时间戳。 - n_best (
int
, optional, defaults to1
) — 返回的最佳假设数。如果n_best
大于 1,则返回的text
将是字符串列表的列表,logit_score
将是浮点数列表的列表,并且lm_score
将是浮点数列表的列表,其中外部列表的长度将对应于批次大小,内部列表的长度将对应于返回的假设数。该值应 >= 1。请查看 decode() 的示例,以更好地理解如何使用
output_word_offsets
。batch_decode() 的工作方式与批量输出相同。
批量解码输出 logits 为带有语言模型支持的音频转录。
此函数使用 Python 的多进程处理。目前,多进程处理仅在 Unix 系统上可用(请参阅此问题)。
如果要解码多个批次,请考虑创建一个 Pool
并将其传递给 batch_decode
。否则,batch_decode
将会非常慢,因为它会在每次调用时创建一个新的 Pool
。 请参阅下面的用法示例。
示例:请参阅解码多个音频。
decode
< source >( logits: ndarray beam_width: Optional = None beam_prune_logp: Optional = None token_min_logp: Optional = None hotwords: Optional = None hotword_weight: Optional = None alpha: Optional = None beta: Optional = None unk_score_offset: Optional = None lm_score_boundary: Optional = None output_word_offsets: bool = False n_best: int = 1 )
参数
- logits (
np.ndarray
) — 模型的 logits 输出向量,表示每个 token 的对数概率。 - beam_width (
int
, optional) — 解码每一步的最大束数量。默认为 pyctcdecode 的 DEFAULT_BEAM_WIDTH。 - beam_prune_logp (
int
, optional) — 用于剪枝的阈值,将对数概率低于 best_beam_logp + beam_prune_logp 的束剪枝。该值应 <= 0。默认为 pyctcdecode 的 DEFAULT_PRUNE_LOGP。 - token_min_logp (
int
, optional) — 对数概率低于 token_min_logp 的 token 将被跳过,除非它们具有 utterance 的最大对数概率。默认为 pyctcdecode 的 DEFAULT_MIN_TOKEN_LOGP。 - hotwords (
List[str]
, optional) — 具有额外重要性的单词列表,这些单词可能在 LM 的词汇表中缺失,例如 [“huggingface”] - hotword_weight (
int
, optional) — 提升热词得分的权重乘数。默认为 pyctcdecode 的 DEFAULT_HOTWORD_WEIGHT。 - alpha (
float
, optional) — 浅层融合期间语言模型的权重 - beta (
float
, optional) — 用于评分期间长度分数调整的权重 - unk_score_offset (
float
, optional) — 未知 token 的对数分数偏移量 - lm_score_boundary (
bool
, optional) — 是否让 kenlm 在评分时考虑边界 - output_word_offsets (
bool
, optional, defaults toFalse
) — 是否输出词偏移量。词偏移量可以与采样率和模型下采样率结合使用,以计算转录单词的时间戳。 - n_best (
int
, optional, defaults to1
) — 返回的最佳假设数。如果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, trust_remote_code=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)
>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
... logits = model(input_values).logits[0].cpu().numpy()
>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
>>> word_offsets = [
... {
... "word": d["word"],
... "start_time": round(d["start_offset"] * time_offset, 2),
... "end_time": round(d["end_offset"] * time_offset, 2),
... }
... for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]
解码多个音频
如果您计划解码多个音频批次,则应考虑使用 batch_decode() 并传递一个实例化的 multiprocessing.Pool
。 否则,batch_decode() 的性能将比为每个音频单独调用 decode() 慢,因为它在内部为每次调用实例化一个新的 Pool
。 请参阅下面的示例
>>> # Let's see how to use a user-managed pool for batch decoding multiple audios
>>> from multiprocessing import get_context
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm").to("cuda")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> # load example dataset
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> def map_to_array(batch):
... batch["speech"] = batch["audio"]["array"]
... return batch
>>> # prepare speech data for batch inference
>>> dataset = dataset.map(map_to_array, remove_columns=["audio"])
>>> def map_to_pred(batch, pool):
... inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt")
... inputs = {k: v.to("cuda") for k, v in inputs.items()}
... with torch.no_grad():
... logits = model(**inputs).logits
... transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
... batch["transcription"] = transcription
... return batch
>>> # note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
>>> # otherwise, the LM won't be available to the pool's sub-processes
>>> # select number of processes and batch_size based on number of CPU cores available and on dataset size
>>> with get_context("fork").Pool(processes=2) as pool:
... result = dataset.map(
... map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
... )
>>> result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]
Wav2Vec2 特定输出
class transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput
< source >( text: Union logit_score: Union = None lm_score: Union = None word_offsets: Union = None )
参数
Wav2Vec2DecoderWithLM
的输出类型,带有转录。
class transformers.modeling_outputs.Wav2Vec2BaseModelOutput
< source >( last_hidden_state: FloatTensor = None extract_features: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
- last_hidden_state (
torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的输出处的隐藏状态序列。 - extract_features (
torch.FloatTensor
,形状为(batch_size, sequence_length, conv_dim[-1])
) — 模型最后一个卷积层的提取特征向量序列。 - hidden_states (
tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(每个嵌入输出一个,每层输出一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出处的隐藏状态,加上初始嵌入输出。
- attentions (
tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
的元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
使用 Wav2Vec2 损失目标训练的模型的基类。
class transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput
< source >( loss: Optional = None projected_states: FloatTensor = None projected_quantized_states: FloatTensor = None codevector_perplexity: FloatTensor = None hidden_states: Optional = None attentions: Optional = None contrastive_loss: Optional = None diversity_loss: Optional = None )
参数
- loss (可选, 当传递了
sample_negative_indices
时返回, 形状为(1,)
的torch.FloatTensor
) — 总损失,为对比损失 (L_m) 和多样性损失 (L_d) 的总和,如 官方论文 中所述。(分类) 损失。 - projected_states (形状为
(batch_size, sequence_length, config.proj_codevector_dim)
的torch.FloatTensor
) — 模型隐藏状态,投影到 config.proj_codevector_dim 维度,可用于预测被掩码的投影量化状态。 - projected_quantized_states (形状为
(batch_size, sequence_length, config.proj_codevector_dim)
的torch.FloatTensor
) — 量化的提取特征向量,投影到 config.proj_codevector_dim 维度,表示对比损失的正目标向量。 - hidden_states (
tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —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 之后的注意力权重,用于计算自注意力头中的加权平均值。
- contrastive_loss (可选, 当传递了
sample_negative_indices
时返回, 形状为(1,)
的torch.FloatTensor
) — 对比损失 (L_m),如 官方论文 中所述。 - diversity_loss (可选, 当传递了
sample_negative_indices
时返回, 形状为(1,)
的torch.FloatTensor
) — 多样性损失 (L_d),如 官方论文 中所述。
Wav2Vec2ForPreTraining 的输出类型,包含可能的隐藏状态和注意力。
class transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput
< source >( last_hidden_state: Array = None extract_features: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
- last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的jnp.ndarray
) — 模型最后一层的输出端的隐藏状态序列。 - extract_features (形状为
(batch_size, sequence_length, last_conv_dim)
的jnp.ndarray
) — 模型最后一层卷积层的提取特征向量序列,其中last_conv_dim
是最后一层卷积层的维度。 - hidden_states (
tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —jnp.ndarray
的元组 (每个层的输出以及初始嵌入输出各一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出端的隐藏状态,加上初始嵌入输出。
- attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) —jnp.ndarray
的元组 (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
FlaxWav2Vec2BaseModelOutput
的输出类型,包含可能的隐藏状态和注意力。
“返回一个新对象,用新值替换指定的字段。”
class transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput
< source >( projected_states: Array = None projected_quantized_states: Array = None codevector_perplexity: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
- loss (可选, 当模型处于训练模式时返回, 形状为
(1,)
的jnp.ndarray
) — 总损失,为对比损失 (L_m) 和多样性损失 (L_d) 的总和,如 官方论文 中所述。(分类) 损失。 - projected_states (形状为
(batch_size, sequence_length, config.proj_codevector_dim)
的jnp.ndarray
) — 模型隐藏状态,投影到 config.proj_codevector_dim 维度,可用于预测被掩码的投影量化状态。 - projected_quantized_states (形状为
(batch_size, sequence_length, config.proj_codevector_dim)
的jnp.ndarray
) — 量化的提取特征向量,投影到 config.proj_codevector_dim 维度,表示对比损失的正目标向量。 - hidden_states (
tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —jnp.ndarray
的元组 (每个层的输出以及初始嵌入输出各一个),形状为(batch_size, sequence_length, hidden_size)
。模型在每一层输出端的隐藏状态,加上初始嵌入输出。
- attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) —jnp.ndarray
的元组 (每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
FlaxWav2Vec2ForPreTrainingOutput
的输出类型,包含可能的隐藏状态和注意力。
“返回一个新对象,用新值替换指定的字段。”
Wav2Vec2Model
class transformers.Wav2Vec2Model
< source >( config: Wav2Vec2Config )
参数
- config (Wav2Vec2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 Wav2Vec2 模型转换器输出原始隐藏状态,顶部没有任何特定头部。Wav2Vec2 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中被提出,作者是 Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli。
此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法 (例如下载或保存等)。
此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。
forward
< source >( input_values: Optional attention_mask: Optional = None mask_time_indices: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或 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)
,可选) — 用于避免在填充 token 索引上执行卷积和注意力的掩码。掩码值在[0, 1]
中选择:- 1 表示 未被掩盖 的 token,
- 0 表示 被掩盖 的 token。
只有当相应的 processor 的
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有 processor 的config.return_attention_mask == False
的模型,例如 wav2vec2-base,不应 传递attention_mask
,以避免在进行批量推理时性能下降。对于此类模型,input_values
应仅用 0 填充并在不使用attention_mask
的情况下传递。请注意,这些模型也会根据input_values
是否填充而产生略有不同的结果。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是纯元组。
返回值
transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或一个 torch.FloatTensor
元组(如果传递 return_dict=False
或当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (Wav2Vec2Config) 和输入。
-
last_hidden_state (
torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的输出处的隐藏状态序列。 -
extract_features (
torch.FloatTensor
,形状为(batch_size, sequence_length, conv_dim[-1])
) — 模型最后一个卷积层的提取特征向量序列。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —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 之后的注意力权重,用于计算自注意力头中的加权平均值。
Wav2Vec2Model 前向方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> from transformers import AutoProcessor, Wav2Vec2Model
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation", trust_remote_code=True)
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 292, 768]
Wav2Vec2ForCTC
class transformers.Wav2Vec2ForCTC
< source >( config target_lang: Optional = None )
参数
- config (Wav2Vec2Config) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。
- target_lang (
str
,可选) — 适配器权重的语言 ID。适配器权重以 adapter.<lang>.safetensors 或 adapter.<lang>.bin 格式存储。仅在使用带有适配器的 Wav2Vec2ForCTC 实例时相关。默认使用 'eng'。
带有 language modeling
头部的 Wav2Vec2 模型,用于连接时序分类 (CTC)。Wav2Vec2 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中被提出,作者是 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli。
此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法 (例如下载或保存等)。
此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。
forward
< source >( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → 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)
,可选) — 用于避免在填充 token 索引上执行卷积和注意力的掩码。掩码值在[0, 1]
中选择:- 1 表示 未被掩盖 的 token,
- 0 表示 被掩盖 的 token。
只有当相应的 processor 的
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有 processor 的config.return_attention_mask == False
的模型,例如 wav2vec2-base,不应 传递attention_mask
,以避免在进行批量推理时性能下降。对于此类模型,input_values
应仅用 0 填充并在不使用attention_mask
的情况下传递。请注意,这些模型也会根据input_values
是否填充而产生略有不同的结果。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是纯元组。 - labels (
torch.LongTensor
,形状为(batch_size, target_length)
,可选) — 用于连接时序分类的标签。 请注意,target_length
必须小于或等于输出 logits 的序列长度。 索引在[-100, 0, ..., config.vocab_size - 1]
中选择。 所有设置为-100
的标签都将被忽略(掩盖),损失仅针对[0, ..., config.vocab_size - 1]
中的标签计算。
返回值
transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutput 或一个 torch.FloatTensor
元组(如果传递 return_dict=False
或当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (Wav2Vec2Config) 和输入。
-
loss (
torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 语言建模损失(用于下一个 token 预测)。 -
logits (
torch.FloatTensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇 token 的分数)。 -
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 之后的注意力权重,用于计算自注意力头中的加权平均值。
Wav2Vec2ForCTC 前向方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> from transformers import AutoProcessor, Wav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation", trust_remote_code=True)
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
'MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL'
>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
53.48
load_adapter
< source >( target_lang: str force_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
) — 是否强制重新下载模型权重和配置文件,覆盖缓存版本(如果存在)。resume_download
— 已弃用并忽略。现在所有下载在可能的情况下都默认恢复。将在 Transformers v5 版本中移除。 - proxies (
Dict[str, str]
, 可选) — 一个字典,用于按协议或端点指定要使用的代理服务器,例如:{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}
。代理服务器用于每个请求。 - local_files_only(
bool
, 可选, 默认为False
) — 是否仅查看本地文件(即,不尝试下载模型)。 - token (
str
或bool
, 可选) — 用作远程文件 HTTP Bearer 授权的令牌。如果为True
,或未指定,将使用运行huggingface-cli login
时生成的令牌(存储在~/.huggingface
中)。 - revision (
str
, 可选, 默认为"main"
) — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID,因为我们使用基于 git 的系统在 huggingface.co 上存储模型和其他工件,因此revision
可以是 git 允许的任何标识符。要测试您在 Hub 上创建的拉取请求,您可以传递 `revision=“refs/pr/
“。 - mirror (
str
, 可选) — 镜像源,用于加速在中国的下载。如果您来自中国并且遇到可访问性问题,您可以设置此选项来解决它。请注意,我们不保证及时性或安全性。有关更多信息,请参阅镜像站点。
从预训练的适配器模型加载语言适配器模型。
激活特殊的 “离线模式” 以在防火墙环境中使用此方法。
示例
>>> from transformers import Wav2Vec2ForCTC, AutoProcessor
>>> ckpt = "facebook/mms-1b-all"
>>> processor = AutoProcessor.from_pretrained(ckpt)
>>> model = Wav2Vec2ForCTC.from_pretrained(ckpt, target_lang="eng")
>>> # set specific language
>>> processor.tokenizer.set_target_lang("spa")
>>> model.load_adapter("spa")
Wav2Vec2ForSequenceClassification
class transformers.Wav2Vec2ForSequenceClassification
< 源代码 >( config )
参数
- config (Wav2Vec2Config) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有序列分类头的 Wav2Vec2 模型(池化输出之上的线性层),用于诸如 SUPERB 关键词识别之类的任务。
Wav2Vec2 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中被提出,作者是 Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli。
此模型继承自 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)
, 可选) — 用于避免在 padding 标记索引上执行卷积和注意力的掩码。掩码值在[0, 1]
中选择:- 1 表示 未被掩盖 的标记,
- 0 表示 被掩盖 的标记。
只有当相应的 processor 具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有 processor 具有config.return_attention_mask == False
的模型,例如 wav2vec2-base,不应 传递attention_mask
以避免在执行批量推理时性能下降。对于此类模型,input_values
应简单地用 0 填充并在没有attention_mask
的情况下传递。请注意,这些模型也会产生略微不同的结果,具体取决于input_values
是否被填充。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是纯元组。 - labels (
torch.LongTensor
,形状为(batch_size,)
, 可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
中。如果config.num_labels == 1
,则计算回归损失(均方误差损失),如果config.num_labels > 1
,则计算分类损失(交叉熵损失)。
返回值
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutput 或 torch.FloatTensor
的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种元素,具体取决于配置 (Wav2Vec2Config) 和输入。
-
loss (
torch.FloatTensor
,形状为(1,)
, 可选, 当提供labels
时返回) — 分类(或回归,如果 config.num_labels==1)损失。 -
logits (
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 之后的注意力权重,用于计算自注意力头中的加权平均值。
Wav2Vec2ForSequenceClassification 前向方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForSequenceClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation", trust_remote_code=True)
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("superb/wav2vec2-base-superb-ks")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("superb/wav2vec2-base-superb-ks")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.argmax(logits, dim=-1).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'_unknown_'
>>> # compute loss - target_label is e.g. "down"
>>> target_label = model.config.id2label[0]
>>> inputs["labels"] = torch.tensor([model.config.label2id[target_label]])
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
6.54
Wav2Vec2ForAudioFrameClassification
class transformers.Wav2Vec2ForAudioFrameClassification
< 源代码 >( config )
参数
- config (Wav2Vec2Config) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有帧分类头的 Wav2Vec2 模型,用于诸如说话人分割之类的任务。
Wav2Vec2 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中被提出,作者是 Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli。
此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法 (例如下载或保存等)。
此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。
forward
< 源代码 >( input_values: Optional attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 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)
, 可选) — 用于避免在 padding 标记索引上执行卷积和注意力的掩码。掩码值在[0, 1]
中选择:- 1 表示 未被掩盖 的标记,
- 0 表示 被掩盖 的标记。
只有当相应的 processor 具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有 processor 具有config.return_attention_mask == False
的模型,例如 wav2vec2-base,不应 传递attention_mask
以避免在执行批量推理时性能下降。对于此类模型,input_values
应简单地用 0 填充并在没有attention_mask
的情况下传递。请注意,这些模型也会产生略微不同的结果,具体取决于input_values
是否被填充。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states
。 - return_dict (
bool
, optional) — 是否返回 ModelOutput 对象而不是普通元组。 - labels (
torch.LongTensor
,形状为(batch_size,)
,optional) — 用于计算序列分类/回归损失的标签。 索引应在[0, ..., config.num_labels - 1]
中。 如果config.num_labels == 1
,则计算回归损失(均方误差损失);如果config.num_labels > 1
,则计算分类损失(交叉熵损失)。
返回值
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.TokenClassifierOutput 对象或一个 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (Wav2Vec2Config) 和输入。
-
loss (
torch.FloatTensor
,形状为(1,)
,optional,当提供labels
时返回) — 分类损失。 -
logits (
torch.FloatTensor
,形状为(batch_size, sequence_length, config.num_labels)
) — 分类得分(SoftMax 之前)。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,当传递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 之后的注意力权重,用于计算自注意力头中的加权平均值。
Wav2Vec2ForAudioFrameClassification forward 方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation", trust_remote_code=True)
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("anton-l/wav2vec2-base-superb-sd")
>>> model = Wav2Vec2ForAudioFrameClassification.from_pretrained("anton-l/wav2vec2-base-superb-sd")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
[0, 0]
Wav2Vec2ForXVector
class transformers.Wav2Vec2ForXVector
< source >( config )
参数
- config (Wav2Vec2Config) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有 XVector 特征提取头的 Wav2Vec2 模型,用于说话人验证等任务。
Wav2Vec2 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中被提出,作者是 Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli。
此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法 (例如下载或保存等)。
此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。
forward
< source >( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → transformers.modeling_outputs.XVectorOutput 或 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)
,optional) — 用于避免在填充 token 索引上执行卷积和注意力的掩码。 在[0, 1]
中选择掩码值:- 1 表示 未被掩码 的 token,
- 0 表示 被掩码 的 token。
只有当对应的 processor 具有
config.return_attention_mask == True
时,才应传递attention_mask
。 对于所有 processor 具有config.return_attention_mask == False
的模型,例如 wav2vec2-base,不应 传递attention_mask
,以避免在进行批量推理时性能下降。 对于此类模型,input_values
应仅使用 0 填充,并在不使用attention_mask
的情况下传递。 请注意,这些模型也会根据input_values
是否填充而产生略有不同的结果。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states
。 - return_dict (
bool
, optional) — 是否返回 ModelOutput 对象而不是普通元组。 - labels (
torch.LongTensor
,形状为(batch_size,)
,optional) — 用于计算序列分类/回归损失的标签。 索引应在[0, ..., config.num_labels - 1]
中。 如果config.num_labels == 1
,则计算回归损失(均方误差损失);如果config.num_labels > 1
,则计算分类损失(交叉熵损失)。
返回值
transformers.modeling_outputs.XVectorOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.XVectorOutput 对象或一个 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (Wav2Vec2Config) 和输入。
-
loss (
torch.FloatTensor
,形状为(1,)
,optional,当提供labels
时返回) — 分类损失。 -
logits (
torch.FloatTensor
,形状为(batch_size, config.xvector_output_dim)
) — AMSoftmax 之前的分类隐藏状态。 -
embeddings (
torch.FloatTensor
,形状为(batch_size, config.xvector_output_dim)
) — 用于基于向量相似度检索的语句嵌入。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,当传递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 之后的注意力权重,用于计算自注意力头中的加权平均值。
Wav2Vec2ForXVector forward 方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForXVector
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation", trust_remote_code=True)
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("anton-l/wav2vec2-base-superb-sv")
>>> model = Wav2Vec2ForXVector.from_pretrained("anton-l/wav2vec2-base-superb-sv")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
... [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
... embeddings = model(**inputs).embeddings
>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()
>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7 # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
... print("Speakers are not the same!")
>>> round(similarity.item(), 2)
0.98
Wav2Vec2ForPreTraining
class transformers.Wav2Vec2ForPreTraining
< source >( config: Wav2Vec2Config )
参数
- config (Wav2Vec2Config) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有量化器和 VQ
头的 Wav2Vec2 模型。 Wav2Vec2 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中提出,作者是 Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli。
此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法 (例如下载或保存等)。
此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。
forward
< source >( input_values: Optional attention_mask: Optional = None mask_time_indices: Optional = None sampled_negative_indices: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 或 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)
,optional) — 用于避免在填充 token 索引上执行卷积和注意力的掩码。 在[0, 1]
中选择掩码值:- 1 表示 未被掩码 的 token,
- 0 表示 被掩码 的 token。
只有当对应的 processor 具有
config.return_attention_mask == True
时,才应传递attention_mask
。 对于所有 processor 具有config.return_attention_mask == False
的模型,例如 wav2vec2-base,不应 传递attention_mask
,以避免在进行批量推理时性能下降。 对于此类模型,input_values
应仅使用 0 填充,并在不使用attention_mask
的情况下传递。 请注意,这些模型也会根据input_values
是否填充而产生略有不同的结果。 - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions
。 - output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states
。 - return_dict (
bool
, optional) — 是否返回 ModelOutput 对象而不是普通元组。 - mask_time_indices (
torch.BoolTensor
, 形状为(batch_size, sequence_length)
, 可选) — 用于对比损失的掩码提取特征的索引。当处于训练模式时,模型学习预测 config.proj_codevector_dim 空间中被掩码的提取特征。 - sampled_negative_indices (
torch.BoolTensor
, 形状为(batch_size, sequence_length, num_negatives)
, 可选) — 指示哪些量化目标向量用作对比损失中的负采样的向量的索引。预训练的必需输入。
返回值
transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 或一个 torch.FloatTensor
的元组 (如果传递了 return_dict=False
或当 config.return_dict=False
时),包含取决于配置 (Wav2Vec2Config) 和输入的各种元素。
-
loss (可选, 当传递
sample_negative_indices
时返回,torch.FloatTensor
, 形状为(1,)
) — 总损失,为对比损失 (L_m) 和多样性损失 (L_d) 的总和,如 官方论文 中所述。(分类) 损失。 -
projected_states (
torch.FloatTensor
, 形状为(batch_size, sequence_length, config.proj_codevector_dim)
) — 模型投影到 config.proj_codevector_dim 的隐藏状态,可用于预测被掩码的投影量化状态。 -
projected_quantized_states (
torch.FloatTensor
, 形状为(batch_size, sequence_length, config.proj_codevector_dim)
) — 量化的提取特征向量投影到 config.proj_codevector_dim,表示对比损失的正目标向量。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —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 之后的注意力权重,用于计算自注意力头中的加权平均值。
-
contrastive_loss (可选, 当传递
sample_negative_indices
时返回,torch.FloatTensor
, 形状为(1,)
) — 对比损失 (L_m),如 官方论文 中所述。 -
diversity_loss (可选, 当传递
sample_negative_indices
时返回,torch.FloatTensor
, 形状为(1,)
) — 多样性损失 (L_d),如 官方论文 中所述。
Wav2Vec2ForPreTraining 前向方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_wav2vec2 import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
>>> model = Wav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values # Batch size 1
>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
... shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
... features_shape=(batch_size, sequence_length),
... num_negatives=model.config.num_negatives,
... mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
... data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )
>>> with torch.no_grad():
... outputs = model(input_values, mask_time_indices=mask_time_indices)
>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)
>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)
>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
... input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss
TFWav2Vec2Model
class transformers.TFWav2Vec2Model
< source >( config: Wav2Vec2Config *inputs **kwargs )
参数
- config (Wav2Vec2Config) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法加载模型权重。
裸 TFWav2Vec2 模型转换器输出原始隐藏状态,顶部没有任何特定的头部。
此模型继承自 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 函数一样传递输入!
call
< source >( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → 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()。
- 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 标记。
- position_ids (
np.ndarray
或tf.Tensor
,形状为({0})
, 可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - 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
。 此参数只能在 eager 模式下使用,在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回的张量下的hidden_states
。 此参数只能在 eager 模式下使用,在 graph 模式下将使用配置中的值。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用,在 graph 模式下,该值将始终设置为 True。 - training (
bool
, 可选, 默认为 “False”) — 是否在训练模式下使用模型(某些模块(如 dropout 模块)在训练和评估之间具有不同的行为)。
返回值
transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个 tf.Tensor
的元组 (如果传递了 return_dict=False
或当 config.return_dict=False
时),包含取决于配置 (Wav2Vec2Config) 和输入的各种元素。
-
last_hidden_state (
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 之后的注意力权重,用于计算自注意力头中的加权平均值。
TFWav2Vec2Model 前向方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> from transformers import AutoProcessor, TFWav2Vec2Model
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = TFWav2Vec2Model.from_pretrained("facebook/wav2vec2-base-960h")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state
TFWav2Vec2ForSequenceClassification
call
< source >( input_values: tf.Tensor attention_mask: tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False )
TFWav2Vec2ForCTC
类 (class) transformers.TFWav2Vec2ForCTC
< 源码 (source) >( config: Wav2Vec2Config *inputs **kwargs )
参数
- config (Wav2Vec2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有用于连接时序分类 (CTC) 的 language modeling
(语言建模) 头部的 TFWav2Vec2 模型。
此模型继承自 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 函数一样传递输入!
call
< 源码 (source) >( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None 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})
) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。 有关详细信息,请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray
或tf.Tensor
,形状为({0})
,可选) — 用于避免对 padding token 索引执行 attention 的掩码。 掩码值在[0, 1]
中选择:- 1 表示 tokens 未被掩盖 (not masked),
- 0 表示 tokens 被掩盖 (masked)。
- token_type_ids (
np.ndarray
或tf.Tensor
,形状为({0})
,可选) — 用于指示输入的第一部分和第二部分的片段 token 索引。索引在[0, 1]
中选择:- 0 对应于 句子 A token,
- 1 对应于 句子 B token。
- position_ids (
np.ndarray
或tf.Tensor
,形状为({0})
,可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。 - head_mask (
np.ndarray
或tf.Tensor
,形状为(num_heads,)
或(num_layers, num_heads)
,可选) — 用于使自注意力模块的选定 head 无效的掩码。 掩码值在[0, 1]
中选择:- 1 表示 head 未被掩盖 (not masked),
- 0 表示 head 被掩盖 (masked)。
- inputs_embeds (
np.ndarray
或tf.Tensor
,形状为({0}, hidden_size)
,可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递input_values
。 如果您想要比模型的内部嵌入查找矩阵更好地控制如何将input_values
索引转换为关联的向量,这将非常有用。 - output_attentions (
bool
, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息,请参阅返回的 tensors 下的attentions
。 此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参阅返回的 tensors 下的hidden_states
。 此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通的 tuple。 此参数可以在 eager 模式下使用,在 graph 模式下该值将始终设置为 True。 - training (
bool
, 可选, 默认为 `False“) — 是否在训练模式下使用模型(dropout 模块等某些模块在训练和评估之间具有不同的行为)。 - labels (
tf.Tensor
或np.ndarray
,形状为(batch_size, sequence_length)
,可选) — 用于计算掩码语言建模损失的标签。 索引应在[-100, 0, ..., config.vocab_size]
中(参见input_values
文档字符串)。索引设置为-100
的 tokens 将被忽略(掩盖),损失仅针对标签在[0, ..., config.vocab_size]
中的 tokens 计算。
返回值
transformers.modeling_tf_outputs.TFCausalLMOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFCausalLMOutput 或 tf.Tensor
的 tuple(如果传递 return_dict=False
或当 config.return_dict=False
时),包含取决于配置 (Wav2Vec2Config) 和输入的各种元素。
-
loss (
tf.Tensor
,形状为(n,)
,可选,当提供labels
时返回,其中 n 是未被掩盖标签的数量) — 语言建模损失(用于下一个 token 预测)。 -
logits (
tf.Tensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模 head 的预测分数(SoftMax 之前每个词汇表 token 的分数)。 -
hidden_states (
tuple(tf.Tensor)
, 可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) —tf.Tensor
的 tuple(embeddings 的输出一个,每层的输出一个),形状为(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 之后的注意力权重,用于计算自注意力头中的加权平均值。
TFWav2Vec2ForCTC forward 方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFWav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = TFWav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values # Batch size 1
>>> logits = model(input_values).logits
>>> predicted_ids = tf.argmax(logits, axis=-1)
>>> transcription = processor.decode(predicted_ids[0])
>>> # compute loss
>>> target_transcription = "A MAN SAID TO THE UNIVERSE SIR I EXIST"
>>> # Pass transcription as `text` to encode labels
>>> labels = processor(text=transcription, return_tensors="tf").input_ids
>>> loss = model(input_values, labels=labels).loss
FlaxWav2Vec2Model
类 (class) transformers.FlaxWav2Vec2Model
< 源码 (source) >( config: Wav2Vec2Config input_shape: Tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (Wav2Vec2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype
, 可选, 默认为jax.numpy.float32
) — 计算的数据类型。 可以是jax.numpy.float32
、jax.numpy.float16
(在 GPU 上)和jax.numpy.bfloat16
(在 TPU 上)之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,所有计算都将使用给定的
dtype
执行。请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。
裸 Wav2Vec2 模型转换器输出原始隐藏状态,顶部没有任何特定头部。Wav2Vec2 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中被提出,作者是 Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli。
此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。
此模型也是 Flax Linen flax.nn.Module 子类。 将其用作常规 Flax Module,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。
最后,此模型支持固有的 JAX 功能,例如
- 即时 (JIT) 编译 (Just-In-Time (JIT) compilation)
- 自动微分 (Automatic Differentiation)
- 向量化 (Vectorization)
- 并行化 (Parallelization)
__call__
< 源码 (source) >( input_values attention_mask = None mask_time_indices = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None freeze_feature_encoder: bool = False return_dict: Optional = None ) → transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput 或 tuple(torch.FloatTensor)
参数
- input_values (形状为
(batch_size, sequence_length)
的jnp.ndarray
) — 输入原始语音波形的浮点数值。这些值可以通过将.flac
或.wav
音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得,例如 通过 soundfile 库 (pip install soundfile
)。 为了将数组准备成input_values
,应该使用 AutoProcessor 进行填充和转换为jnp.ndarray
类型的张量。 有关详细信息,请参阅 Wav2Vec2Processor.call()。 - attention_mask (形状为
(batch_size, sequence_length)
的jnp.ndarray
, 可选) — 用于避免在 padding 标记索引上执行卷积和注意力的掩码。 掩码值在[0, 1]
中选择:- 1 表示 未被掩盖 的标记,
- 0 表示 被掩盖 的标记。
什么是注意力掩码? .. warning:: 仅当对应的 processor 具有
config.return_attention_mask == True
时,才应传递attention_mask
。 对于所有 processor 具有config.return_attention_mask == False
的模型,例如 wav2vec2-base,不应 传递attention_mask
,以避免在进行批量推理时性能下降。 对于此类模型,input_values
应该简单地用 0 填充,并在不使用attention_mask
的情况下传递。 请注意,这些模型也会根据input_values
是否填充而产生略有不同的结果。 - mask_time_indices (形状为
(batch_size, sequence_length)
的jnp.ndarray
, 可选) — 用于掩盖提取特征以进行对比损失的索引。 当处于训练模式时,模型学习在 config.proj_codevector_dim 空间中预测被掩盖的提取特征。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通的元组。
返回值
transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput 或一个 torch.FloatTensor
元组 (如果传递了 return_dict=False
或当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>
) 和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的jnp.ndarray
) — 模型最后一层的输出处的隐藏状态序列。 -
extract_features (形状为
(batch_size, sequence_length, last_conv_dim)
的jnp.ndarray
) — 模型最后一个卷积层的提取特征向量序列,其中last_conv_dim
是最后一个卷积层的维度。 -
hidden_states (
tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(embeddings 的输出一个,加上每层的输出一个)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
FlaxWav2Vec2PreTrainedModel
的 forward 方法覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> from transformers import AutoProcessor, FlaxWav2Vec2Model
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-large-lv60")
>>> model = FlaxWav2Vec2Model.from_pretrained("facebook/wav2vec2-large-lv60")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(
... ds["speech"][0], sampling_rate=16_000, return_tensors="np"
... ).input_values # Batch size 1
>>> hidden_states = model(input_values).last_hidden_state
FlaxWav2Vec2ForCTC
class transformers.FlaxWav2Vec2ForCTC
< source >( config: Wav2Vec2Config input_shape: Tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (Wav2Vec2Config) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 请查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype
, 可选, 默认为jax.numpy.float32
) — 计算的数据类型。 可以是jax.numpy.float32
、jax.numpy.float16
(在 GPU 上) 和jax.numpy.bfloat16
(在 TPU 上) 之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,则所有计算将使用给定的
dtype
执行。请注意,这仅指定计算的 dtype,并不影响模型参数的 dtype。
带有 language modeling
头部的 Wav2Vec2 模型,用于连接时序分类 (CTC)。Wav2Vec2 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中被提出,作者是 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli。
此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。
此模型也是 Flax Linen flax.nn.Module 子类。 将其用作常规 Flax Module,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。
最后,此模型支持固有的 JAX 功能,例如
- 即时 (JIT) 编译 (Just-In-Time (JIT) compilation)
- 自动微分 (Automatic Differentiation)
- 向量化 (Vectorization)
- 并行化 (Parallelization)
__call__
< source >( input_values attention_mask = None mask_time_indices = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None freeze_feature_encoder: bool = False return_dict: Optional = None ) → transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
参数
- input_values (形状为
(batch_size, sequence_length)
的jnp.ndarray
) — 输入原始语音波形的浮点数值。这些值可以通过将.flac
或.wav
音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得,例如 通过 soundfile 库 (pip install soundfile
)。 为了将数组准备成input_values
,应该使用 AutoProcessor 进行填充和转换为jnp.ndarray
类型的张量。 有关详细信息,请参阅 Wav2Vec2Processor.call()。 - attention_mask (形状为
(batch_size, sequence_length)
的jnp.ndarray
, 可选) — 用于避免在 padding 标记索引上执行卷积和注意力的掩码。 掩码值在[0, 1]
中选择:- 1 表示 未被掩盖 的标记,
- 0 表示 被掩盖 的标记。
什么是注意力掩码? .. warning:: 仅当对应的 processor 具有
config.return_attention_mask == True
时,才应传递attention_mask
。 对于所有 processor 具有config.return_attention_mask == False
的模型,例如 wav2vec2-base,不应 传递attention_mask
,以避免在进行批量推理时性能下降。 对于此类模型,input_values
应该简单地用 0 填充,并在不使用attention_mask
的情况下传递。 请注意,这些模型也会根据input_values
是否填充而产生略有不同的结果。 - mask_time_indices (形状为
(batch_size, sequence_length)
的jnp.ndarray
, 可选) — 用于掩盖提取特征以进行对比损失的索引。 当处于训练模式时,模型学习在 config.proj_codevector_dim 空间中预测被掩盖的提取特征。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通的元组。
返回值
transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一个 torch.FloatTensor
元组 (如果传递了 return_dict=False
或当 config.return_dict=False
时),其中包含各种元素,具体取决于配置 (<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>
) 和输入。
-
logits (形状为
(batch_size, sequence_length, config.vocab_size)
的jnp.ndarray
) — 语言建模头的预测分数(SoftMax 之前每个词汇表标记的分数)。 -
hidden_states (
tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(embeddings 的输出一个,加上每层的输出一个)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
FlaxWav2Vec2PreTrainedModel
的 forward 方法覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> import jax.numpy as jnp
>>> from transformers import AutoProcessor, FlaxWav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-large-960h-lv60")
>>> model = FlaxWav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-large-960h-lv60")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(
... ds["speech"][0], sampling_rate=16_000, return_tensors="np"
... ).input_values # Batch size 1
>>> logits = model(input_values).logits
>>> predicted_ids = jnp.argmax(logits, axis=-1)
>>> transcription = processor.decode(predicted_ids[0])
>>> # should give: "A MAN SAID TO THE UNIVERSE SIR I EXIST"
FlaxWav2Vec2ForPreTraining
class transformers.FlaxWav2Vec2ForPreTraining
< source >( config: Wav2Vec2Config input_shape: Tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (Wav2Vec2Config) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 请查看 from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype
, 可选, 默认为jax.numpy.float32
) — 计算的数据类型。 可以是jax.numpy.float32
、jax.numpy.float16
(在 GPU 上) 和jax.numpy.bfloat16
(在 TPU 上) 之一。这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,则所有计算将使用给定的
dtype
执行。请注意,这仅指定计算的 dtype,并不影响模型参数的 dtype。
带有量化器和 VQ
头的 Wav2Vec2 模型。 Wav2Vec2 在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations 中提出,作者是 Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli。
此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。
此模型也是 Flax Linen flax.nn.Module 子类。 将其用作常规 Flax Module,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。
最后,此模型支持固有的 JAX 功能,例如
- 即时 (JIT) 编译 (Just-In-Time (JIT) compilation)
- 自动微分 (Automatic Differentiation)
- 向量化 (Vectorization)
- 并行化 (Parallelization)
__call__
< source >( input_values attention_mask = None mask_time_indices = None gumbel_temperature: int = 1 params: dict = None dropout_rng: PRNGKey = None gumbel_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None freeze_feature_encoder: bool = False return_dict: Optional = None ) → transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)
参数
- input_values (
jnp.ndarray
,形状为(batch_size, sequence_length)
) — 输入原始语音波形的浮点数值。这些值可以通过将.flac
或.wav
音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得,例如 通过 soundfile 库 (pip install soundfile
)。 为了将数组准备为input_values
,应该使用 AutoProcessor 进行填充并转换为jnp.ndarray
类型的张量。 有关详细信息,请参阅 Wav2Vec2Processor.call()。 - attention_mask (
jnp.ndarray
,形状为(batch_size, sequence_length)
,可选) — 掩码,用于避免在填充 token 索引上执行卷积和注意力机制。掩码值在[0, 1]
中选择:- 1 表示 未被掩盖 的 token,
- 0 表示 已被掩盖 的 token。
什么是注意力掩码? .. warning:: 只有当对应的 processor 具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有 processor 具有config.return_attention_mask == False
的模型,例如 wav2vec2-base,不应 传递attention_mask
,以避免在执行批量推理时性能下降。 对于此类模型,input_values
应该简单地用 0 填充,并在不使用attention_mask
的情况下传递。 请注意,这些模型也会产生略有不同的结果,具体取决于input_values
是否被填充。 - mask_time_indices (
jnp.ndarray
,形状为(batch_size, sequence_length)
,可选) — 用于掩盖对比损失提取特征的索引。当处于训练模式时,模型学习在 config.proj_codevector_dim 空间中预测被掩盖的提取特征。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
,可选) — 是否返回 ModelOutput 而不是普通的元组。
返回值
transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或一个 torch.FloatTensor
元组 (如果传递了 return_dict=False
或当 config.return_dict=False
时),其中包含取决于配置 (<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>
) 和输入的各种元素。
-
loss (可选,当模型处于训练模式时返回,
jnp.ndarray
,形状为(1,)
) — 总损失,为对比损失 (L_m) 和多样性损失 (L_d) 的总和,如 官方论文 中所述。(分类)损失。 -
projected_states (
jnp.ndarray
,形状为(batch_size, sequence_length, config.proj_codevector_dim)
) — 模型投影到 config.proj_codevector_dim 的隐藏状态,可用于预测被掩盖的投影量化状态。 -
projected_quantized_states (
jnp.ndarray
,形状为(batch_size, sequence_length, config.proj_codevector_dim)
) — 投影到 config.proj_codevector_dim 的量化提取特征向量,表示对比损失的正目标向量。 -
hidden_states (
tuple(jnp.ndarray)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(embeddings 的输出一个,加上每层的输出一个)。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
FlaxWav2Vec2ForPreTraining 前向方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在该函数中定义,但应该在之后调用 Module
实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会静默地忽略它们。
示例
>>> import optax
>>> import numpy as np
>>> import jax.numpy as jnp
>>> from transformers import AutoFeatureExtractor, FlaxWav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_flax_wav2vec2 import _compute_mask_indices
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-large-lv60")
>>> model = FlaxWav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-large-lv60")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = feature_extractor(ds["speech"][0], return_tensors="np").input_values # Batch size 1
>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length)
>>> mask_time_indices = _compute_mask_indices((batch_size, sequence_length), mask_prob=0.2, mask_length=2)
>>> outputs = model(input_values, mask_time_indices=mask_time_indices)
>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = optax.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states)
>>> # show that cosine similarity is much higher than random
>>> assert np.asarray(cosine_sim)[mask_time_indices].mean() > 0.5