Wav2Vec2模型由Alexei Baevski,Henry Zhou,Abdelrahman Mohamed,Michael Auli在wav2vec 2.0:一个自监督学习语音表示框架中提出。
论文的摘要如下
我们首次证明,仅从语音音频中学习强大的表示,然后对转录语音进行微调,可以实现比最佳半监督方法更好的效果,同时概念上更简单。wav2vec 2.0 在潜在空间中掩蔽语音输入,并解决通过对联合学习到的潜在表示进行量化所定义的对比任务。使用 Librispeech 的所有标记数据进行的实验在干净/其他测试集上实现了 1.8/3.3 WER。当将标记数据的量降低到一个小时时,wav2vec 2.0 在 100 小时子集上优于之前的最先进技术,同时使用标记数据量降低了100倍。仅使用10分钟的标记数据并在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)
...
预期加速
以下是在transformers的原生实现中,比较facebook/wav2vec2-large-960h-lv60-self
模型的native和flash-attention-2以及sdpa(scale-dot-product-attention)版本纯推理时间的预期加速图。我们显示了在librispeech_asr
clean
验证集上获得的平均加速率。
资源
一篇官方的Hugging Face和社区资源列表(由🌎标示),以帮助您开始使用Wav2Vec2。如果您有兴趣提交要包含在此的资源,请随时开设一个Pull Request,我们将进行审查!资源应该理想地展示一些新东西,而不是重复现有的资源。
- 一篇关于如何利用预训练的Wav2Vec2模型进行情感分类的笔记。[链接](https://colab.research.google.com/github/m3hrdadfi/soxan/blob/main/notebooks/Emotion_recognition_in_Greek_speech_using_Wav2Vec2.ipynb) 🌎
- 这个示例脚本和笔记本支持Wav2Vec2ForCTC。
- 音频分类任务指南
- 一篇关于在🤗 Transformers中利用n-gram提升Wav2Vec2性能的博客文章。[链接](https://huggingface.co/blog/wav2vec2-with-ngram)
- 一篇关于如何使用🤗 Transformers对Wav2Vec2进行英语ASR微调的博客文章。[链接](https://huggingface.co/blog/fine-tune-wav2vec2-english)
- 一篇关于使用🤗 Transformers微调XLS-R进行多语言ASR的博客文章。[链接](https://huggingface.co/blog/fine-tune-xlsr-wav2vec2)
- 一篇关于如何使用Wav2Vec2将任意视频的音频转录成文本创建YouTube字幕的笔记。[链接](https://colab.research.google.com/github/Muennighoff/ytclipcc/blob/main/wav2vec_youtube_captions.ipynb) 🌎
- 一个笔记本演示了如何使用示例脚本和笔记本在英语中Wav2Vec2ForCTC中微调语音识别模型,以及在任何语言中微调语音识别模型。
- 自动语音识别任务指南
🚀 部署
- 一篇关于如何将Wav2Vec2部署到Hugging Face的Transformers与Amazon SageMaker进行自动语音识别的博客文章。[链接](https://www.philschmid.de/automatic-speech-recognition-sagemaker)
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
表达的不同标记数量。模型词汇表大小。定义了通过 inputs_ids 返回的方法 Wav2Vec2Model 可以表示的不同标记。 - hidden_size (
int
, 可选,默认值 768) — 编码层和池化层的维度。 - num_hidden_layers (
int
, 可选,默认值 12) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int
, 可选, 默认为12) — Transformer编码器中每个注意力层的注意力头数量。 - intermediate_size (
int
, 可选, 默认为3072) — Transformer编码器中“中间”层(即前馈层)的维度。 - hidden_act (
str
或function
, 可选, 默认为"gelu"
) — 编码器和池器中的非线性行为函数(函数或字符串)。如果是字符串,支持"gelu"
,"relu"
,"selu"
和"gelu_new"
。 - hidden_dropout (
float
, 可选, 默认为 0.1) — 嵌入层、编码器和池器中所有全连接层的dropout概率。 - activation_dropout (
float
, 可选,默认为0.1) — 完全连结层内激活的dropout比率。 - attention_dropout (
float
, 可选,默认为0.1) — 注意力概率的dropout比率。 - final_dropout (
float
, 可选,默认为0.1) — Wav2Vec2ForCTC 的最终投影层的dropout概率。 - layerdrop (
float
, 可选, 默认值为 0.1) — 层丢弃概率。详见 [LayerDrop 论文](详见 https://arxiv.org/abs/1909.11556) 以获取更多详情。 - initializer_range (
float
, 可选, 默认值为 0.02) — 所有权重矩阵初始化使用的截断_normalInitializer 的标准差。 - layer_norm_eps (
float
, 可选, 默认值为 1e-12) — 层标准化层使用的 epsilon 值。 - feat_extract_norm (
str
, 可选,默认为"group"
) — 应用于特征编码器中 1D 卷积层的归一化方法。取值为"group"
表示仅对第一个 1D 卷积层进行组归一化,或取值为"layer"
表示对全部 1D 卷积层进行层归一化。 - 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 (
整数元组
或整数列表
,可选,默认为(512, 512, 512, 512, 512, 512, 512)
) — 定义特征编码器中每个1D卷积层的输入和输出通道数的整数元组。conv_dim 的长度定义了1D卷积层的数量。 - conv_stride (
整数元组
或整数列表
,可选,默认为(5, 2, 2, 2, 2, 2, 2)
) — 定义特征编码器中每个1D卷积层的步长的整数元组。《conv_stride》的长度定义了卷积层的数量,并且必须与`conv_dim`的长度匹配。 - conv_kernel (
元组[int]
或列表[int]
,可选,默认为(10, 3, 3, 3, 3, 3, 3)
) — 定义特征编码器中每个1D卷积层核大小的整数元组。由于open the links - conv_bias (
bool
,可选,默认为False
) — 1D卷积层是否有偏差。 - num_conv_pos_embeddings (
int
,可选,默认为 128) — 卷积位置编码的数量。定义1D卷积位置编码层的核大小。 - 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
,默认为 可选 ,为0.05)— 沿时间轴所有特征向量中将被掩码的比例(介于0和1之间)。掩码过程在每个轴上生成 mask_time_problen(time_axis)/mask_time_length 个独立的掩码。如果从每个特征向量被选为要掩码的向量跨度起始点的概率理性出发,mask_time_prob 应为 `prob_vector_start`mask_time_length。请注意,重叠可能降低实际掩码向量的比例。这仅在 apply_spec_augment 为 True 时相关。
- mask_time_length (
int
,默认为 可选 ,为10)— 沿时间轴的向量跨度长度。 - mask_time_min_masks (
int
,默认为 可选 ,为2),— 沿时间轴生成长度为 mask_feature_length 的掩码的最小数量,每个时间步长,不考虑 mask_feature_prob。仅在 "mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks" 时相关 - mask_feature_prob (
float
,可选,默认为0.0)— 在特征轴上被遮覆的所有特征向量的百分比(介于0和1之间)。遮覆过程会在轴上生成 “mask_feature_problen(feature_axis)/mask_time_length” 个独立的遮覆掩码。如果从每个特征向量被选为要遮覆的向量范围起始点的概率来推理,则`mask_feature_prob` 应为 `prob_vector_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_codevector_groups (
int
, 可选,默认为2) — 乘积码字量化中的代码字组数。 - contrastive_logits_temperature (
float
, 可选,默认为0.1) — 对比损失中的温度参数kappa。 - feat_quantizer_dropout (
float
, 可选,默认为0.0) — 量化器使用的特征编码器输出的dropout概率。 - num_negatives (
int
, 可选, 默认为100) — 对比损失的负样本数量。 - codevector_dim (
int
, 可选, 默认为256) — 量化特征向量的维数。 - proj_codevector_dim (
int
, 可选, 默认为256) — 量化和转换器和特征最后投影的维数。 - 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(《整数》, 可选, 默认为 256)— 分类前的投影维度。
- tdnn_dim(《整数元组》或《整数列表》, 可选, 默认为
(512, 512, 512, 512, 1500)
)— 定义 XVector 模型中 TDNN 模块的每个 1D 卷积层输出通道数的整数元组。tdnn_dim 的长度定义了 TDNN 层的数量。 - tdnn_kernel(《整数元组》或《整数列表》, 可选, 默认为
(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
为真时相关。 - adapter_stride (
int
, 可选,默认为2) — 适配器网络中卷积层的步长。仅当add_adapter
为真时相关。 - num_adapter_layers (
int
, 可选,默认为3) — 适配器网络中应该使用的卷积层的数量。仅当add_adapter
为真时相关。 - adapter_attn_dim (
int
, 可选) — 每个注意力块中使用的注意力适配器权重的维度。使用注意力适配器的模型示例是 facebook/mms-1b-all。 - output_hidden_size (
int
, optional) — 编码输出层的维度。如果没有定义,默认为hidden-size。只有当add_adapter is True
时才相关。
这是存储Wav2Vec2模型配置的配置类。它用于根据指定的参数实例化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__
< 源头 >( text: 联合类型 = None text_pair: 联合类型 = None text_target: 联合类型 = None text_pair_target: 联合类型 = None add_special_tokens: 布尔类型 = True padding: 联合类型 = False truncation: 联合类型 = None max_length: 可选 = None stride: 整数类型 = 0 is_split_into_words: 布尔类型 = False pad_to_multiple_of: 可选 = None return_tensors: 联合类型 = None return_token_type_ids: 可选 = None return_attention_mask: 可选 = None return_overflowing_tokens: 布尔类型 = False return_special_tokens_mask: 布尔类型 = False return_offsets_mapping: 布尔类型 = False return_length: 布尔类型 = False verbose: 布尔类型 = 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
) — 在对序列进行编码时是否添加特殊标记。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens
函数,该函数定义了哪些标记会被自动添加到输入ID中。如果你想要自动添加bos
或eos
标记,这将非常有用。 - padding (
bool
,str
或PaddingStrategy,可选,默认为False
) — 激活并控制填充。接受以下值:True
或'longest'
:填充到批次中最长的序列(如果只提供一个序列,则不填充)。'max_length'
:填充到位长度由max_length
参数指定的最大长度,或如果不提供该参数,则填充到模型可接受的输入最大长度。False
或'do_not_pad'
(默认值):不填充(即可以输出包含不同长度序列的批次)。
- stride (
int
, 可选,默认为0) — 如果与max_length
一起设置数字,当return_overflowing_tokens=True
时返回的溢出标记将从截断序列的末尾包含一些标记,从而在截断和溢出序列之间提供一些重叠。此参数的值定义重叠标记的数量。 - is_split_into_words (
bool
, 可选,默认为False
) — 是否输入已预先标记(例如,按单词分割)。如果设置为True
,分词器假定输入已被分割成单词(例如,通过空格分割),并将其标记。这对于 NER 或标记分类非常有用。 - pad_to_multiple_of (
int
, 可选) — 如果设置,则将序列填充为提供值的倍数。需要启用padding
。这对于启用 NVIDIA 硬件 Tensor Cores 的使用特别有用,具备>= 7.5
(Volta) 的计算能力。 - return_tensors (
str
或 TensorType,可选) — 如果设置,将返回张量而不是Python整数列表。可接受值包括: - return_token_type_ids (
bool
,可选) — 是否返回token类型ID。如果默认值不变,将根据数据转换器的默认设置返回token类型ID,由return_outputs
属性定义。 - return_attention_mask (
bool
,可选) — 是否返回注意力掩码。如果默认值不变,则返回注意力掩码,根据数据转换器的默认设置,由return_outputs
属性定义。 - return_length (
bool
, 可选,默认为False
) — 是否返回编码输入的长度。 - verbose (
bool
, 可选,默认为True
) — 是否打印更多信息和警告。**kwargs — 传递给self.tokenize()
方法的参数
返回值
A BatchEncoding 包含以下字段
-
input_ids — 用于向模型输入的标记 ID 列表。
-
token_type_ids — 向模型输入的标记类型 ID 列表(当 `return_token_type_ids=True` 或 "token_type_ids" 在 `self.model_input_names` 中时)。
-
attention_mask — 指定模型应关注的标记的索引列表(当 `return_attention_mask=True` 或 "attention_mask" 在 `self.model_input_names` 中时)。
-
overflowing_tokens — 超过最大长度指定的溢出标记序列列表(当指定 `max_length` 并且 `return_overflowing_tokens=True` 时)。
-
num_truncated_tokens — 被截断的标记数量(当指定 `max_length` 并且 `return_overflowing_tokens=True` 时)。
-
special_tokens_mask — 包含 0 和 1 的列表,其中 1 表示添加了特殊标记,而 0 表示常规序列标记(当 `add_special_tokens=True` 并且 `return_special_tokens_mask=True` 时)。
-
length — 输入的长度(当 `return_length=True` 时)
主要方法用于标记和准备一个或多个序列,一对或多对序列。
解码
< 源代码 >( 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
or Wav2Vec2CTCTokenizerOutput
参数
- token_ids (
Union[int, List[int], np.ndarray, torch.Tensor, tf.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序列转换为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}]
批量解码
< 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]
or Wav2Vec2CTCTokenizerOutput
参数
- sequences (
Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]
) — tokenized input ids的列表。可以通过__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 将一系列列表中的标记 ID 转换为字符串。
设置嵌套多语言字典的目标语言。
Wav2Vec2FeatureExtractor
类 transformers.Wav2Vec2FeatureExtractor
< 源代码 >( feature_size = 1 sampling_rate = 16000 padding_value = 0.0 return_attention_mask = False do_normalize = True **kwargs )
参数
- feature_size (
int
, 可选, 默认为 1) — 提取特征的维度。 - 采样率 (
int
, 可选, 默认为 16000) — 表示音频文件应进行数字化的采样率,以赫兹 (Hz) 为单位。 - 填充值 (
float
, 可选, 默认为 0.0) — 用于填充填充值的价值。 - do_normalize (
bool
, 可选, 默认为True
) — 是否进行零均值单位方差归一化输入。归一化可以帮助显着提高某些模型(例如,wav2vec2-lv60)的性能。 - return_attention_mask (
bool
, optional, 默认为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: 派生 padding: 派生 = False max_length: 可选 = None truncation: bool = False pad_to_multiple_of: 可选 = None return_attention_mask: 可选 = None return_tensors: 派生 = None sampling_rate: 可选 = 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'
:填充到需要用 argumentmax_length
指定的最大长度,如果没有提供该 argument,则填充到模型可接受的最大输入长度。False
或'do_not_pad'
(默认):不填充(即可以输出具有不同长度的序列的批次)。
- max_length (
int
,可选) — 返回列表和(可选)填充长度的最大长度。 - truncation (
bool
) — 激活截断,以剪裁长度超过 max_length 的输入序列到 max_length。 - pad_to_multiple_of (
int
, optional) — 如果设置,则将序列填充到提供值的多倍。这在启用NVIDIA硬件上的Tensor Cores(计算能力
>= 7.5
(Volta))或从序列长度为128的倍数中受益的TPU使用时特别有用。 - return_attention_mask (
bool
, optional) — 返回注意力掩码的标志。如果是默认值,将根据特定特征提取器的默认值返回注意力掩码。已经设置
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 整数列表。可接受值包括: - sampling_rate (
int
,可选)——raw_speech
输入的采样率。强烈建议在前向调用中传递sampling_rate
以防止无声错误。 - padding_value (
float
,可选,默认为 0.0)——
特征化和准备一个或多个序列的主方法。
Wav2Vec2Processor
类 transformers.Wav2Vec2Processor
< 源码 >( feature_extractor tokenizer )
参数
- feature_extractor (
Wav2Vec2FeatureExtractor
) — Wav2Vec2FeatureExtractor 的一个实例。特征提取器是必需的输入。 - tokenizer (PreTrainedTokenizer) — PreTrainedTokenizer 的一个实例。分词器是必需的输入。
构建一个 Wav2Vec2 处理器,该处理器将 Wav2Vec2 特征提取器和 Wav2Vec2 CTC 分词器封装为单个处理器。
Wav2Vec2Processor 提供了 Wav2Vec2FeatureExtractor 和 PreTrainedTokenizer 所具有的所有功能。有关更多信息,请参阅 调用() 和 decode() 的文档字符串。
在正常模式下,该方法将所有参数传递给 Wav2Vec2FeatureExtractor 的 call() 并返回输出。如果在 as_target_processor()
上下文中使用,则该方法将所有参数传递给 PreTrainedTokenizer 的 call()。请参阅上述两个方法的文档字符串以获取更多信息。
在正常模式下,该方法将所有参数传递给 Wav2Vec2FeatureExtractor 的 pad() 并返回输出。如果在 as_target_processor()
上下文中使用,则该方法将所有参数传递给 PreTrainedTokenizer 的 pad()。请参阅上述两个方法的文档字符串以获取更多信息。
save_pretrained
< source >( 保存目录 push_to_hub: bool = False **kwargs )
参数
- save_directory (
str
oros.PathLike
) — 保存特征提取器JSON文件和分词器文件的目录(如果不存在,将创建目录)。 - push_to_hub (
bool
, 可选, 默认为False
) — 在保存模型后是否将其推送到 Hugging Face 模型 Hub。你可以通过repo_id
指定想要推送的存储库(将默认为命名空间中save_directory
的名称)。 - kwargs (
Dict[str, Any]
, 可选) — 传递给 push_to_hub() 方法的附加关键字参数。
将此处理器(特征提取器,分词器……)的属性保存到指定的目录,以便可以使用 from_pretrained() 方法重新加载。
这个类方法仅仅是调用 save_pretrained() 和 save_pretrained() 方法。请参阅上述方法的文档字符串以获取更多信息。
此方法将所有参数传递给 PreTrainedTokenizer 的 batch_decode() 方法。请参阅该方法的文档字符串以获取更多信息。
Wav2Vec2ProcessorWithLM
类 transformers.Wav2Vec2ProcessorWithLM
< 源代码 >( 特征提取器: FeatureExtractionMixin 标记器: PreTrainedTokenizerBase 解码器: BeamSearchDecoderCTC )
参数
- feature_extractor (Wav2Vec2FeatureExtractor 或 SeamlessM4TFeatureExtractor) — Wav2Vec2FeatureExtractor 或 SeamlessM4TFeatureExtractor 的实例。特征提取器是必要输入。
- tokenizer (Wav2Vec2CTCTokenizer) — Wav2Vec2CTCTokenizer 的实例。分词器是必要输入。
- decoder (
pyctcdecode.BeamSearchDecoderCTC
) —pyctcdecode.BeamSearchDecoderCTC
的实例。解码器是必要输入。
构建一个 Wav2Vec2 处理器,它将 Wav2Vec2 特征提取器、Wav2Vec2 CTC 分词器和具有语言模型支持的解码器包装成一个处理器,用于语言模型增强的语音识别解码。
__call__
( *args **kwargs )
补齐
( *args **kwargs )
从预训练模型
( 预训练模型名称或路径 **kwargs )
参数
- 预训练模型名称或路径 (
str
或os.PathLike
) — 这可以是以下之一:- 一个字符串,一个预训练的特征提取器在huggingface.co上的模型库中的模型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
。
请参阅上述方法的文档字符串以获取更多信息。
批量解码
< 来源 >( 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 (
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 的标记将被跳过,除非它们是帧的 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分数偏移量 - lm_score_boundary (
bool
, 可选) — 在评分时kenlm是否尊重边界 - output_word_offsets (
bool
, 可选, 默认为False
) — 是否输出单词偏移量。单词偏移量可以与采样率和模型下采样率结合使用,以计算转录单词的时间戳。 - n_best (
int
, 可选, 默认为1
) — 返回最佳假设的数量。如果n_best
大于 1,返回的text
将是一个字符串列表列表,logit_score
将是一个浮点数列表列表,lm_score
也将是一个浮点数列表列表,外层列表的长度对应于批大小,内层列表的长度对应于返回的假设数量。该值应 >= 1。
批量解码输出与语言模型支持的语音转写。
此函数使用 Python 的多进程。目前,多进程仅在 Unix 系统上可用(参见此 问题)。
如果您正在解码多个批处理,请考虑创建一个 Pool
并将其传递给 batch_decode
。否则,由于将为每次调用创建一个新的 Pool
,因此 batch_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输出向量,表示每个标记的对数概率。 - beam_width (
int
, 可选) — 解码每一步时最大光束数。默认为pyctcdecode的DEFAULT_BEAM_WIDTH。 - beam_prune_logp (
int
, 可选) — 当log-probs小于best_beam_logp+beam_prune_logp时用于剪枝光束的阈值。该值应小于等于0。默认为pyctcdecode的DEFAULT_PRUNE_LOGP。 - token_min_logp (
int
, 可选) — 当token的log-probs低于token_min_logp时会被跳过,除非它们具有某个句子的最大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
, 可选) — 未知标记的日志得分偏移量 - lm_score_boundary (
bool
, 可选) — kenlm在评分时是否尊重边界 - output_word_offsets (
bool
, 可选, 默认为False
) — 是否输出词偏移量。词偏移量可以与采样率和模型下采样率结合使用来计算转写单词的时间戳。 - n_best (
int
, 可选, 默认值为1
) — 返回最佳假设的数量。如果n_best
大于 1,则返回的text
将是一个字符串列表,logit_score
将是一个浮点数列表,lm_score
也是一个浮点数列表,其中这些列表的长度将对应返回的假设数量。该值应 ≥ 1。
解码语言模型支持的输出日志到音频转录。
例子:
>>> # 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 特定输出
类 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
的输出类型,带有转录信息。
类 transformers.modeling_outputs.Wav2Vec2BaseModelOutput
< 源代码 >( last_hidden_state: FloatTensor = None extract_features: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
- last_hidden_state (
torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
) — 模型最后层输出的隐藏状态序列。 - extract_features (
torch.FloatTensor
of shape(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)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — Tuple oftorch.FloatTensor
(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length)
. 注意力权重 soft amendment 后,用于计算 self-attention head 中的加权平均。
以 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
时返回) — 一个形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入层的输出,一个用于每层的输出)。模型的每个层输出以及初始嵌入输出中的隐藏状态。
- attentions (
tuple(torch.FloatTensor)
, 可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 一个形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。注意力softmax后的注意力权重,用于计算自注意力头中的加权平均值。
- contrastive_loss (可选,当传递
sample_negative_indices
时返回,形状为(1,)
的torch.FloatTensor
) — 正如官方论文 所述的对比损失 (L_m)。 - diversity_loss (可选,仅在传递
sample_negative_indices
时返回,形状为(1,)
的torch.FloatTensor
) —— 如官方论文所述 的多样性损失 (L_d)。
Wav2Vec2ForPreTraining 的输出类型,包含潜在的隐藏状态和注意力。
类 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 (
jnp.ndarray
形状为(batch_size, sequence_length, hidden_size)
) —— 模型最后一层的隐藏状态的序列。 - extract_features (
jnp.ndarray
形状(batch_size, sequence_length, last_conv_dim)
) — 模型的最后一层卷积层中提取的特征向量序列,其中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)
。
FlaxWav2Vec2BaseModelOutput
的输出类型,可能包含隐藏状态和注意力。
“返回一个新的对象,用新的值替换指定的字段。
类 transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput
< source >( projected_states: 数组 = None projected_quantized_states: 数组 = None codevector_perplexity: 数组 = None hidden_states: 可选的 = None attentions: 可选的 = 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
参数时返回) — 包含一个形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组的元组(包括嵌入层的输出和一个层的输出)。 - attentions (
tuple(jnp.ndarray)
, 可选,当传递output_attentions=True
或config.output_attentions=True
参数时返回) — 包含一个形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组的元组(每个层各自一个)。
输出类型为 FlaxWav2Vec2ForPreTrainingOutput
,可能包含潜在状态和注意力。
“返回一个新的对象,用新的值替换指定的字段。
Wav2Vec2Model
类 transformers.Wav2Vec2Model
< source >( config: Wav2Vec2Config )
参数
- config (Wav2Vec2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载模型相关的权重,只有配置。查看from_pretrained() 方法来加载模型权重。
Wav2Vec2 模型变压器,输出原始隐藏状态,顶部没有特定的头。Wav2Vec2 由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed 和 Michael Auli 在wav2vec 2.0: 居于自监督学习语音表示的框架中提出。
此模型继承自 PreTrainedModel。请查看类的文档,了解库为所有模型实现的通用方法(例如下载或保存等)。
此模型是 PyTorch 的 torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解与一般使用和行为相关的所有内容。
forward
< 来源 >( input_values: 可选 attention_mask: 可选 = None mask_time_indices: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = 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)
,可选)—— 避免对填充标记索引执行卷积和注意力的掩码。掩码值选择在[0, 1]
:- 对于未掩码的标记,值为 1,
- 对于掩码的标记,值为 0。
attention_mask
应仅在对应的处理器有config.return_attention_mask == True
时传递。对于所有处理器config.return_attention_mask == False
的模型,例如 wav2vec2-base,attention_mask
应**不**传递,避免批量推理时性能下降。对于此类模型,应仅用 0 进行填充的input_values
并传递,无需传递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)
A transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或一个字典(如果 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
类 transformers.Wav2Vec2ForCTC
< source >( config target_lang: Optional = None )
参数
- config (Wav2Vec2Config) — 包含所有模型参数的模型配置类。使用配置文件初始化不会加载模型相关的权重,只有配置。查看 from_pretrained() 方法以加载模型权重。
- target_lang (
str
, 可选) — 适配器权重语言id。适配器权重存储在格式为 adapter..safetensors 或 adapter. .bin。只有在使用适配器的 Wav2Vec2ForCTC 实例时相关。默认使用 ‘eng’。
Wav2Vec2 模型在上方带有对序列分类时间连接 (CTC) 的 语言建模
头部。Wav2Vec2 由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed 和 Michael Auli 提出,发表在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations。
此模型继承自 PreTrainedModel。请查看类的文档,了解库为所有模型实现的通用方法(例如下载或保存等)。
此模型是 PyTorch 的 torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解与一般使用和行为相关的所有内容。
forward
< source >( input_values: 可选 attention_mask: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None labels: 可选 = None ) → transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)
参数
- input_values (形状为
(batch_size, sequence_length)
的torch.FloatTensor
)—— 输入原始语音波形浮点数值。可以通过将.flac
或.wav
音频文件加载为List[float]
或numpy.ndarray
类型的数组来获取值,例如通过 soundfile 库(pip install soundfile
)。为了将数组准备为input_values
,应该使用 AutoProcessor 进行填充和转换为形状为torch.FloatTensor
的张量。有关详细信息,请参阅 Wav2Vec2Processor.call()。 - attention_mask (形状为
(batch_size, sequence_length)
的可选torch.LongTensor
)—— 用于避免在填充令牌索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]
:- 1 表示 未掩码 的令牌,
- 0 表示 掩码 的令牌。
attention_mask
只应在相应的处理器具有config.return_attention_mask == True
时传入。对于处理器具有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
of shape(batch_size, target_length)
, optional) — 连接时序分类的标签。注意,target_length
必须小于或等于输出对数序列的长度。索引从[-100, 0, ..., config.vocab_size - 1]
中选择。所有设置为-100
的标签将被忽略(遮蔽),仅对[0, ..., config.vocab_size - 1]
中的标签计算损失。
返回值
transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.CausalLMOutput 或一个 torch.FloatTensor
的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时)包含各种元素,具体取决于配置(Wav2Vec2Config)和输入。
-
loss (
torch.FloatTensor
of shape(1,)
, optional, returned whenlabels
is provided) — 语言模型损失(用于下一个标记预测)。 -
logits (
torch.FloatTensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言模型头部的预测分数(SoftMax 之前的每个词汇的分数)。 -
hidden_states (
tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.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
) — 必须是现有适配器权重的语言标识符。适配器权重以 adapter..safetensors 或 adapter. .bin 格式存储。 - force_load (
bool
, 默认值为True
) — 是否即使target_lang
与self.target_lang
匹配,也要加载权重。 - cache_dir (
Union[str, os.PathLike]
, 可选) — 如果不使用标准缓存,则将下载的预训练模型配置缓存到该目录的路径。 - force_download (
bool
, 可选, 默认为False
) — 是否强制下载数据集,覆盖已存在的缓存版本,只适用于模型权重和配置文件。 resume_download — 已废弃且将被忽略。所有下载数据现在默认都是在可能的情况下自动恢复。将在 v5 版本的 Transformers 中移除。 - proxies (
Dict[str, str]
, 可选) — 以协议或端点为键的代理服务器字典,例如,{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}
。在每次请求中使用这些代理服务器。 - local_files_only(
bool
, 可选, 默认为False
) — 是否只检查本地文件(即不尝试下载模型)。 - token (
str
或bool
,可选) — 用作远程文件的 HTTP 令牌认证的令牌。如果为True
,或未指定,将使用在运行huggingface-cli login
时生成的令牌(存储在~/.huggingface
中)。 - revision (
str
,可选,默认值为"main"
) — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID,因为我们使用基于 git 的系统在 huggingface.co 上存储模型和其他工件,因此revision
可以是 git 允许的任何标识符。 - 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
< source >( config )
参数
- config (Wav2Vec2Config) — 模型配置类,包含所有模型参数。使用配置文件初始化模型时不加载与模型关联的权重,只加载配置。有关加载模型权重的细节,请参阅from_pretrained() 方法。
在序列分类头(wav2vec2的池化输出上的线性层)之上的Wav2Vec2模型,用于如SUPERB关键词检测等任务。
Wav2Vec2在Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli发表的wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出。
此模型继承自 PreTrainedModel。请查看类的文档,了解库为所有模型实现的通用方法(例如下载或保存等)。
此模型是 PyTorch 的 torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解与一般使用和行为相关的所有内容。
forward
< 来源 >( input_values: 可选 attention_mask: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None labels: 可选 = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_values (
torch.FloatTensor
of shape(batch_size, sequence_length)
) — 输入原始语音波形浮点值。值可以通过将flac 或 wav 音频文件加载到类型为List[float]
或numpy.ndarray
的数组中获得,例如 通过 soundfile 库(pip install soundfile
)。要将数组准备为input_values
,应使用 AutoProcessor 进行填充和转换为类型为torch.FloatTensor
的张量。有关详细信息,请参见 Wav2Vec2Processor.call()。 - attention_mask (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 用于避免对填充标记索引执行卷积和注意力的掩码。选定的掩码值在[0, 1]
范围内:- 1 表示 未掩码 的标记;
- 0 表示 掩码 的标记。
只有当相应的处理器具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,例如 wav2vec2-base,进行批量推理时,不应传递attention_mask
以避免性能下降。对于此类模型,应简单地用 0 填充input_values
并不带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
时),包含各种元素,具体取决于配置和输入。
-
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)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.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 的 forward 方法,覆盖了特殊方法 __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
类 transformers.Wav2Vec2ForAudioFrameClassification
< 源码 >( config )
参数
- config (Wav2Vec2Config) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载模型相关的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
Wav2Vec2 模型顶部有帧分类头,适用于说话人去个性化等任务。
Wav2Vec2在Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli发表的wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出。
此模型继承自 PreTrainedModel。请查看类的文档,了解库为所有模型实现的通用方法(例如下载或保存等)。
此模型是 PyTorch 的 torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解与一般使用和行为相关的所有内容。
forward
参数
- attention_mask (
torch.LongTensor
的形状为(batch_size, sequence_length)
, 可选) — 用于避免在填充标记索引上执行卷积和注意力的掩码。选定的掩码值在[0, 1]
范围内:- 1 表示 未掩码 的标记,
- 0 表示 掩码 的标记。
attention_mask
只应在没有config.return_attention_mask == True
的处理器的对应情况下传递。对于所有处理器具有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
of shape(batch_size,)
, 可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
范围内。如果config.num_labels == 1
,则计算回归损失(均方 loss),如果config.num_labels > 1
,则计算分类损失(交叉熵)。
返回值
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.TokenClassifierOutput 或一个由 torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
),其包含根据配置(Wav2Vec2Config)和输入而变化的各种元素。
-
loss (
torch.FloatTensor
of shape(1,)
, 可选, 当提供labels
时返回) — 分类 loss。 -
logits (
torch.FloatTensor
of shape(batch_size, sequence_length, config.num_labels)
) — 分类得分(SoftMax 之前)。 -
hidden_states (
tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.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 前向方法,重写了 __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
类 transformers.Wav2Vec2ForXVector
< 源 >( config )
参数
- config (Wav2Vec2Config) — 包含模型所有参数的模型配置类。用配置文件初始化时不会加载模型相关的权重,只有配置。请查看 from_pretrained() 方法来加载模型权重。
Wav2Vec2 模型,搭载 XVector 特征提取头,用于像说话人识别这样的任务。
Wav2Vec2在Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli发表的wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出。
此模型继承自 PreTrainedModel。请查看类的文档,了解库为所有模型实现的通用方法(例如下载或保存等)。
此模型是 PyTorch 的 torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解与一般使用和行为相关的所有内容。
forward
< 来源 >( input_values: 可选 attention_mask: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None labels: 可选 = None ) → transformers.modeling_outputs.XVectorOutput 或 tuple(torch.FloatTensor)
参数
- input_values (
torch.FloatTensor
of shape(batch_size, sequence_length)
) — 输入原始语音波形的浮点值。这些值可以通过将.flac
或.wav
音频文件加载到类型为List[float]
或numpy.ndarray
的数组中获取,例如通过 soundfile 库(pip install soundfile
)。要将数组准备成input_values
,应使用 AutoProcessor 进行填充和转换为类型为torch.FloatTensor
的张量。有关详情,请参阅 Wav2Vec2Processor.call()。 - attention_mask (
torch.LongTensor
of shape(batch_size, sequence_length)
, 可选) — 避免在填充标记索引上执行卷积和注意力操作的掩码。选取的掩码值在[0, 1]
:- 1 表示 未屏蔽 的标记,
- 0 表示 屏蔽 的标记。
attention_mask
只应在其对应的处理器有config.return_attention_mask == True
时传递。对于所有其处理器有config.return_attention_mask == False
的模型,例如 wav2vec2-base,应 不 传递attention_mask
以避免批推理时的性能下降。对于此类模型,应仅将input_values
填充为 0 并传递,无需attention_mask
。请注意,这些模型的结果也略有所不同,取决于input_values
是否被填充。 - output_attentions (
bool
, 可选) — 是否要返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的attentions
张量。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。请参考返回的tensor中关于hidden_states
的更多详细信息。 - return_dict (
bool
, 可选) — 是否返回ModelOutput而不是一个普通的元组。 - labels (
torch.LongTensor
of shape(batch_size,)
, 可选) — 计算序列分类/回归损失的标签。索引应该在[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
时) encompasses various elements depending on the configuration (Wav2Vec2Config) and inputs.
-
loss (
torch.FloatTensor
of shape(1,)
, 可选, 当提供labels
时返回) — 分类 loss。 -
logits (
torch.FloatTensor
of shape(batch_size, config.xvector_output_dim)
) — 在AMSoftmax之前的分类隐藏状态。 -
embeddings (
torch.FloatTensor
of shape(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的前向方法覆盖了特殊的__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
类 transformers.Wav2Vec2ForPreTraining
< 资源 >( config: Wav2Vec2Config )
参数
- config (Wav2Vec2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不加载模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
具有量化和顶部 VQ
头的 Wav2Vec2 模型。Wav2Vec2 由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed 和 Michael Auli 在 wav2vec 2.0: 一种自监督学习语音表示的框架一文中提出。
此模型继承自 PreTrainedModel。请查看类的文档,了解库为所有模型实现的通用方法(例如下载或保存等)。
此模型是 PyTorch 的 torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解与一般使用和行为相关的所有内容。
forward
< 来源 >( input_values: 可选 attention_mask: 可选 = None mask_time_indices: 可选 = None sampled_negative_indices: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)
参数
- input_values (
torch.FloatTensor
of shape(batch_size, sequence_length)
) — 输入原始语音波形浮点值。值可以通过将.flac
或.wav
音频文件加载到类型为List[float]
或numpy.ndarray
的数组中来获得,例如通过soundfile库实现的(pip install soundfile
)。为了将数组准备成input_values
,应该使用AutoProcessor进行填充并将类型转换为torch.FloatTensor
张量。请参见Wav2Vec2Processor.call()以了解详细信息。 - attention_mask(
torch.LongTensor
形状为(batch_size, sequence_length)
,可选) — 用于避免在填充令牌索引处执行卷积和注意力操作的掩码。掩码值选择在[0, 1]
:- 1 表示 未掩码 令牌,
- 0 表示 掩码 令牌。
attention_mask
仅当相应的处理器有config.return_attention_mask == True
时才应传递。对于所有处理器配置为config.return_attention_mask == False
的模型,例如 wav2vec2-base,attention_mask
应 不 传递,以避免在批量推理时性能下降。对于此类模型,应直接使用 0 进行填充的input_values
并传递,而不使用attention_mask
。请注意,这些模型的结果也会因是否填充input_values
而略有不同。 - output_attentions(
bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
布尔值
, 可选) — 是否返回所有层的隐藏状态。有关更多信息,请参阅返回的标量下的hidden_states
。 - return_dict (
布尔值
, 可选) — 是否返回一个ModelOutput而非纯元组。 - mask_time_indices (
torch.BoolTensor
of shape(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)
A transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 或一个包含多个元素的元组,具体取决于配置(Wav2Vec2Config)和输入的 torch.FloatTensor
(如果传递了 return_dict=False
或当 config.return_dict=False
)。
-
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 前向方法,覆盖了 __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 模型是一个 τxf bare transformer,它的输出是原始隐藏状态,没有顶部的任何特定头。
此模型继承自 TFPreTrainedModel。请参阅超类文档,了解库为所有模型实现的一般方法(例如下载或保存、调整输入嵌入、剪枝头部等)。
此模型同时也是 keras.Model 的子类。可以将它作为常规的 TF 2.0 Keras 模型使用,并参考 TF 2.0 文档以了解所有与通用使用和行为相关的事项。
transformers
中的 TensorFlow 模型和层级接受两种输入格式
- 将所有输入作为关键字参数(类似于 PyTorch 模型),或者
- 将所有输入作为第一个位置参数中的列表、元组或字典。
第二种格式被支持的原因是 Keras 方法在向模型和层传递输入数据时更倾向于使用这种格式。由于这种支持,当使用如 model.fit()
这样的方法时,对于您来说事情应该"刚好正常工作" - 只需要以 model.fit()
支持的任何格式传递您的输入和标签!但是,如果您想在 fit()
和 predict()
这类 Keras 方法之外使用第二种格式,例如在创建自己的层或使用 Keras Functional
API 的模型时,有三种可能的方法可以收集所有带有第一个位置参数的输入 Tensor
- 只有一个 Tensor 与
input_values
和没有其他内容:model(input_values)
- 一个长度可变的列表,包含一个或多个按照文档字符串中给出的顺序输入 Tensor:
model([input_values, attention_mask])
或model([input_values, attention_mask, token_type_ids])
- 一个字典,有一个或多个与文档字符串中给出的输入名称关联的输入 Tensor:
model({"input_values": input_values, "token_type_ids": token_type_ids})
注意,当通过 子类化 来创建模型和层时,您不需要担心这些问题,因为您可以像传递任何其他 Python 函数的输入一样传递输入!
调用
< 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: 可选[bool] = None output_hidden_states: 可选[bool] = None return_dict: 可选[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]
and each example must have the shape({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 模式下可用,在图模式下将使用配置中的值。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。更多细节请见返回的张量中的hidden_states
。此参数只在急切模式中使用,在图模式下将使用配置中的值。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是简单的元组。此参数可以在急切模式下使用,在图模式下此值将始终设置为 True。 - training (
bool
, 可选, 默认为 `False“) — 是否使用模型进行训练模式(某些模块(如dropout模块)在不同训练和评估模式下有不同的行为)。
返回值
transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
A 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时返回) — 一个形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组,表示嵌入层的输出及每一层的输出。每层输出的隐藏状态以及初始嵌入输出。
-
attentions (
tuple(tf.Tensor)
,可选,当传递了output_attentions=True或者config.output_attentions=True时返回) — 一个形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组,包含了每一层的注意力矩阵。注意力 softmax 后的注意力权重,用于在自注意力头中计算加权平均。
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
TFWav2Vec2Model
调用
< 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
类 transformers.TFWav2Vec2ForCTC
< source >( config: Wav2Vec2Config *inputs **kwargs )
参数
- config (Wav2Vec2Config) — 模型配置类,包含所有模型参数。用配置文件初始化不会加载模型相关的权重,仅加载配置。查看 from_pretrained() 方法加载数据权重。
TFWav2Vec2 模型,在语音识别连接主义时间分类(CTC)上方添加了语言模型头。
此模型继承自 TFPreTrainedModel。请参阅超类文档,了解库为所有模型实现的一般方法(例如下载或保存、调整输入嵌入、剪枝头部等)。
此模型同时也是 keras.Model 的子类。可以将它作为常规的 TF 2.0 Keras 模型使用,并参考 TF 2.0 文档以了解所有与通用使用和行为相关的事项。
transformers
中的 TensorFlow 模型和层级接受两种输入格式
- 将所有输入作为关键字参数(类似于 PyTorch 模型),或者
- 将所有输入作为第一个位置参数中的列表、元组或字典。
第二种格式被支持的原因是 Keras 方法在向模型和层传递输入数据时更倾向于使用这种格式。由于这种支持,当使用如 model.fit()
这样的方法时,对于您来说事情应该"刚好正常工作" - 只需要以 model.fit()
支持的任何格式传递您的输入和标签!但是,如果您想在 fit()
和 predict()
这类 Keras 方法之外使用第二种格式,例如在创建自己的层或使用 Keras Functional
API 的模型时,有三种可能的方法可以收集所有带有第一个位置参数的输入 Tensor
- 只有一个 Tensor 与
input_values
和没有其他内容:model(input_values)
- 一个长度可变的列表,包含一个或多个按照文档字符串中给出的顺序输入 Tensor:
model([input_values, attention_mask])
或model([input_values, attention_mask, token_type_ids])
- 一个字典,有一个或多个与文档字符串中给出的输入名称关联的输入 Tensor:
model({"input_values": input_values, "token_type_ids": token_type_ids})
注意,当通过 子类化 来创建模型和层时,您不需要担心这些问题,因为您可以像传递任何其他 Python 函数的输入一样传递输入!
调用
< 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]
orDict[str, np.ndarray]
and each example must have the shape({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 模式下使用,在图模式下将使用配置中的值。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而非普通元组。此参数可以在 eager 模式下使用,在图模式下此值始终为 True。 - training (
bool
, 可选,默认 False) — 是否将在训练模式下使用模型(一些模块,如 dropout 模块,在训练和评估模式之间有不同的行为)。 - labels (
tf.Tensor
或np.ndarray
的形状为(batch_size, sequence_length)
,可选) – 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]
范围内(参见input_values
文档字符串)。设置为-100
的索引将被忽略(掩码),仅对[0, ..., config.vocab_size]
范围内具有标签的标记计算损失
返回值
transformers.modeling_tf_outputs.TFCausalLMOutput 或 tuple(tf.Tensor)
A transformers.modeling_tf_outputs.TFCausalLMOutput 或 tf.Tensor
的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包括各种元素,具体取决于配置(Wav2Vec2Config)和输入。
-
loss (
tf.Tensor
的形状为(n,)
,可选,其中 n 是非掩码标签的数量,当提供了labels
时返回)– 语言建模损失(用于下一个标记预测)。 -
logits (
tf.Tensor
的形状为(batch_size, sequence_length, config.vocab_size)
)– 语言建模头部的预测得分(在 SoftMax 之前对每个词汇表标记的得分)。 -
hidden_states (
tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
时返回或当config.output_hidden_states=True
时返回)– 包含不同层的输出tf.Tensor
的元组(一个用于嵌入层的输出,一个用于每个层的输出)的形状为(batch_size, sequence_length, hidden_size)
。每层输出的隐藏状态以及初始嵌入输出。
-
attentions (
tuple(tf.Tensor)
,可选,当传递了output_attentions=True或者config.output_attentions=True时返回) — 一个形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组,包含了每一层的注意力矩阵。注意力 softmax 后的注意力权重,用于在自注意力头中计算加权平均。
TFWav2Vec2ForCTC 前向方法覆盖了 __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
< 来源 >( config: Wav2Vec2Config input_shape: 元组 = (1, 1024) seed: int = 0 dtype: dtype = <类 '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
进行。请注意,这仅指定了计算的数据类型,并不会影响模型参数的数据类型。
Wav2Vec2 模型变压器,输出原始隐藏状态,顶部没有特定的头。Wav2Vec2 由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed 和 Michael Auli 在wav2vec 2.0: 居于自监督学习语音表示的框架中提出。
此模型继承自 FlaxPreTrainedModel。检查超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入层大小、剪枝头部等)。
此模型也是Flax Linen flax.nn.Module的子类。将其作为常规Flax模块使用,并参考Flax文档了解有关通用用法和行为的所有内容。
最后,此模型支持固有的JAX功能,例如:
__call__
< 源 >( 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 or 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
,可选) — 代表填充标记索引,避免在填充标记上进行卷积和注意力操作。掩码值选择范围为[0, 1]
:- 1 代表未掩码的标记,
- 0 代表已掩码的标记。
什么是注意力掩码? .. 警告 :: 只有当对应的处理器具有
config.return_attention_mask == True
时才应该传入attention_mask
。对于处理器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 (布尔值,可选) — 是返回所有注意力层的注意力张量。有关更多详情,请参阅返回的树人中的
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 或当 return_dict=False
被传递或当 config.return_dict=False
时,包括各种元素的张量元组(torch.FloatTensor
),具体取决于配置(<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>
)和输入。
-
last_hidden_state (
jnp.ndarray
形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。 -
extract_features (
jnp.ndarray
形状为(batch_size, sequence_length, last_conv_dim)
) — 模型最后一层卷积层的提取特征向量序列,其中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
的元组(一个用于嵌入层的输出,一个用于每个层的输出)。每层输出的隐藏状态以及初始嵌入输出。
-
attentions (
tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 包含形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
的元组(每个层一个)。注意力 softmax 后的注意力权重,用于在自注意力头中计算加权平均。
FlaxWav2Vec2PreTrainedModel
前向方法覆盖了 __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
类 transformers.FlaxWav2Vec2ForCTC
< 源代码 >( config: Wav2Vec2Config input_shape: 元组 = (1, 1024) seed: int = 0 dtype: dtype = <类 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (Wav2Vec2配置) — 包含模型所有参数的模型配置类。使用配置文件初始化时,不会加载与模型关联的权重,只有配置。请查看from_pretrained() 方法以加载模型权重。
- dtype (
jax.numpy.dtype
, 可选, 默认为jax.numpy.float32
) - 计算的数据类型。可以是jax.numpy.float32
、jax.numpy.float16
(在GPU上)和jax.numpy.bfloat16
(在TPU上)。这可以用来在GPU或TPU上启用混合精度训练或半精度推理。如果指定了,所有计算都将使用给定的
dtype
进行。注意:这仅指定了计算的数据类型,不会影响模型参数的数据类型。
Wav2Vec2 模型在上方带有对序列分类时间连接 (CTC) 的 语言建模
头部。Wav2Vec2 由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed 和 Michael Auli 提出,发表在 wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations。
此模型继承自 FlaxPreTrainedModel。检查超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入层大小、剪枝头部等)。
此模型也是Flax Linen flax.nn.Module的子类。将其作为常规Flax模块使用,并参考Flax文档了解有关通用用法和行为的所有内容。
最后,此模型支持固有的JAX功能,例如:
__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 or tuple(torch.FloatTensor)
参数
- input_values (
jnp.ndarray
of shape(batch_size, sequence_length)
) — 输入的原始语音波形浮点值。可以通过将.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
,可选) — 避免在填充标记索引处执行卷积和注意力的掩码。选取的掩码值在[0, 1]
内:- 1,对应未被掩码的标记;
- 0,对应被掩码的标记。
什么是注意力掩码? .. warning::
attention_mask
只应在对应的处理器具备config.return_attention_mask == True
时传入。对于所有处理器中config.return_attention_mask == False
的模型,例如 wav2vec2-base,在批量推理时应该 不传入attention_mask
以避免性能下降。对于此类模型,input_values
应简单地进行填充并传入,无需attention_mask
。请注意,这些模型生成的结果会根据input_values
是否填充而略有不同。 - mask_time_indices (形状为
(batch_size, sequence_length)
的jnp.ndarray
,可选) — 用于对比损失的提取特征掩码索引。在训练模式下,模型学习在 config.proj_codevector_dim 空间中预测掩码的提取特征。 - output_attentions(《布尔值》,可选)— 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的
attentions
。 - output_hidden_states(《布尔值》,可选)— 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的
hidden_states
。 - return_dict(《布尔值》,可选)— 是否返回ModelOutput而不是普通元组。
返回值
transformers.modeling_flax_outputs.FlaxMaskedLMOutput或tuple(torch.FloatTensor)
transformers.modeling_flax_outputs.FlaxMaskedLMOutput或一个包含torch.FloatTensor
的元组(如果传递了return_dict=False
或者当config.return_dict=False
时),这取决于配置和输入。
-
logits(《jnp.ndarray形状为(《批次大小`, 《序列长度`, 《配置词汇表大小`))— 语言模型头的预测分数(在SoftMax之前的每个词汇表 tokens 的得分)。
-
hidden_states (
tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 包含形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
的元组(一个用于嵌入层的输出,一个用于每个层的输出)。每层输出的隐藏状态以及初始嵌入输出。
-
attentions (
tuple(jnp.ndarray)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回) — 包含形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
的元组(每个层一个)。注意力 softmax 后的注意力权重,用于在自注意力头中计算加权平均。
FlaxWav2Vec2PreTrainedModel
前向方法覆盖了 __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
类 transformers.FlaxWav2Vec2ForPreTraining
< 来源 >( config: Wav2Vec2Config input_shape: 元组 = (1, 1024) seed: int = 0 dtype: dtype = <类 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- 配置 (Wav2Vec2Config) —— 包含模型所有参数的模型配置类。通过配置文件初始化不会加载模型相关的权重,只加载配置。查看from_pretrained()方法以加载模型权重。
- dtype (
jax.numpy.dtype
, 可选, 默认为jax.numpy.float32
) — 计算的数据类型。可以是jax.numpy.float32
、jax.numpy.float16
(在GPU上)以及jax.numpy.bfloat16
(在TPU上)。这可以用于在GPU或TPU上启用混合精度训练或半精度推理。如果指定了所有计算将以给定的
dtype
执行。请注意,这仅指定计算的数据类型,不会影响模型参数的数据类型。
具有量化和顶部 VQ
头的 Wav2Vec2 模型。Wav2Vec2 由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed 和 Michael Auli 在 wav2vec 2.0: 一种自监督学习语音表示的框架一文中提出。
此模型继承自 FlaxPreTrainedModel。检查超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入层大小、剪枝头部等)。
此模型也是Flax Linen flax.nn.Module的子类。将其作为常规Flax模块使用,并参考Flax文档了解有关通用用法和行为的所有内容。
最后,此模型支持固有的JAX功能,例如:
__call__
< 源代码 >( 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 or tuple(torch.FloatTensor)
参数
- input_values (
jnp.ndarray
of shape(batch_size, sequence_length)
) — 输入原始语音波形的浮点值。这些值可以通过将.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
,可选)—— 用于避免在填充标记索引上执行卷积和注意力运算的掩码。掩码值选择在[0, 1]
之间:- 1 代表未经掩码的标记,
- 0 代表掩码的标记。
什么是注意力掩码? .. warning:: 只有当相应的处理器有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有处理器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
。 - 输出状态列表 (
bool
, 可选) — 是否返回所有层的隐藏状态。请参阅返回张量下的hidden_states
以获取更多详细信息。 - 返回字典 (
bool
, 可选) — 是否返回 ModelOutput 而不是纯 tuple。
返回值
transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或一个由 torch.FloatTensor
组成的 tuple(如果传递了 return_dict=False
或当 config.return_dict=False
时),根据配置(<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>
)和输入的不同而包含不同的元素。
-
loss (可选,当模型处于训练模式时返回,
jnp.ndarray
,形状(1,)
) — 总损失是对比损失(L_m)和多样性损失(L_d)的和,正如在 官方论文 所述。 (分类)损失。 -
投影状态 (
jnp.ndarray
,形状(batch_size, sequence_length, config.proj_codevector_dim)
) — 模型隐藏状态投影到 config.proj_codevector_dim 的状态,可用于预测掩码的投影量化状态。 -
投影量化状态 (
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
的元组(一个用于嵌入层的输出,一个用于每个层的输出)。每层输出的隐藏状态以及初始嵌入输出。
-
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