Transformers--4-37-中文文档-三十九-
Transformers 4.37 中文文档(三十九)
Speech2Text2
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/speech_to_text_2
概述
Speech2Text2 模型与 Wav2Vec2 一起用于大规模自监督和半监督学习的语音翻译中提出的语音翻译模型,作者为 Changhan Wang,Anne Wu,Juan Pino,Alexei Baevski,Michael Auli,Alexis Conneau。
Speech2Text2 是一种仅解码器变换器模型,可与任何语音仅编码器一起使用,例如 Wav2Vec2 或 HubERT 用于语音到文本任务。请参考 SpeechEncoderDecoder 类,了解如何将 Speech2Text2 与任何语音仅编码器模型结合使用。
此模型由Patrick von Platen贡献。
原始代码可以在这里找到。
使用提示
-
Speech2Text2 在 CoVoST 语音翻译数据集上取得了最先进的结果。有关更多信息,请参阅官方模型。
-
Speech2Text2 始终在 SpeechEncoderDecoder 框架内使用。
-
Speech2Text2 的分词器基于fastBPE。
推理
Speech2Text2 的 SpeechEncoderDecoderModel 模型接受来自语音的原始波形输入值,并利用 generate()将输入语音自回归地翻译为目标语言。
Wav2Vec2FeatureExtractor 类负责预处理输入语音,Speech2Text2Tokenizer 解码生成的目标标记为目标字符串。Speech2Text2Processor 将 Wav2Vec2FeatureExtractor 和 Speech2Text2Tokenizer 封装成单个实例,用于提取输入特征和解码预测的标记 ID。
- 逐步语音翻译
>>> import torch
>>> from transformers import Speech2Text2Processor, SpeechEncoderDecoderModel
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> model = SpeechEncoderDecoderModel.from_pretrained("facebook/s2t-wav2vec2-large-en-de")
>>> processor = Speech2Text2Processor.from_pretrained("facebook/s2t-wav2vec2-large-en-de")
>>> 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)
>>> inputs = processor(ds["speech"][0], sampling_rate=16_000, return_tensors="pt")
>>> generated_ids = model.generate(inputs=inputs["input_values"], attention_mask=inputs["attention_mask"])
>>> transcription = processor.batch_decode(generated_ids)
-
通过管道进行语音翻译
自动语音识别管道也可用于仅使用几行代码翻译语音
>>> from datasets import load_dataset
>>> from transformers import pipeline
>>> librispeech_en = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> asr = pipeline(
... "automatic-speech-recognition",
... model="facebook/s2t-wav2vec2-large-en-de",
... feature_extractor="facebook/s2t-wav2vec2-large-en-de",
... )
>>> translation_de = asr(librispeech_en[0]["file"])
查看model hub以查找 Speech2Text2 检查点。
资源
- 因果语言建模任务指南
Speech2Text2Config
class transformers.Speech2Text2Config
( vocab_size = 10000 decoder_layers = 6 decoder_ffn_dim = 2048 decoder_attention_heads = 4 decoder_layerdrop = 0.0 use_cache = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 scale_embedding = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 max_target_positions = 1024 **kwargs )
参数
-
vocab_size
(int
,可选,默认为 50265)—Speech2Text 模型的词汇量。定义了在调用 Speech2TextModel 时可以表示的不同标记数量。 -
d_model
(int
,可选,默认为 1024)—层和池化层的维度。 -
decoder_layers
(int
,可选,默认为 12)—解码器层数。 -
decoder_attention_heads
(int
,可选,默认为 16)—Transformer 解码器中每个注意力层的注意力头数。 -
decoder_ffn_dim
(int
,可选,默认为 4096) — 解码器中“中间”(通常称为前馈)层的维度。 -
activation_function
(str
或function
,可选,默认为"gelu"
) — 池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。 -
dropout
(float
,可选,默认为 0.1) — 嵌入层和池化器中所有全连接层的丢失概率。 -
attention_dropout
(float
,可选,默认为 0.0) — 注意力概率的丢失比率。 -
activation_dropout
(float
,可选,默认为 0.0) — 全连接层内激活的丢失比率。 -
init_std
(float
,可选,默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。`arxiv.org/abs/1909.11556>``__ 了解更多详情。 -
decoder_layerdrop
(float
,可选,默认为 0.0) — 解码器的 LayerDrop 概率。有关更多详情,请参阅 LayerDrop 论文)。 -
use_cache
(bool
,可选,默认为True
) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。 -
max_target_positions
(int
,可选,默认为 1024) — 该模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512、1024 或 2048)。
这是一个配置类,用于存储 Speech2Text2ForCausalLM 的配置。根据指定的参数实例化一个 Speech2Text2 模型,定义模型架构。使用默认值实例化配置将产生类似于 Speech2Text2 facebook/s2t-wav2vec2-large-en-de 架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 中的文档以获取更多信息。
示例:
>>> from transformers import Speech2Text2Config, Speech2Text2ForCausalLM
>>> # Initializing a Speech2Text2 s2t_transformer_s style configuration
>>> configuration = Speech2Text2Config()
>>> # Initializing a model (with random weights) from the s2t_transformer_s style configuration
>>> model = Speech2Text2ForCausalLM(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
Speech2TextTokenizer
class transformers.Speech2Text2Tokenizer
( vocab_file bos_token = '<s>' pad_token = '<pad>' eos_token = '</s>' unk_token = '<unk>' do_lower_case = False merges_file = None **kwargs )
参数
-
vocab_file
(str
) — 包含词汇表的文件。 -
bos_token
(str
,可选,默认为"<s>"
) — 句子的开头标记。 -
eos_token
(str
,可选,默认为"</s>"
) — 句子的结尾标记。 -
unk_token
(str
,可选,默认为"<unk>"
) — 未知标记。词汇表中不存在的标记无法转换为 ID,而是设置为此标记。 -
pad_token
(str
,可选,默认为"<pad>"
) — 用于填充的标记,例如在批处理不同长度的序列时使用。**kwargs — 传递给 PreTrainedTokenizer 的其他关键字参数。
构造一个 Speech2Text2Tokenizer。
该分词器继承自 PreTrainedTokenizer,其中包含一些主要方法。用户应参考超类以获取有关这些方法的更多信息。
batch_decode
( sequences: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → export const metadata = 'undefined';List[str]
参数
-
sequences
(Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]
) — token 化输入 id 的列表。可以使用__call__
方法获得。 -
skip_special_tokens
(bool
, 可选, 默认为False
) — 是否在解码中删除特殊标记。 -
clean_up_tokenization_spaces
(bool
, 可选) — 是否清除 tokenization 空格。如果为None
,将默认为self.clean_up_tokenization_spaces
。 -
kwargs
(额外的关键字参数, 可选) — 将传递给底层模型特定的解码方法。
返回
List[str]
解码后的句子列表。
通过调用 decode 将 token id 的列表转换为字符串列表。
decode
( token_ids: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → export const metadata = 'undefined';str
参数
-
token_ids
(Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]
) — token 化输入 id 的列表。可以使用__call__
方法获得。 -
skip_special_tokens
(bool
, 可选, 默认为False
) — 是否在解码中删除特殊标记。 -
clean_up_tokenization_spaces
(bool
, 可选) — 是否清除 tokenization 空格。如果为None
,将默认为self.clean_up_tokenization_spaces
。 -
kwargs
(额外的关键字参数, 可选) — 将传递给底层模型特定的解码方法。
返回
str
解码后的句子。
使用分词器和词汇表将 id 序列转换为字符串,具有删除特殊标记和清除 tokenization 空格的选项。
类似于执行self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))
。
save_vocabulary
( save_directory: str filename_prefix: Optional = None )
Speech2Text2Processor
class transformers.Speech2Text2Processor
( feature_extractor tokenizer )
参数
-
feature_extractor
(AutoFeatureExtractor
) — 一个 AutoFeatureExtractor 的实例。特征提取器是必需的输入。 -
tokenizer
(Speech2Text2Tokenizer
) — 一个 Speech2Text2Tokenizer 的实例。Tokenizer 是必需的输入。
构建一个 Speech2Text2 处理器,将 Speech2Text2 特征提取器和 Speech2Text2 分词器包装成一个单一处理器。
Speech2Text2Processor 提供了 AutoFeatureExtractor 和 Speech2Text2Tokenizer 的所有功能。查看更多信息,请参考call()和 decode()。
__call__
( *args **kwargs )
在正常模式下使用时,此方法将所有参数转发给 AutoFeatureExtractor 的__call__()
并返回其输出。如果在上下文as_target_processor()
中使用此方法,则将所有参数转发给 Speech2Text2Tokenizer 的call()。请参考上述两种方法的文档以获取更多信息。
from_pretrained
( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )
参数
-
pretrained_model_name_or_path
(str
或os.PathLike
) — 这可以是:-
一个字符串,huggingface.co 模型存储库中托管的预训练特征提取器的模型 ID。有效的模型 ID 可以位于根级别,如
bert-base-uncased
,或命名空间在用户或组织名称下,如dbmdz/bert-base-german-cased
。 -
一个包含使用 save_pretrained()方法保存的特征提取器文件的目录路径,例如
./my_model_directory/
。 -
一个保存特征提取器 JSON 文件的路径或 URL,例如
./my_model_directory/preprocessor_config.json
。**kwargs — 传递给 from_pretrained()和~tokenization_utils_base.PreTrainedTokenizer.from_pretrained
的额外关键字参数。
-
实例化与预训练模型相关联的处理器。
这个类方法只是调用特征提取器 from_pretrained()、图像处理器 ImageProcessingMixin 和标记器~tokenization_utils_base.PreTrainedTokenizer.from_pretrained
方法。更多信息请参考上述方法的文档字符串。
save_pretrained
( save_directory push_to_hub: bool = False **kwargs )
参数
-
save_directory
(str
或os.PathLike
) — 特征提取器 JSON 文件和标记器文件将保存在的目录(如果目录不存在,将创建该目录)。 -
push_to_hub
(bool
, 可选, 默认为False
) — 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用repo_id
指定要推送到的存储库(将默认为您的命名空间中的save_directory
名称)。 -
kwargs
(Dict[str, Any]
, 可选) — 传递给 push_to_hub()方法的额外关键字参数。
将该处理器的属性(特征提取器、标记器等)保存在指定目录中,以便可以使用 from_pretrained()方法重新加载。
这个类方法只是调用 save_pretrained()和 save_pretrained()。更多信息请参考上述方法的文档字符串。
batch_decode
( *args **kwargs )
这个方法将所有参数转发到 Speech2Text2Tokenizer 的 batch_decode()。更多信息请参考该方法的文档字符串。
decode
( *args **kwargs )
这个方法将所有参数转发到 Speech2Text2Tokenizer 的 decode()。更多信息请参考该方法的文档字符串。
Speech2Text2ForCausalLM
class transformers.Speech2Text2ForCausalLM
( config )
参数
config
(Speech2Text2Config)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
带有语言建模头的 Speech2Text2 解码器。可用作 EncoderDecoderModel 和SpeechEncoderDecoder
的解码器部分。此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( input_ids: Optional = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)
参数
-
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。默认情况下将忽略填充。可以使用 Speech2Text2Tokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是输入 ID?
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.Tensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]
中:-
对于
未屏蔽
的标记, -
0 表示标记为
屏蔽
。
什么是注意力掩码?
-
-
encoder_hidden_states
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 编码器最后一层的隐藏状态序列。如果模型配置为解码器,则在交叉注意力中使用。 -
encoder_attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器,则在交叉注意力中使用。选择的掩码值在[0, 1]
中: -
head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.Tensor
,可选)— 用于使注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]
中:-
1 表示头部未被
屏蔽
, -
0 表示头部被
屏蔽
。
-
-
cross_attn_head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.Tensor
,可选)— 用于使交叉注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]
中:-
1 表示头部未被
屏蔽
, -
0 表示头部被
屏蔽
。
-
-
past_key_values
(tuple(tuple(torch.FloatTensor))
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。当模型用作序列到序列模型中的解码器时,这两个额外的张量是必需的。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参阅
past_key_values
输入)。如果使用了
past_key_values
,用户可以选择仅输入形状为(batch_size, 1)
的最后一个decoder_input_ids
(那些没有将它们的过去键值状态提供给此模型的)而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。 -
labels
(torch.LongTensor
,形状为(batch_size, sequence_length)
,optional) — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]
范围内,或者为-100(请参阅input_ids
文档字符串)。索引设置为-100
的标记将被忽略(被masked
),损失仅计算具有标签在[0, ..., config.vocab_size]
范围内的标记。 -
use_cache
(bool
, optional) — 如果设置为True
,将返回past_key_values
键值状态,并可用于加速解码(请参阅past_key_values
)。-
对于未被
masked
的标记为 1, -
对于被
masked
的标记为 0。
-
-
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。
返回
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor
元组
一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(Speech2Text2Config)和输入的不同元素。
-
loss
(torch.FloatTensor
,形状为(1,)
,optional, 当提供labels
时返回) — 语言建模损失(用于下一个标记预测)。 -
logits
(torch.FloatTensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出,如果模型有嵌入层,+ 一个用于每个层的输出)。模型在每个层的输出隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。在注意力 softmax 之后的交叉注意力权重,用于计算交叉注意力头中的加权平均值。
-
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的torch.FloatTensor
元组,每个元组包含自注意力和交叉注意力层的缓存键、值状态,如果模型用于编码器-解码器设置,则相关。仅在config.is_decoder = True
时相关。包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码。(请参见
past_key_values
输入)
示例:
>>> from transformers import (
... SpeechEncoderDecoderModel,
... Speech2Text2ForCausalLM,
... Wav2Vec2Model,
... Speech2Text2Config,
... Wav2Vec2Config,
... Wav2Vec2FeatureExtractor,
... Speech2Text2Tokenizer,
... )
>>> from datasets import load_dataset
>>> feature_extractor = Wav2Vec2FeatureExtractor()
>>> tokenizer = Speech2Text2Tokenizer.from_pretrained("facebook/s2t-wav2vec2-large-en-de")
>>> encoder = Wav2Vec2Model(Wav2Vec2Config())
>>> decoder = Speech2Text2ForCausalLM(Speech2Text2Config())
>>> # init random speech2text model
>>> model = SpeechEncoderDecoderModel(encoder=encoder, decoder=decoder)
>>> model.config.pad_token_id = tokenizer.pad_token_id
>>> model.config.decoder_start_token_id = tokenizer.bos_token_id
>>> # pre-process inputs and labels
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(
... ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_values = inputs.input_values
>>> decoder_input_ids = tokenizer(ds[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(inputs=input_values, labels=decoder_input_ids).loss
>>> # backprop loss
>>> loss.backward()
SpeechT5
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/speecht5
概述
SpeechT5 模型是由 Junyi Ao、Rui Wang、Long Zhou、Chengyi Wang、Shuo Ren、Yu Wu、Shujie Liu、Tom Ko、Qing Li、Yu Zhang、Zhihua Wei、Yao Qian、Jinyu Li、Furu Wei 在 SpeechT5: Unified-Modal Encoder-Decoder Pre-Training for Spoken Language Processing 中提出的。
论文摘要如下:
受 T5(文本到文本转换变压器)在预训练自然语言处理模型中的成功启发,我们提出了一个统一的 SpeechT5 框架,探索编码器-解码器的预训练,用于自监督语音/文本表示学习。SpeechT5 框架由一个共享的编码器-解码器网络和六个模态特定的(语音/文本)预/后网络组成。通过预网络对输入的语音/文本进行预处理后,共享的编码器-解码器网络对序列到序列的转换进行建模,然后后网络根据解码器的输出在语音/文本模态中生成输出。利用大规模未标记的语音和文本数据,我们预训练 SpeechT5 来学习一个统一的模态表示,希望提高对语音和文本的建模能力。为了将文本和语音信息对齐到这个统一的语义空间中,我们提出了一种跨模态向量量化方法,随机混合语音/文本状态和潜在单元作为编码器和解码器之间的接口。广泛的评估显示了所提出的 SpeechT5 框架在各种口语处理任务上的优越性,包括自动语音识别、语音合成、语音翻译、语音转换、语音增强和说话人识别。
该模型由 Matthijs 贡献。原始代码可以在 这里 找到。
SpeechT5Config
class transformers.SpeechT5Config
( vocab_size = 81 hidden_size = 768 encoder_layers = 12 encoder_attention_heads = 12 encoder_ffn_dim = 3072 encoder_layerdrop = 0.1 decoder_layers = 6 decoder_ffn_dim = 3072 decoder_attention_heads = 12 decoder_layerdrop = 0.1 hidden_act = 'gelu' positional_dropout = 0.1 hidden_dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 scale_embedding = False feat_extract_norm = 'group' feat_proj_dropout = 0.0 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 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 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 decoder_start_token_id = 2 num_mel_bins = 80 speech_decoder_prenet_layers = 2 speech_decoder_prenet_units = 256 speech_decoder_prenet_dropout = 0.5 speaker_embedding_dim = 512 speech_decoder_postnet_layers = 5 speech_decoder_postnet_units = 256 speech_decoder_postnet_kernel = 5 speech_decoder_postnet_dropout = 0.5 reduction_factor = 2 max_speech_positions = 4000 max_text_positions = 450 encoder_max_relative_position = 160 use_guided_attention_loss = True guided_attention_loss_num_heads = 2 guided_attention_loss_sigma = 0.4 guided_attention_loss_scale = 10.0 use_cache = True is_encoder_decoder = True **kwargs )
参数
-
vocab_size
(int
,可选,默认为 81)— SpeechT5 模型的词汇量。定义了可以由传递给 SpeechT5Model 的inputs_ids
表示的不同标记数量。 -
hidden_size
(int
,可选,默认为 768)— 编码器层和池化层的维度。 -
encoder_layers
(int
,可选,默认为 12)— Transformer 编码器中的隐藏层数。 -
encoder_attention_heads
(int
,可选,默认为 12)— Transformer 编码器中每个注意力层的注意力头数。 -
encoder_ffn_dim
(int
,可选,默认为 3072)— Transformer 编码器中“中间”(即前馈)层的维度。 -
encoder_layerdrop
(float
,可选,默认为 0.1)— 编码器的 LayerDrop 概率。有关更多详细信息,请参阅 LayerDrop 论文。 -
decoder_layers
(int
,可选,默认为 6)— Transformer 解码器中的隐藏层数。 -
decoder_attention_heads
(int
,可选,默认为 12)— Transformer 解码器中每个注意力层的注意力头数。 -
decoder_ffn_dim
(int
,可选,默认为 3072)— Transformer 解码器中“中间”(通常称为前馈)层的维度。 -
decoder_layerdrop
(float
,可选,默认为 0.1)— 解码器的 LayerDrop 概率。有关更多详细信息,请参阅 LayerDrop 论文。 -
hidden_act
(str
orfunction
, optional, defaults to"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 -
positional_dropout
(float
, optional, defaults to 0.1) — 文本位置编码层的 dropout 概率。 -
hidden_dropout
(float
, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 -
attention_dropout
(float
, optional, defaults to 0.1) — 注意力概率的 dropout 比率。 -
activation_dropout
(float
, optional, defaults to 0.1) — 全连接层内部激活的 dropout 比率。 -
initializer_range
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
layer_norm_eps
(float
, optional, defaults to 1e-5) — 层归一化层使用的 epsilon。 -
scale_embedding
(bool
, optional, defaults toFalse
) — 通过 sqrt(d_model)缩放嵌入。 -
feat_extract_norm
(str
, optional, defaults to"group"
) — 应用于语音编码器预网络中 1D 卷积层的规范化方式。可以选择"group"
表示仅对第一个 1D 卷积层进行组归一化,或者选择"layer"
表示对所有 1D 卷积层进行层归一化。 -
feat_proj_dropout
(float
, optional, defaults to 0.0) — 语音编码器预网络输出的 dropout 概率。 -
feat_extract_activation
(str,
optional, defaults to
“gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数(函数或字符串)。如果是字符串,支持
“gelu”、
“relu”、
“selu”和
“gelu_new”`。 -
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 卷积位置嵌入层的组数。 -
apply_spec_augment
(bool
, optional, defaults toTrue
) — 是否对语音编码器预网络的输出应用SpecAugment数据增强。有关详细信息,请参阅SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。 -
mask_time_prob
(float
, optional, 默认为 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
, optional, 默认为 10) — 沿时间轴的向量跨度长度。 -
mask_time_min_masks
(int
, optional, 默认为 2) — 沿时间轴生成的长度为mask_feature_length
的掩码的最小数量,每个时间步,与mask_feature_prob
无关。只有在”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”时才相关。 -
mask_feature_prob
(float
, optional, 默认为 0.0) — 沿特征轴的所有特征向量中将被掩盖的百分比(介于 0 和 1 之间)。掩盖过程在该轴上生成”mask_feature_problen(feature_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选择为掩盖的向量跨度的起始的概率推理,mask_feature_prob*应该是prob_vector_start*mask_feature_length
。请注意,重叠可能会降低实际掩盖向量的百分比。只有在apply_spec_augment
为 True 时才相关。 -
mask_feature_length
(int
, optional, 默认为 10) — 沿特征轴的向量跨度长度。 -
mask_feature_min_masks
(int
, optional, 默认为 0) — 沿特征轴生成的长度为mask_feature_length
的掩码的最小数量,每个时间步,与mask_feature_prob
无关。只有在”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”时才相关。 -
num_mel_bins
(int
, optional, 默认为 80) — 每个输入特征中使用的梅尔特征数量。由语音解码器预网络使用。应与 SpeechT5Processor 类中使用的值对应。 -
speech_decoder_prenet_layers
(int
, optional, 默认为 2) — 语音解码器预网络中的层数。 -
speech_decoder_prenet_units
(int
, optional, 默认为 256) — 语音解码器预网络中层的维度。 -
speech_decoder_prenet_dropout
(float
, optional, 默认为 0.5) — 语音解码器预网络层的丢失概率。 -
speaker_embedding_dim
(int
, optional, 默认为 512) — XVector嵌入向量的维度。 -
speech_decoder_postnet_layers
(int
, optional, 默认为 5) — 语音解码器后置网络中的层数。 -
speech_decoder_postnet_units
(int
, optional, 默认为 256) — 语音解码器后置网络中层的维度。 -
speech_decoder_postnet_kernel
(int
, optional, 默认为 5) — 语音解码器后置网络中的卷积滤波器通道数。 -
speech_decoder_postnet_dropout
(float
, optional, 默认为 0.5) — 语音解码器后置网络层的丢失概率。 -
reduction_factor
(int
, optional, 默认为 2) — 用于语音解码器输入的频谱长度缩减因子。 -
max_speech_positions
(int
, optional, 默认为 4000) — 该模型可能用于的语音特征的最大序列长度。 -
max_text_positions
(int
, optional, 默认为 450) — 该模型可能用于的文本特征的最大序列长度。 -
encoder_max_relative_position
(int
, optional, 默认为 160) — 编码器中相对位置嵌入的最大距离。 -
use_guided_attention_loss
(bool
, optional, 默认为True
) — 在训练 TTS 模型时是否应用引导注意力损失。 -
guided_attention_loss_num_heads
(int
, optional, defaults to 2) — 引导注意力损失将应用的注意力头数。使用-1 将此损失应用于所有注意力头。 -
guided_attention_loss_sigma
(float
, optional, defaults to 0.4) — 引导注意力损失的标准差。 -
guided_attention_loss_scale
(float
, optional, defaults to 10.0) — 引导注意力损失的缩放系数(也称为 lambda)。 -
use_cache
(bool
, optional, defaults toTrue
) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。
这是一个配置类,用于存储 SpeechT5Model 的配置。它用于根据指定的参数实例化一个 SpeechT5 模型,定义模型架构。使用默认值实例化配置将产生类似于 SpeechT5 microsoft/speecht5_asr架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import SpeechT5Model, SpeechT5Config
>>> # Initializing a "microsoft/speecht5_asr" style configuration
>>> configuration = SpeechT5Config()
>>> # Initializing a model (with random weights) from the "microsoft/speecht5_asr" style configuration
>>> model = SpeechT5Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
SpeechT5HifiGanConfig
class transformers.SpeechT5HifiGanConfig
( model_in_dim = 80 sampling_rate = 16000 upsample_initial_channel = 512 upsample_rates = [4, 4, 4, 4] upsample_kernel_sizes = [8, 8, 8, 8] resblock_kernel_sizes = [3, 7, 11] resblock_dilation_sizes = [[1, 3, 5], [1, 3, 5], [1, 3, 5]] initializer_range = 0.01 leaky_relu_slope = 0.1 normalize_before = True **kwargs )
参数
-
model_in_dim
(int
, optional, defaults to 80) — 输入对数梅尔频谱中的频率箱数。 -
sampling_rate
(int
, optional, defaults to 16000) — 生成输出音频的采样率,以赫兹(Hz)表示。 -
upsample_initial_channel
(int
, optional, defaults to 512) — 输入通道数到上采样网络。 -
upsample_rates
(Tuple[int]
orList[int]
, optional, defaults to[4, 4, 4, 4]
) — 一个整数元组,定义了上采样网络中每个 1D 卷积层的步幅。upsample_rates的长度定义了卷积层的数量,并且必须与upsample_kernel_sizes的长度匹配。 -
upsample_kernel_sizes
(Tuple[int]
orList[int]
, optional, defaults to[8, 8, 8, 8]
) — 一个整数元组,定义了上采样网络中每个 1D 卷积层的内核大小。upsample_kernel_sizes的长度定义了卷积层的数量,并且必须与upsample_rates的长度匹配。 -
resblock_kernel_sizes
(Tuple[int]
orList[int]
, optional, defaults to[3, 7, 11]
) — 一个整数元组,定义了多接受域融合(MRF)模块中 1D 卷积层的内核大小。 -
resblock_dilation_sizes
(Tuple[Tuple[int]]
orList[List[int]]
, optional, defaults to[[1, 3, 5], [1, 3, 5], [1, 3, 5]]
) — 一个嵌套的整数元组,定义了多接受域融合(MRF)模块中扩张的 1D 卷积层的扩张率。 -
initializer_range
(float
, optional, defaults to 0.01) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
leaky_relu_slope
(float
, optional, defaults to 0.1) — 漏斗 ReLU 激活使用的负斜率的角度。 -
normalize_before
(bool
, optional, defaults toTrue
) — 是否在使用声码器的学习均值和方差进行声码之前对频谱进行归一化。
这是用于存储SpeechT5HifiGanModel
配置的配置类。它用于根据指定的参数实例化一个 SpeechT5 HiFi-GAN 声码器模型,定义模型架构。使用默认值实例化配置将产生类似于 SpeechT5 microsoft/speecht5_hifigan架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import SpeechT5HifiGan, SpeechT5HifiGanConfig
>>> # Initializing a "microsoft/speecht5_hifigan" style configuration
>>> configuration = SpeechT5HifiGanConfig()
>>> # Initializing a model (with random weights) from the "microsoft/speecht5_hifigan" style configuration
>>> model = SpeechT5HifiGan(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
SpeechT5Tokenizer
class transformers.SpeechT5Tokenizer
( vocab_file bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' normalize = False sp_model_kwargs: Optional = None **kwargs )
参数
-
vocab_file
(str
) — 包含实例化分词器所需词汇的SentencePiece文件(通常具有.spm扩展名)。 -
bos_token
(str
, 可选, 默认为"<s>"
) — 序列开始标记。 -
eos_token
(str
, 可选, 默认为"</s>"
) — 序列结束标记。 -
unk_token
(str
, 可选, 默认为"<unk>"
) — 未知标记。词汇表中没有的标记无法转换为 ID,而是设置为此标记。 -
pad_token
(str
, 可选, 默认为"<pad>"
) — 用于填充的标记,例如在批处理不同长度的序列时。 -
normalize
(bool
, 可选, 默认为False
) — 是否将文本中的数字量转换为其拼写的英文对应项。 -
sp_model_kwargs
(dict
, 可选) — 将传递给SentencePieceProcessor.__init__()
方法。SentencePiece 的 Python 包装器可用于设置:-
enable_sampling
: 启用子词正则化。 -
nbest_size
: 一元采样的参数。对于 BPE-Dropout 无效。-
nbest_size = {0,1}
: 不执行采样。 -
nbest_size > 1
: 从 nbest_size 结果中进行采样。 -
nbest_size < 0
: 假设 nbest_size 为无限,并使用前向过滤和后向采样算法从所有假设(格)中进行采样。
-
-
alpha
: 一元采样的平滑参数,以及 BPE-dropout 的合并操作的丢弃概率。
-
-
sp_model
(SentencePieceProcessor
) — 用于每次转换(字符串、标记和 ID)的SentencePiece处理器。
构建一个 SpeechT5 分词器。基于SentencePiece。
此分词器继承自 PreTrainedTokenizer,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
__call__
( 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 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 ) → export const metadata = 'undefined';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'
(默认): 无填充(即,可以输出具有不同长度序列的批次)。
-
-
truncation
(bool
,str
或 TruncationStrategy, 可选, 默认为False
) — 激活和控制截断。接受以下值:-
True
或'longest_first'
: 使用参数max_length
指定的最大长度进行截断,或者如果未提供该参数,则截断到模型的最大可接受输入长度。如果提供了一对序列(或一批序列),则将逐标记截断,从一对序列中最长的序列中删除一个标记。 -
'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
时返回的溢出标记将包含截断序列末尾的一些标记,以提供截断和溢出序列之间的一些重叠。该参数的值定义了重叠标记的数量。 -
is_split_into_words
(bool
,可选,默认为False
) — 输入是否已经预分词(例如,已经分成单词)。如果设置为True
,分词器会假定输入已经分成单词(例如,通过在空格上分割),然后进行分词。这对于 NER 或标记分类很有用。 -
pad_to_multiple_of
(int
,可选) — 如果设置,将填充序列到提供的值的倍数。需要激活padding
。这对于在具有计算能力>= 7.5
(Volta)的 NVIDIA 硬件上启用 Tensor Cores 特别有用。 -
return_tensors
(str
或 TensorType,可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:-
'tf'
:返回 TensorFlowtf.constant
对象。 -
'pt'
:返回 PyTorchtorch.Tensor
对象。 -
'np'
:返回 Numpynp.ndarray
对象。
-
-
return_token_type_ids
(bool
,可选) — 是否返回 token 类型 ID。如果保持默认值,将根据特定分词器的默认值返回 token 类型 ID,由return_outputs
属性定义。什么是 token 类型 ID?
-
return_attention_mask
(bool
,可选) — 是否返回注意力掩码。如果保持默认值,将根据特定分词器的默认值返回注意力掩码,由return_outputs
属性定义。什么是注意力掩码?
-
return_overflowing_tokens
(bool
,可选,默认为False
) — 是否返回溢出的标记序列。如果提供一对输入 ID 序列(或一批对)并且truncation_strategy = longest_first
或True
,则会引发错误,而不是返回溢出的标记。 -
return_special_tokens_mask
(bool
,可选,默认为False
) — 是否返回特殊标记掩码信息。 -
return_offsets_mapping
(bool
,可选,默认为False
) — 是否返回每个标记的(char_start, char_end)
。这仅适用于继承自 PreTrainedTokenizerFast 的快速分词器,如果使用 Python 的分词器,此方法将引发
NotImplementedError
。 -
return_length
(bool
,可选,默认为False
) — 是否返回编码输入的长度。 -
verbose
(bool
,可选,默认为True
) — 是否打印更多信息和警告。**kwargs — 传递给self.tokenize()
方法
返回
BatchEncoding
一个带有以下字段的 BatchEncoding:
-
input_ids
— 要提供给模型的标记 ID 列表。什么是输入 ID?
-
token_type_ids
— 要提供给模型的 token 类型 ID 列表(当return_token_type_ids=True
或token_type_ids
在self.model_input_names
中时)。什么是 token 类型 ID?
-
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
时)
将一个或多个序列或一个或多个序列对标记化并准备好传递给模型的主要方法。
save_vocabulary
( save_directory: str filename_prefix: Optional = None )
decode
( token_ids: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → export const metadata = 'undefined';str
参数
-
token_ids
(Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]
) — 标记化输入 id 的列表。可以使用__call__
方法获得。 -
skip_special_tokens
(bool
, optional, 默认为False
) — 是否在解码中删除特殊标记。 -
clean_up_tokenization_spaces
(bool
, optional) — 是否清理标记化空格。如果为None
,将默认为self.clean_up_tokenization_spaces
。 -
kwargs
(额外的关键字参数,optional) — 将传递给底层模型特定的解码方法。
返回
str
解码后的句子。
使用标记器和词汇表将 id 序列转换为字符串,具有删除特殊标记和清理标记化空格的选项。
类似于执行self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))
。
batch_decode
( sequences: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → export const metadata = 'undefined';List[str]
参数
-
sequences
(Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]
) — 标记化输入 id 的列表。可以使用__call__
方法获得。 -
skip_special_tokens
(bool
, optional, 默认为False
) — 是否在解码中删除特殊标记。 -
clean_up_tokenization_spaces
(bool
, optional) — 是否清理标记化空格。如果为None
,将默认为self.clean_up_tokenization_spaces
。 -
kwargs
(额外的关键字参数,optional) — 将传递给底层模型特定的解码方法。
返回
List[str]
解码后的句子列表。
通过调用解码将标记 id 的列表转换为字符串列表。
SpeechT5FeatureExtractor
class transformers.SpeechT5FeatureExtractor
( feature_size: int = 1 sampling_rate: int = 16000 padding_value: float = 0.0 do_normalize: bool = False num_mel_bins: int = 80 hop_length: int = 16 win_length: int = 64 win_function: str = 'hann_window' frame_signal_scale: float = 1.0 fmin: float = 80 fmax: float = 7600 mel_floor: float = 1e-10 reduction_factor: int = 2 return_attention_mask: bool = True **kwargs )
参数
-
feature_size
(int
, optional, 默认为 1) — 提取特征的特征维度。 -
sampling_rate
(int
, optional, 默认为 16000) — 音频文件应数字化的采样率,以赫兹(Hz)表示。 -
padding_value
(float
, optional, 默认为 0.0) — 用于填充值的值。 -
do_normalize
(bool
, optional, 默认为False
) — 是否对输入进行零均值单位方差归一化。归一化可以帮助显著提高某些模型的性能。 -
num_mel_bins
(int
, optional, 默认为 80) — 提取的频谱图特征中的 mel 频率箱数。 -
hop_length
(int
, optional, 默认为 16) — 窗口之间的毫秒数。在许多论文中也称为“shift”。 -
win_length
(int
, optional, 默认为 64) — 每个窗口的毫秒数。 -
win_function
(str
, optional, 默认为"hann_window"
) — 用于窗口化的窗口函数的名称,必须可以通过torch.{win_function}
访问。 -
frame_signal_scale
(float
, optional, 默认为 1.0) — 在应用 DFT 之前创建帧时乘以的常数。此参数已弃用。 -
fmin
(float
, optional, 默认为 80) — Hz 中的最小 mel 频率。 -
fmax
(float
, optional, 默认为 7600) — Hz 中的最大 mel 频率。 -
mel_floor
(float
, optional, 默认为 1e-10) — mel 频率银行的最小值。 -
reduction_factor
(int
, optional, 默认为 2) — 频谱长度缩减因子。此参数已弃用。 -
return_attention_mask
(bool
, 可选, 默认为True
) — 是否call
()应该返回attention_mask
。
构建一个 SpeechT5 特征提取器。
这个类可以通过(可选)将原始语音信号归一化为零均值单位方差,供 SpeechT5 语音编码器 prenet 使用。
这个类还可以从原始语音中提取 log-mel 滤波器组特征,供 SpeechT5 语音解码器 prenet 使用。
这个特征提取器继承自 SequenceFeatureExtractor,其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。
__call__
( audio: Union = None audio_target: Union = None 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 )
参数
-
audio
(np.ndarray
,List[float]
,List[np.ndarray]
,List[List[float]]
, 可选) — 要处理的序列或批次。每个序列可以是一个 numpy 数组,一个浮点值列表,一个 numpy 数组列表或一个浮点值列表的列表。这将输出波形特征。必须是单声道音频,不是立体声,即每个时间步长一个浮点数。 -
audio_target
(np.ndarray
,List[float]
,List[np.ndarray]
,List[List[float]]
, 可选) — 要处理为目标的序列或批次。每个序列可以是一个 numpy 数组,一个浮点值列表,一个 numpy 数组列表或一个浮点值列表的列表。这将输出 log-mel 频谱特征。 -
padding
(bool
,str
或 PaddingStrategy, 可选, 默认为False
) — 在以下选项中选择一种策略来填充返回的序列(根据模型的填充方向和填充索引):-
True
或'longest'
: 填充到批次中最长的序列(如果只提供一个序列,则不填充)。 -
'max_length'
: 使用参数max_length
指定的最大长度进行填充,或者如果未提供该参数,则使用模型可接受的最大输入长度进行填充。 -
False
或'do_not_pad'
(默认): 不填充(即,可以输出具有不同长度序列的批次)。
-
-
max_length
(int
, 可选) — 返回列表的最大长度和可选填充长度(见上文)。 -
truncation
(bool
) — 激活截断,将输入序列截断为max_length长。 -
pad_to_multiple_of
(int
, 可选) — 如果设置,将序列填充到提供的值的倍数。这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用,其计算能力为
>= 7.5
(Volta),或者对于受益于序列长度为 128 的倍数的 TPUs。 -
return_attention_mask
(bool
, 可选) — 是否返回注意力掩码。如果保持默认设置,将根据特定的 feature_extractor 的默认设置返回注意力掩码。什么是注意力掩码?
-
return_tensors
(str
或 TensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:-
'tf'
: 返回 TensorFlowtf.constant
对象。 -
'pt'
: 返回 PyTorchtorch.Tensor
对象。 -
'np'
: 返回 Numpynp.ndarray
对象。
-
-
sampling_rate
(int
, 可选) —audio
或audio_target
输入的采样率。强烈建议在前向调用时传递sampling_rate
以防止潜在错误。
对一个或多个序列进行特征化和为模型准备的主要方法。
传入一个值给audio
以提取波形特征。传入一个值给audio_target
以提取 log-mel 频谱特征。
SpeechT5Processor
class transformers.SpeechT5Processor
( feature_extractor tokenizer )
参数
-
feature_extractor
(SpeechT5FeatureExtractor
)- SpeechT5FeatureExtractor 的实例。特征提取器是必需的输入。 -
tokenizer
(SpeechT5Tokenizer
)- SpeechT5Tokenizer 的实例。分词器是必需的输入。
构建一个 SpeechT5 处理器,将特征提取器和分词器包装成一个单一的处理器。
SpeechT5Processor 提供了 SpeechT5FeatureExtractor 和 SpeechT5Tokenizer 的所有功能。有关更多信息,请参阅call()和 decode()的文档字符串。
__call__
( *args **kwargs )
处理音频和文本输入,以及音频和文本目标。
您可以使用参数audio
处理音频,或者使用参数audio_target
处理音频目标。这将参数转发到 SpeechT5FeatureExtractor 的call()。
您可以使用参数text
处理文本,或者使用参数text_target
处理文本标签。这将参数转发到 SpeechT5Tokenizer 的call()。
有效的输入组合是:
-
仅
text
-
仅
audio
-
仅
text_target
-
仅
audio_target
-
text
和audio_target
-
audio
和audio_target
-
text
和text_target
-
audio
和text_target
有关更多信息,请参阅上述两种方法的文档字符串。
pad
( *args **kwargs )
将音频和文本输入以及它们的目标整合到填充的批次中。
音频输入由 SpeechT5FeatureExtractor 的 pad()进行填充。文本输入由 SpeechT5Tokenizer 的 pad()进行填充。
有效的输入组合是:
-
仅
input_ids
-
仅
input_values
-
仅
labels
,可以是 log-mel 频谱图或文本标记 -
input_ids
和 log-mel 频谱labels
-
input_values
和文本labels
有关更多信息,请参阅上述两种方法的文档字符串。
from_pretrained
( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )
参数
-
pretrained_model_name_or_path
(str
或os.PathLike
)- 这可以是:-
一个字符串,预训练特征提取器的模型 ID,托管在 huggingface.co 上的模型存储库中。有效的模型 ID 可以位于根级别,如
bert-base-uncased
,或者命名空间在用户或组织名称下,如dbmdz/bert-base-german-cased
。 -
一个目录的路径,其中包含使用 save_pretrained()方法保存的特征提取器文件,例如,
./my_model_directory/
。 -
保存特征提取器 JSON 文件的路径或 url,例如
./my_model_directory/preprocessor_config.json
。**kwargs — 传递给 from_pretrained()和~tokenization_utils_base.PreTrainedTokenizer.from_pretrained
的其他关键字参数。
-
实例化与预训练模型相关联的处理器。
此类方法只是调用特征提取器 from_pretrained()、图像处理器 ImageProcessingMixin 和标记器~tokenization_utils_base.PreTrainedTokenizer.from_pretrained
方法。有关更多信息,请参考上述方法的文档字符串。
save_pretrained
( save_directory push_to_hub: bool = False **kwargs )
参数
-
save_directory
(str
或os.PathLike
) — 特征提取器 JSON 文件和标记器文件将保存在的目录(如果目录不存在,则将创建该目录)。 -
push_to_hub
(bool
, 可选, 默认为False
) — 在保存模型后是否将其推送到 Hugging Face 模型中心。您可以使用repo_id
指定要推送到的存储库(将默认为您的命名空间中的save_directory
名称)。 -
kwargs
(Dict[str, Any]
,可选) — 传递给 push_to_hub()方法的其他关键字参数。
将此处理器的属性(特征提取器、标记器等)保存在指定目录中,以便可以使用 from_pretrained()方法重新加载。
此类方法只是调用 save_pretrained()和 save_pretrained()。有关更多信息,请参考上述方法的文档字符串。
batch_decode
( *args **kwargs )
该方法将其所有参数转发到 SpeechT5Tokenizer 的 batch_decode()。有关更多信息,请参考此方法的文档字符串。
decode
( *args **kwargs )
该方法将其所有参数转发到 SpeechT5Tokenizer 的 decode()。有关更多信息,请参考此方法的文档字符串。
SpeechT5Model
class transformers.SpeechT5Model
( config: SpeechT5Config encoder: Optional = None decoder: Optional = None )
参数
-
config
(SpeechT5Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。 -
encoder
(SpeechT5EncoderWithSpeechPrenet
或SpeechT5EncoderWithTextPrenet
或None
)— 应用适当的语音或文本编码器预网络的 Transformer 编码器模块。如果为None
,将使用SpeechT5EncoderWithoutPrenet
,并假定input_values
为隐藏状态。 -
decoder
(SpeechT5DecoderWithSpeechPrenet
或SpeechT5DecoderWithTextPrenet
或None
)— 应用适当的语音或文本解码器预网络的 Transformer 解码器模块。如果为None
,将使用SpeechT5DecoderWithoutPrenet
,并假定decoder_input_values
为隐藏状态。
裸的 SpeechT5 编码器-解码器模型输出原始隐藏状态,没有任何特定的预处理或后处理网络。该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头部等)。
该模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_values: Optional = None attention_mask: Optional = None decoder_input_values: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None use_cache: Optional = None speaker_embeddings: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)
参数
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 用于避免在填充令牌索引上执行卷积和注意力的蒙版。蒙版值选定在[0, 1]
之间:-
1 表示令牌未被遮蔽,
-
0 表示令牌被遮蔽。
什么是注意力蒙版?
只有当相应的处理器具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,应避免在进行批量推断时传递attention_mask
以避免性能下降。对于这样的模型,input_values
应简单地填充为 0 并在不传递attention_mask
的情况下传递。请注意,这些模型的结果也会因input_values
是否填充而略有不同。 -
-
decoder_attention_mask
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 默认行为:生成一个忽略decoder_input_values
中填充令牌的张量。默认情况下还将使用因果蒙版。如果要更改填充行为,应阅读
SpeechT5Decoder._prepare_decoder_attention_mask
并根据需要进行修改。有关默认策略的更多信息,请参阅论文中的图表 1。 -
head_mask
(形状为(encoder_layers, encoder_attention_heads)
的torch.FloatTensor
,可选)— 用于在编码器中使注意力模块的选定头部失效的蒙版。蒙版值选定在[0, 1]
之间:-
1 表示头部未被遮蔽,
-
0 表示头部被遮蔽。
-
-
decoder_head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.FloatTensor
,可选)— 用于在解码器中使注意力模块的选定头部失效的蒙版。蒙版值选定在[0, 1]
之间:-
1 表示头部未被遮蔽,
-
0 表示头部被遮蔽。
-
-
cross_attn_head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.Tensor
,可选)— 用于使交叉注意力模块的选定头部失效的蒙版。蒙版值选定在[0, 1]
之间:-
1 表示头部未被遮蔽,
-
0 表示头部被遮蔽。
-
-
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选)— 元组包括(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或者config.use_cache=True
时返回)- 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参见
past_key_values
输入)。如果使用
past_key_values
,用户可以选择只输入最后一个decoder_input_values
(那些没有将它们的过去键值状态提供给该模型的)的形状为(batch_size, 1)
,而不是形状为(batch_size, sequence_length)
的所有decoder_input_values
。decoder_inputs_embeds(形状为(batch_size, target_sequence_length, hidden_size)
的torch.FloatTensor
,可选):可选地,可以直接传递嵌入表示,而不是传递decoder_input_values
。如果使用past_key_values
,可选择只输入最后一个decoder_inputs_embeds
(参见past_key_values
)。如果您想要更多控制如何将decoder_input_values
索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。 -
use_cache
(bool
,可选)- 如果设置为True
,将返回past_key_values
键值状态,并可用于加速解码(请参见past_key_values
)。 -
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。 -
input_values
(形状为(batch_size, sequence_length)
的torch.Tensor
)- 根据使用的编码器,input_values
可以是:输入原始语音波形的浮点值,或者词汇表中输入序列标记的索引,或者隐藏状态。 -
decoder_input_values
(形状为(batch_size, target_sequence_length)
的torch.Tensor
,可选)- 根据使用的解码器,decoder_input_values
可以是:从原始语音波形中提取的对数梅尔滤波器特征的浮点值,或者词汇表中解码器输入序列标记的索引,或者隐藏状态。 -
speaker_embeddings
(形状为(batch_size, config.speaker_embedding_dim)
的torch.FloatTensor
,可选)- 包含说话者嵌入的张量。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqModelOutput 或者一个torch.FloatTensor
的元组(如果传递了return_dict=False
或者config.return_dict=False
时)包括不同的元素,取决于配置(SpeechT5Config)和输入。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
)- 模型解码器最后一层的隐藏状态序列。如果使用
past_key_values
,则仅输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
, 可选, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出和每一层的输出各一个)。解码器在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(形状为
(batch_size, sequence_length, hidden_size)的
torch.FloatTensor`, 可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出和每一层的输出各一个)。编码器在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
SpeechT5Model 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行前后处理步骤,而后者会默默地忽略它们。
SpeechT5ForSpeechToText
class transformers.SpeechT5ForSpeechToText
( config: SpeechT5Config )
参数
config
(SpeechT5Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
SpeechT5 模型具有语音编码器和文本解码器。该模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
该模型还是一个 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般使用和行为相关的所有事项。
forward
( input_values: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)
参数
-
attention_mask
(torch.LongTensor
of shape(batch_size, sequence_length)
, optional) — 避免在填充标记索引上执行卷积和注意力的掩码。掩码值在[0, 1]
中选择:-
1 表示未被
masked
的标记, -
0 表示被
masked
的标记。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,应避免传递attention_mask
以避免在进行批量推理时性能下降。对于这样的模型,input_values
应该简单地用 0 填充并在不传递attention_mask
的情况下传递。请注意,这些模型根据input_values
是否填充也会产生略有不同的结果。 -
-
decoder_attention_mask
(torch.LongTensor
of shape(batch_size, target_sequence_length)
, optional) — 默认行为:生成一个忽略decoder_input_values
中填充标记的张量。默认情况下还将使用因果掩码。如果要更改填充行为,应阅读
SpeechT5Decoder._prepare_decoder_attention_mask
并根据需要进行修改。有关默认策略的更多信息,请参阅论文中的图表 1。 -
head_mask
(torch.FloatTensor
of shape(encoder_layers, encoder_attention_heads)
, optional) — 编码器中注意力模块中选择性头部置零的掩码。掩码值在[0, 1]
中选择。-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
decoder_head_mask
(torch.FloatTensor
of shape(decoder_layers, decoder_attention_heads)
, optional) — 解码器中注意力模块中选择性头部置零的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
cross_attn_head_mask
(torch.Tensor
of shape(decoder_layers, decoder_attention_heads)
, optional) — 交叉注意力模块中选择性头部置零的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
encoder_outputs
(tuple(tuple(torch.FloatTensor)
, optional) — 元组包括 (last_hidden_state
, optional:hidden_states
, optional:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参阅
past_key_values
输入)。如果使用
past_key_values
,用户可以选择仅输入最后的decoder_input_values
(即不将其过去的键值状态提供给此模型的那些)的形状为(batch_size, 1)
的张量,而不是形状为(batch_size, sequence_length)
的所有decoder_input_values
。decoder_inputs_embeds
(形状为(batch_size, target_sequence_length, hidden_size)
的torch.FloatTensor
,可选):可选择直接传递嵌入表示,而不是传递decoder_input_values
。如果使用past_key_values
,可以选择仅输入最后的decoder_inputs_embeds
(请参阅past_key_values
)。如果要更好地控制如何将decoder_input_values
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 -
use_cache
(bool
,可选)- 如果设置为True
,将返回past_key_values
键值状态,并可用于加速解码(请参阅past_key_values
)。 -
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
。 -
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。 -
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。 -
input_values
(形状为(batch_size, sequence_length)
的torch.FloatTensor
)- 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得值,例如通过声音文件库(pip install soundfile)。要准备好将数组转换为input_values
,应使用 SpeechT5Processor 进行填充和转换为torch.FloatTensor
类型的张量。有关详细信息,请参阅 SpeechT5Processor.call
()。 -
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)- 词汇表中解码器输入序列标记的索引。可以使用 SpeechT5Tokenizer 来获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是解码器输入 ID?
SpeechT5 使用
eos_token_id
作为decoder_input_ids
生成的起始标记。如果使用past_key_values
,可以选择仅输入最后的decoder_input_ids
(请参阅past_key_values
)。 -
labels
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 用于计算语言建模损失的标签。索引应该在[0, ..., config.vocab_size]
范围内,或者为-100(请参阅input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅计算具有标签在[0, ..., config.vocab_size]
范围内的标记。可以使用 SpeechT5Tokenizer 获取标签索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(SpeechT5Config)和输入的各种元素。
-
loss
(torch.FloatTensor
of shape(1,)
, optional, 当提供labels
时返回) — 语言建模损失。 -
logits
(torch.FloatTensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出和每一层的输出)。每一层解码器的隐藏状态以及初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每一层一个)。解码器的注意力权重,在注意力 SoftMax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每一层一个)。解码器交叉注意力层的注意力权重,在注意力 SoftMax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出和每一层的输出)。编码器每一层的隐藏状态以及初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
SpeechT5ForSpeechToText 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import SpeechT5Processor, SpeechT5ForSpeechToText
>>> from datasets import load_dataset
>>> dataset = load_dataset(
... "hf-internal-testing/librispeech_asr_demo", "clean", split="validation"
... ) # doctest: +IGNORE_RESULT
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_asr")
>>> model = SpeechT5ForSpeechToText.from_pretrained("microsoft/speecht5_asr")
>>> # audio file is decoded on the fly
>>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> predicted_ids = model.generate(**inputs, max_length=100)
>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
>>> transcription[0]
'mister quilter is the apostle of the middle classes and we are glad to welcome his gospel'
>>> inputs["labels"] = processor(text_target=dataset[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
19.68
SpeechT5ForTextToSpeech
class transformers.SpeechT5ForTextToSpeech
( config: SpeechT5Config )
参数
config
(SpeechT5Config)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
具有文本编码器和语音解码器的 SpeechT5 模型。该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( input_ids: Optional = None attention_mask: Optional = None decoder_input_values: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None speaker_embeddings: Optional = None labels: Optional = None stop_labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqSpectrogramOutput or tuple(torch.FloatTensor)
参数
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 用于避免在填充标记索引上执行卷积和注意力的遮罩。遮罩值选定在[0, 1]
之间:-
1 表示未被遮罩的标记,
-
0 表示被遮罩的标记。
什么是注意力遮罩?
只有当相应的处理器具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,在进行批量推理时,应避免传递attention_mask
以避免性能下降。对于这样的模型,input_values
应简单地用 0 填充并在不传递attention_mask
的情况下传递。请注意,这些模型根据input_values
是否填充,也会产生略有不同的结果。 -
-
decoder_attention_mask
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 默认行为:生成一个忽略decoder_input_values
中填充标记的张量。因果遮罩也将默认使用。如果要更改填充行为,应阅读
SpeechT5Decoder._prepare_decoder_attention_mask
并根据需要进行修改。有关默认策略的更多信息,请参见论文中的图表 1。 -
head_mask
(形状为(encoder_layers, encoder_attention_heads)
的torch.FloatTensor
,可选)— 用于在编码器中使注意力模块中的选定头部失效的遮罩。遮罩值选定在[0, 1]
之间:-
1 表示头部未被遮罩,
-
0 表示头部被遮罩。
-
-
decoder_head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.FloatTensor
,可选)- 用于使解码器中注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被“掩盖”,
-
0 表示头部被“掩盖”。
-
-
cross_attn_head_mask
(形状为(decoder_layers, decoder_attention_heads)
的torch.Tensor
,可选)- 用于使解码器中交叉注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被“掩盖”,
-
0 表示头部被“掩盖”。
-
-
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选)- 元组包括(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的tuple(torch.FloatTensor)
的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(参见
past_key_values
输入)。如果使用
past_key_values
,用户可以选择仅输入最后的decoder_input_values
(这些值没有传递给该模型的过去键值状态)的形状为(batch_size, 1)
,而不是形状为(batch_size, sequence_length)
的所有decoder_input_values
。decoder_inputs_embeds(形状为(batch_size, target_sequence_length, hidden_size)
的torch.FloatTensor
,可选):可选择直接传递嵌入表示,而不是传递decoder_input_values
。如果使用past_key_values
,可以选择只输入最后的decoder_inputs_embeds
(参见past_key_values
)。如果要更好地控制如何将decoder_input_values
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。 -
use_cache
(bool
,可选)- 如果设置为True
,将返回past_key_values
键值状态,可用于加速解码(参见past_key_values
)。 -
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 -
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。 -
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)- 词汇表中输入序列标记的索引。可以使用 SpeechT5Tokenizer 获取索引。有关详细信息,请参见 encode()和
call
()。什么是输入 ID?
-
decoder_input_values
(形状为(batch_size, sequence_length, config.num_mel_bins)
的torch.FloatTensor
)- 输入梅尔频谱的浮点值。SpeechT5 使用全零频谱作为
decoder_input_values
生成的起始令牌。如果使用past_key_values
,可以选择只输入最后的decoder_input_values
(参见past_key_values
)。 -
speaker_embeddings
(形状为(batch_size, config.speaker_embedding_dim)
的torch.FloatTensor
,可选)- 包含说话者嵌入的张量。 -
labels
(形状为(batch_size, sequence_length, config.num_mel_bins)
的torch.FloatTensor
,可选)- 目标梅尔频谱的浮点值。时间步设置为-100.0
将被忽略(掩码)用于损失计算。可以使用 SpeechT5Processor 获取频谱图。有关详细信息,请参阅 SpeechT5Processor.call
()。
返回值
transformers.modeling_outputs.Seq2SeqSpectrogramOutput 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqSpectrogramOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(SpeechT5Config)和输入的各种元素。
-
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)- 频谱生成损失。 -
spectrogram
(形状为(batch_size, sequence_length, num_bins)
的torch.FloatTensor
)- 预测的频谱图。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)- 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。
-
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。解码器每一层的隐藏状态以及初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。编码器在每一层的隐藏状态加上初始嵌入输出。
-
encoder_attentions
(可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组,每层一个。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
SpeechT5ForTextToSpeech 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan, set_seed
>>> import torch
>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
>>> model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")
>>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
>>> speaker_embeddings = torch.zeros((1, 512)) # or load xvectors from a file
>>> set_seed(555) # make deterministic
>>> # generate speech
>>> speech = model.generate(inputs["input_ids"], speaker_embeddings, vocoder=vocoder)
>>> speech.shape
torch.Size([15872])
generate
( input_ids: LongTensor attention_mask: Optional = None speaker_embeddings: Optional = None threshold: float = 0.5 minlenratio: float = 0.0 maxlenratio: float = 20.0 vocoder: Optional = None output_cross_attentions: bool = False return_output_lengths: bool = False **kwargs ) → export const metadata = 'undefined';tuple(torch.FloatTensor) comprising various elements depending on the inputs
参数
-
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
) — 词汇表中输入序列标记的索引。可以使用 SpeechT5Tokenizer 获取索引。有关详细信息,请参阅 encode()和
call
()。什么是输入 ID?
-
attention_mask
(形状为(batch_size, sequence_length)
的torch.LongTensor
) — 来自分词器的注意力蒙版,用于批量推理,指示模型在哪里忽略输入的填充标记。 -
speaker_embeddings
(形状为(batch_size, config.speaker_embedding_dim)
的torch.FloatTensor
,可选) — 包含说话者嵌入的张量。 -
threshold
(可选,默认为 0.5 的float
) — 当预测的停止标记概率超过此值时,生成的序列结束。 -
minlenratio
(可选,默认为 0.0 的float
) — 用于计算输出序列的最小所需长度。 -
maxlenratio
(可选,默认为 20.0 的float
) — 用于计算输出序列的最大允许长度。 -
vocoder
(可选,nn.Module
) — 将梅尔频谱图转换为语音波形的声码器。如果为None
,则输出为梅尔频谱图。 -
output_cross_attentions
(可选,默认为False
的bool
) — 是否返回解码器的交叉注意力层的注意力张量。 -
return_output_lengths
(可选,默认为False
的bool
) — 是否返回具体的频谱/波形长度。
返回
torch.FloatTensor
元组,包含根据输入不同的元素
-
当
return_output_lengths
为 False 时-
spectrogram
(可选,当未提供vocoder
时返回)torch.FloatTensor
,形状为(output_sequence_length, config.num_mel_bins)
— 预测的对数梅尔频谱图。 -
waveform
(可选,当提供vocoder
时返回)torch.FloatTensor
,形状为(num_frames,)
— 预测的语音波形。 -
cross_attentions
(可选,当output_cross_attentions
为True
时返回)torch.FloatTensor
,形状为(config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)
— 解码器的交叉注意力层的输出。
-
-
当
return_output_lengths
为 True 时-
spectrograms
(可选,当未提供vocoder
时返回)torch.FloatTensor
,形状为(batch_size, output_sequence_length, config.num_mel_bins)
— 预测的对数梅尔频谱图,填充到最大长度。 -
spectrogram_lengths
(可选,在没有提供vocoder
时返回)List[Int]
— 每个频谱图的具体长度的列表。 -
waveforms
(可选,在提供vocoder
时返回)torch.FloatTensor
,形状为(batch_size, num_frames)
— 预测的语音波形,填充到最大长度。 -
waveform_lengths
(可选,在提供vocoder
时返回)List[Int]
— 每个波形的具体长度的列表。 -
cross_attentions
(可选,当output_cross_attentions
为True
时返回)torch.FloatTensor
,形状为(batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)
— 解码器的交叉注意力层的输出。
-
将一系列输入标记转换为一系列 mel 频谱图,随后使用声码器将其转换为语音波形。
SpeechT5ForSpeechToSpeech
class transformers.SpeechT5ForSpeechToSpeech
( config: SpeechT5Config )
参数
config
(SpeechT5Config)— 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
具有语音编码器和语音解码器的 SpeechT5 模型。该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
该模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_values: Optional = None attention_mask: Optional = None decoder_input_values: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None speaker_embeddings: Optional = None labels: Optional = None stop_labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqSpectrogramOutput or tuple(torch.FloatTensor)
参数
-
attention_mask
(torch.LongTensor
,形状为(batch_size, sequence_length)
,可选)— 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选定在[0, 1]
之间:-
1 表示未被
masked
的标记, -
0 表示被
masked
的标记。
什么是注意力掩码?
只有在相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,应避免传递attention_mask
以避免在进行批量推断时性能下降。对于这些模型,input_values
应简单地用 0 填充并在不传递attention_mask
的情况下传递。请注意,这些模型还会根据input_values
是否填充而产生略有不同的结果。 -
-
decoder_attention_mask
(torch.LongTensor
,形状为(batch_size, target_sequence_length)
,可选)— 默认行为:生成一个张量,忽略decoder_input_values
中的填充标记。因果掩码也将默认使用。如果要更改填充行为,您应阅读
SpeechT5Decoder._prepare_decoder_attention_mask
并根据需要进行修改。有关默认策略的更多信息,请参阅论文中的图表 1。 -
head_mask
(torch.FloatTensor
,形状为(encoder_layers, encoder_attention_heads)
,可选)— 用于将编码器中注意力模块的选定头部置零的掩码。掩码值选定在[0, 1]
之间:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
decoder_head_mask
(torch.FloatTensor
,形状为(decoder_layers, decoder_attention_heads)
,可选)— 用于使解码器中选择的注意力模块的头部失效的掩码。掩码值选在[0, 1]
之间:-
1 表示头部未被遮蔽,
-
0 表示头部被遮蔽。
-
-
cross_attn_head_mask
(torch.Tensor
,形状为(decoder_layers, decoder_attention_heads)
,可选)— 用于使交叉注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]
之间:-
1 表示头部未被遮蔽,
-
0 表示头部被遮蔽。
-
-
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选)— 元组包含(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
形状为(batch_size, sequence_length, hidden_size)
,可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(请参阅
past_key_values
输入)。如果使用
past_key_values
,用户可以选择仅输入最后一个形状为(batch_size, 1)
的decoder_input_values
(那些没有将其过去键值状态提供给此模型的值),而不是形状为(batch_size, sequence_length)
的所有decoder_input_values
。decoder_inputs_embeds
(torch.FloatTensor
,形状为(batch_size, target_sequence_length, hidden_size)
,可选):可选地,您可以选择直接传递嵌入表示,而不是传递decoder_input_values
。如果使用past_key_values
,可以选择仅输入最后一个decoder_inputs_embeds
(请参阅past_key_values
)。如果您想要更多控制权来将decoder_input_values
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 -
use_cache
(bool
,可选)— 如果设置为True
,将返回past_key_values
键值状态,可用于加速解码(请参阅past_key_values
)。 -
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多细节,请参阅返回张量中的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多细节,请参阅返回张量中的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。 -
input_values
(torch.FloatTensor
,形状为(batch_size, sequence_length)
)— 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得值,例如通过 soundfile 库(pip install soundfile)。要将数组准备成input_values
,应使用 SpeechT5Processor 进行填充和转换为torch.FloatTensor
类型的张量。有关详细信息,请参阅 SpeechT5Processor.call
()。 -
decoder_input_values
(torch.FloatTensor
,形状为(batch_size, sequence_length, config.num_mel_bins)
)— 输入梅尔频谱图的浮点值。SpeechT5 使用全零频谱作为
decoder_input_values
生成的起始标记。如果使用past_key_values
,可以选择只输入最后的decoder_input_values
(参见past_key_values
)。 -
speaker_embeddings
(torch.FloatTensor
,形状为(batch_size, config.speaker_embedding_dim)
,可选) — 包含说话者嵌入的张量。 -
labels
(torch.FloatTensor
,形状为(batch_size, sequence_length, config.num_mel_bins)
,可选) — 目标梅尔频谱的浮点值。可以使用 SpeechT5Processor 获取频谱图。详细信息请参见 SpeechT5Processor.call
()。
返回
transformers.modeling_outputs.Seq2SeqSpectrogramOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqSpectrogramOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含各种元素,取决于配置(SpeechT5Config)和输入。
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,在提供labels
时返回) — 频谱图生成损失。 -
spectrogram
(torch.FloatTensor
,形状为(batch_size, sequence_length, num_bins)
) — 预测的频谱图。 -
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,在传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。包含预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码(查看
past_key_values
输入)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,在传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每一层的输出一个)。解码器每一层输出的隐藏状态加上初始嵌入输出。
-
decoder_attentions
(tuple(torch.FloatTensor)
,可选,在传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
-
cross_attentions
(tuple(torch.FloatTensor)
,可选,在传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。编码器在每一层输出的隐藏状态以及初始嵌入输出。
-
encoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
SpeechT5ForSpeechToSpeech 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此之后调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import SpeechT5Processor, SpeechT5ForSpeechToSpeech, SpeechT5HifiGan, set_seed
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset(
... "hf-internal-testing/librispeech_asr_demo", "clean", split="validation"
... ) # doctest: +IGNORE_RESULT
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_vc")
>>> model = SpeechT5ForSpeechToSpeech.from_pretrained("microsoft/speecht5_vc")
>>> vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
>>> # audio file is decoded on the fly
>>> inputs = processor(audio=dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> speaker_embeddings = torch.zeros((1, 512)) # or load xvectors from a file
>>> set_seed(555) # make deterministic
>>> # generate speech
>>> speech = model.generate_speech(inputs["input_values"], speaker_embeddings, vocoder=vocoder)
>>> speech.shape
torch.Size([77824])
generate_speech
( input_values: FloatTensor speaker_embeddings: Optional = None attention_mask: Optional = None threshold: float = 0.5 minlenratio: float = 0.0 maxlenratio: float = 20.0 vocoder: Optional = None output_cross_attentions: bool = False return_output_lengths: bool = False ) → export const metadata = 'undefined';tuple(torch.FloatTensor) comprising various elements depending on the inputs
参数
-
input_values
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载到
List[float]
类型的数组或numpy.ndarray
中来获取值,例如通过声音文件库(pip install soundfile)。要将数组准备成input_values
,应该使用 SpeechT5Processor 进行填充和转换为torch.FloatTensor
类型的张量。有关详细信息,请参阅 SpeechT5Processor.call
()。 -
speaker_embeddings
(torch.FloatTensor
,形状为(batch_size, config.speaker_embedding_dim)
,optional) — 包含说话者嵌入的张量。 -
attention_mask
(torch.LongTensor
,形状为(batch_size, sequence_length)
,optional) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]
之间:-
对于未被
masked
的标记,值为 1。 -
对于被
masked
的标记,值为 0。
什么是注意力掩码?
-
-
threshold
(float
,optional,默认为 0.5) — 当预测的停止标记概率超过此值时,生成的序列结束。 -
minlenratio
(float
,optional,默认为 0.0) — 用于计算输出序列的最小所需长度。 -
maxlenratio
(float
,optional,默认为 20.0) — 用于计算输出序列的最大允许长度。 -
vocoder
(nn.Module
,optional,默认为None
) — 将梅尔频谱图转换为语音波形的声码器。如果为None
,则输出为梅尔频谱图。 -
output_cross_attentions
(bool
,optional,默认为False
) — 是否返回解码器交叉注意力层的注意力张量。 -
return_output_lengths
(bool
,optional,默认为False
) — 是否返回具体的频谱/波形长度。
返回
包含各种元素的tuple(torch.FloatTensor)
,取决于输入
-
当
return_output_lengths
为 False 时-
spectrogram
(optional,当未提供vocoder
时返回) 形状为(output_sequence_length, config.num_mel_bins)
的torch.FloatTensor
— 预测的对数梅尔频谱图。 -
waveform
(optional,当提供vocoder
时返回) 形状为(num_frames,)
的torch.FloatTensor
— 预测的语音波形。 -
cross_attentions
(可选, 当output_cross_attentions
为True
时返回)torch.FloatTensor
,形状为(config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)
— 解码器交叉注意力层的输出。
-
-
当
return_output_lengths
为 True 时-
spectrograms
(可选, 当未提供vocoder
时返回)torch.FloatTensor
,形状为(batch_size, output_sequence_length, config.num_mel_bins)
— 预测的对数梅尔频谱图,已填充到最大长度。 -
spectrogram_lengths
(可选, 当未提供vocoder
时返回)List[Int]
— 每个频谱图的具体长度列表。 -
waveforms
(可选, 当提供vocoder
时返回)torch.FloatTensor
,形状为(batch_size, num_frames)
— 预测的语音波形,已填充到最大长度。 -
waveform_lengths
(可选, 当提供vocoder
时返回)List[Int]
— 每个波形的具体长度列表。 -
cross_attentions
(可选, 当output_cross_attentions
为True
时返回)torch.FloatTensor
,形状为(batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length)
— 解码器交叉注意力层的输出。
-
将原始语音波形转换为一系列梅尔频谱图,随后使用语音合成器将其转换回语音波形。
SpeechT5HifiGan
class transformers.SpeechT5HifiGan
( config: SpeechT5HifiGanConfig )
参数
config
(SpeechT5HifiGanConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
HiFi-GAN 语音合成器。该模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
该模型也是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( spectrogram: FloatTensor ) → export const metadata = 'undefined';torch.FloatTensor
参数
spectrogram
(torch.FloatTensor
) — 包含对数梅尔频谱图的张量。可以是批处理的,形状为(batch_size, sequence_length, config.model_in_dim)
,也可以是未经批处理的,形状为(sequence_length, config.model_in_dim)
。
返回
torch.FloatTensor
包含语音波形的张量。如果输入的频谱图是批处理的,则形状为(batch_size, num_frames,)
。如果未经批处理,则形状为(num_frames,)
。
将对数梅尔频谱图转换为语音波形。传递一批对数梅尔频谱图将返回一批语音波形。传递单个、未经批处理的对数梅尔频谱图将返回单个、未经批处理的语音波形。
UniSpeech
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/unispeech
概述
UniSpeech 模型是由 Chengyi Wang、Yu Wu、Yao Qian、Kenichi Kumatani、Shujie Liu、Furu Wei、Michael Zeng、Xuedong Huang 在UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data中提出的。
论文摘要如下:
在本文中,我们提出了一种统一的预训练方法 UniSpeech,用于学习具有未标记和标记数据的语音表示,其中通过多任务学习方式进行监督语音 CTC 学习和语音感知对比自监督学习。所得到的表示可以捕获更多与语音结构相关的信息,并提高跨语言和领域的泛化能力。我们在公共 CommonVoice 语料库上评估了 UniSpeech 在跨语言表示学习方面的有效性。结果显示,UniSpeech 相对于自监督预训练和监督迁移学习在语音识别方面分别最多减少了 13.4%和 17.8%的相对电话错误率(在所有测试语言上平均)。UniSpeech 的可迁移性也在领域转移语音识别任务中得到了证明,即相对于先前方法减少了 6%的相对词错误率。
该模型由patrickvonplaten贡献。作者的代码可以在这里找到。
使用提示
-
UniSpeech 是一个语音模型,接受与语音信号的原始波形对应的浮点数组。请使用 Wav2Vec2Processor 进行特征提取。
-
UniSpeech 模型可以使用连接主义时间分类(CTC)进行微调,因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。
资源
-
音频分类任务指南
-
自动语音识别任务指南
UniSpeechConfig
class transformers.UniSpeechConfig
( 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 = 'mean' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 num_ctc_classes = 80 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 replace_prob = 0.5 **kwargs )
参数
-
vocab_size
(int
, 可选, 默认为 32) — UniSpeech 模型的词汇表大小。定义了在调用 UniSpeechModel 时可以表示的不同标记的数量。模型的词汇表大小。定义了在调用 UniSpeechModel 的 forward 方法时可以表示的不同标记。 -
hidden_size
(int
, 可选, 默认为 768) — 编码器层和池化器层的维度。 -
num_hidden_layers
(int
, 可选, 默认为 12) — Transformer 编码器中的隐藏层数。 -
num_attention_heads
(int
, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。 -
intermediate_size
(int
, 可选, 默认为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。 -
hidden_act
(str
或function
, 可选, 默认为"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 -
hidden_dropout
(float
, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。 -
activation_dropout
(float
, optional, defaults to 0.1) — 全连接层内激活的 dropout 比率。 -
attention_dropout
(float
, optional, defaults to 0.1) — 注意力概率的 dropout 比率。 -
feat_proj_dropout
(float
, optional, defaults to 0.0) — 特征编码器输出的 dropout 概率。 -
feat_quantizer_dropout
(float
, optional, defaults to 0.0) — 用于量化器使用的特征编码器输出的 dropout 概率。 -
final_dropout
(float
, optional, defaults to 0.1) — UniSpeechForCTC 的最终投影层的 dropout 概率。 -
layerdrop
(float
, optional, defaults to 0.1) — LayerDrop 概率。有关详细信息,请参阅 LayerDrop paper)。 -
initializer_range
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 -
layer_norm_eps
(float
, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。 -
feat_extract_norm
(str
, optional, defaults to"group"
) — 应用于特征编码器中 1D 卷积层的规范化方式。"group"
表示仅对第一个 1D 卷积层进行组归一化,"layer"
表示对所有 1D 卷积层进行层归一化。 -
feat_extract_activation
(str, *optional*, defaults to
“gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数(函数或字符串)。如果是字符串,支持
“gelu”、
“relu”、
“selu”和
“gelu_new”`。 -
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, 2, 2)
) — 一个整数元组,定义特征编码器中每个 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 编码器的稳定层归一化架构。do_stable_layer_norm 为 True
表示在注意力层之前应用层归一化,而do_stable_layer_norm 为 False
表示在注意力层之后应用层归一化。 -
apply_spec_augment
(bool
, optional, defaults toTrue
) — 是否对特征编码器的输出应用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。 -
num_negatives
(int
, 可选, 默认为 100) — 对比损失的负样本数量。 -
codevector_dim
(int
, 可选, 默认为 256) — 量化特征向量的维度。 -
proj_codevector_dim
(int
, 可选, 默认为 256) — 最终投影的维度,用于量化和变换特征。 -
diversity_loss_weight
(int
, 可选, 默认为 0.1) — 码本多样性损失组件的权重。 -
ctc_loss_reduction
(str
, 可选, 默认为"mean"
) — 指定应用于torch.nn.CTCLoss
输出的减少方式。仅在训练 UniSpeechForCTC 的实例时相关。 -
ctc_zero_infinity
(bool
, 可选, 默认为False
) — 是否将torch.nn.CTCLoss
的无限损失和相关梯度置零。当输入太短无法与目标对齐时,主要会出现无限损失。仅在训练 UniSpeechForCTC 的实例时相关。 -
use_weighted_layer_sum
(bool
, 可选, 默认为False
) — 是否使用具有学习权重的层输出的加权平均值。仅在使用 UniSpeechForSequenceClassification 的实例时相关。 -
classifier_proj_size
(int
, 可选, 默认为 256) — 用于分类的令牌均值池化之前的投影的维度。 -
num_ctc_classes
(int
, optional, 默认为 80) — 指定音素级 CTC 损失的类别数(音素标记和空白标记)。仅在使用 UniSpeechForPreTraining 的实例时相关。 -
pad_token_id
(int
, optional, 默认为 0) — 填充标记的 id。 -
bos_token_id
(int
, optional, 默认为 1) — “序列开始”标记的 id。 -
eos_token_id
(int
, optional, 默认为 2) — “序列结束”标记的 id。 -
replace_prob
(float
,optional,默认为 0.5) — 替换 transformer 特征为预训练的量化特征的概率。
这是一个配置类,用于存储 UniSpeechModel 的配置。根据指定的参数实例化 UniSpeech 模型,定义模型架构。使用默认值实例化配置将产生类似于 UniSpeech microsoft/unispeech-large-1500h-cv架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import UniSpeechConfig, UniSpeechModel
>>> # Initializing a UniSpeech facebook/unispeech-base-960h style configuration
>>> configuration = UniSpeechConfig()
>>> # Initializing a model (with random weights) from the facebook/unispeech-base-960h style configuration
>>> model = UniSpeechModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
UniSpeech 特定的输出
class transformers.models.unispeech.modeling_unispeech.UniSpeechForPreTrainingOutput
( loss: Optional = None projected_states: FloatTensor = None projected_quantized_states: FloatTensor = None codevector_perplexity: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(optional,当模型处于训练模式时返回,形状为(1,)
的torch.FloatTensor
) — 总损失,作为对比损失(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)
,optional,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。模型在每层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,optional,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
UniSpeechForPreTrainingOutput
的输出类型,具有潜在的隐藏状态和注意力。
UniSpeechModel
class transformers.UniSpeechModel
( config: UniSpeechConfig )
参数
config
(UniSpeechConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
裸 UniSpeech 模型变压器,输出没有特定头部的原始隐藏状态。UniSpeech 由 Chengyi Wang、Yu Wu、Yao Qian、Kenichi Kumatani、Shujie Liu、Furu Wei、Michael Zeng、Xuedong Huang 在UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data中提出。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存等)。
此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_values: Optional attention_mask: Optional = None mask_time_indices: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Wav2Vec2BaseModelOutput or 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)
, optional) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选在[0, 1]
之间:-
对于未被
masked
的标记为 1, -
对于被
masked
的标记为 0。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,应避免在进行批量推断时传递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 而不是普通元组。
返回
transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(UniSpeechConfig)和输入的不同元素。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
)- 模型最后一层输出的隐藏状态序列。 -
extract_features
(形状为(batch_size, sequence_length, conv_dim[-1])
的torch.FloatTensor
)- 模型最后一个卷积层提取的特征向量序列。 -
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 之后的注意力权重,用于计算自注意力头中的加权平均值。
UniSpeechModel 的前向方法覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoProcessor, UniSpeechModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/unispeech-large-1500h-cv-timit")
>>> model = UniSpeechModel.from_pretrained("patrickvonplaten/unispeech-large-1500h-cv-timit")
>>> # 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, 1024]
UniSpeechForCTC
class transformers.UniSpeechForCTC
( config target_lang: Optional = None )
参数
-
config
(UniSpeechConfig)- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。 -
target_lang
(str
,可选)- 适配器权重的语言 id。适配器权重存储在格式为 adapter..safetensors 或 adapter. .bin 的文件中。仅在使用带有适配器的 UniSpeechForCTC 实例时相关。默认使用‘eng’。
UniSpeech 模型在顶部带有语言建模
头部,用于连接主义时间分类(CTC)。UniSpeech 是由 Chengyi Wang、Yu Wu、Yao Qian、Kenichi Kumatani、Shujie Liu、Furu Wei、Michael Zeng、Xuedong Huang 在UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data中提出的。
该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存等)。
该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutput or tuple(torch.FloatTensor)
参数
-
input_values
(torch.FloatTensor
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)
, optional) — 用于避免在填充标记索引上执行卷积和注意力的掩码。选择的掩码值在[0, 1]
中。-
1 表示未被
masked
的标记, -
0 表示被
masked
的标记。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,当进行批量推断时,应避免传递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
of shape(batch_size, target_length)
, optional) — 连接主义时间分类的标签。请注意,target_length
必须小于或等于输出 logits 的序列长度。索引在[-100, 0, ..., config.vocab_size - 1]
中选择。所有设置为-100
的标签都被忽略(被masked
),损失仅计算在[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
时)包含根据配置(UniSpeechConfig)和输入的不同元素。
-
loss
(torch.FloatTensor
of shape(1,)
, optional, 当提供labels
时返回) — 语言建模损失(用于下一个标记预测)。 -
logits
(torch.FloatTensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型具有嵌入层,则为嵌入的输出+每个层的输出)。每层模型的输出处的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
UniSpeechForCTC 的前向方法覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoProcessor, UniSpeechForCTC
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/unispeech-large-1500h-cv-timit")
>>> model = UniSpeechForCTC.from_pretrained("patrickvonplaten/unispeech-large-1500h-cv-timit")
>>> # 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 apposl of the midle classes and weare glad to welcom his gosepl'
>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
17.17
UniSpeechForSequenceClassification
class transformers.UniSpeechForSequenceClassification
( config )
参数
config
(UniSpeechConfig)— 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
带有顶部序列分类头(池化输出上的线性层)的 UniSpeech 模型,用于类似 SUPERB 关键词检测的任务。
UniSpeech 是由 Chengyi Wang、Yu Wu、Yao Qian、Kenichi Kumatani、Shujie Liu、Furu Wei、Michael Zeng、Xuedong Huang 在UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data中提出的。
这个模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法(例如下载或保存等)。
这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or 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 表示“掩码”标记。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器的模型,如果处理器具有config.return_attention_mask == False
,在进行批量推理时应避免传递attention_mask
以避免性能下降。对于这样的模型,input_values
应该简单地用 0 填充并在不传递attention_mask
的情况下传递。请注意,这些模型根据input_values
是否填充会产生略有不同的结果。 -
-
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请查看返回的张量下的attentions
。 -
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请查看返回的张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 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
)包含不同元素,取决于配置(UniSpeechConfig)和输入。
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, config.num_labels)
) — 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传入output_hidden_states=True
或者config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的输出 + 每层的输出)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传入output_attentions=True
或者config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
UniSpeechForSequenceClassification 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在之后调用 Module
实例而不是这个函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoFeatureExtractor, UniSpeechForSequenceClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("patrickvonplaten/unispeech-large-1500h-cv-timit")
>>> model = UniSpeechForSequenceClassification.from_pretrained("patrickvonplaten/unispeech-large-1500h-cv-timit")
>>> # 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]
>>> # 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
UniSpeechForPreTraining
class transformers.UniSpeechForPreTraining
( config: UniSpeechConfig )
参数
config
(UniSpeechConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
带有矢量量化模块和用于预训练的 ctc 损失的 UniSpeech 模型。UniSpeech 是由 Chengyi Wang、Yu Wu、Yao Qian、Kenichi Kumatani、Shujie Liu、Furu Wei、Michael Zeng、Xuedong Huang 在UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data中提出的。
这个模型继承自 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 ) → export const metadata = 'undefined';transformers.models.unispeech.modeling_unispeech.UniSpeechForPreTrainingOutput or tuple(torch.FloatTensor)
参数
-
input_values
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 输入原始语音波形的浮点值。值可以通过将.flac
或.wav
音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得,例如通过 soundfile 库(pip install soundfile
)。要准备好数组以获得input_values
,应使用 AutoProcessor 进行填充和转换为torch.FloatTensor
类型的张量。有关详细信息,请参见 Wav2Vec2Processor.call
()。 -
attention_mask
(torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 用于避免在填充标记索引上执行卷积和注意力的掩码。选择的掩码值在[0, 1]
中:-
对于“未屏蔽”的标记,为 1,
-
对于“屏蔽”的标记,为 0。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,应避免在进行批量推理时传递attention_mask
以避免性能下降。对于这样的模型,input_values
应该简单地用 0 填充并在不传递attention_mask
的情况下传递。请注意,这些模型根据input_values
是否填充会产生略有不同的结果。 -
-
output_attentions
(bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回的张量下的attentions
。 -
output_hidden_states
(bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回的张量下的hidden_states
。 -
return_dict
(bool
, 可选) — 是否返回一个 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.unispeech.modeling_unispeech.UniSpeechForPreTrainingOutput 或tuple(torch.FloatTensor)
一个 transformers.models.unispeech.modeling_unispeech.UniSpeechForPreTrainingOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含各种元素,取决于配置(UniSpeechConfig)和输入。
-
loss
(可选,当模型处于训练模式时返回,形状为(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 之后的注意力权重,用于计算自注意力头中的加权平均值。
UniSpeechForPreTraining 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在这个函数中定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> import torch
>>> from transformers import AutoFeatureExtractor, UniSpeechForPreTraining
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-large-1500h-cv")
>>> model = UniSpeechForPreTraining.from_pretrained("microsoft/unispeech-large-1500h-cv")
>>> # TODO: Add full pretraining example
UniSpeech-SAT
查看原文:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/unispeech-sat
概述
UniSpeech-SAT 模型是由 Sanyuan Chen、Yu Wu、Chengyi Wang、Zhengyang Chen、Zhuo Chen、Shujie Liu、Jian Wu、Yao Qian、Furu Wei、Jinyu Li、Xiangzhan Yu 在UniSpeech-SAT: Universal Speech Representation Learning with Speaker Aware Pre-Training中提出的。
论文摘要如下:
自监督学习(SSL)是语音处理的一个长期目标,因为它利用大规模未标记数据,避免了大量的人工标注。近年来,在语音识别中应用自监督学习取得了巨大成功,但在建模说话者特征方面的尝试有限。在本文中,我们旨在改进现有的 SSL 框架,用于说话者表示学习。我们介绍了两种方法来增强无监督说话者信息提取。首先,我们将多任务学习应用于当前的 SSL 框架,将话语级对比损失与 SSL 目标函数整合在一起。其次,为了更好地区分说话者,我们提出了一种话语混合策略用于数据增强,其中额外的重叠话语是无监督创建的,并在训练过程中整合。我们将这些方法整合到 HuBERT 框架中。在 SUPERB 基准上的实验结果表明,所提出的系统在通用表示学习方面取得了最先进的性能,特别是针对说话者识别导向的任务。进行了消融研究,验证了每种提出方法的有效性。最后,我们将训练数据集扩大到 94,000 小时的公共音频数据,并在所有 SUPERB 任务中实现了进一步的性能提升。
这个模型是由patrickvonplaten贡献的。作者的代码可以在这里找到。
使用提示
-
UniSpeechSat 是一个语音模型,接受与语音信号的原始波形对应的浮点数组。请使用 Wav2Vec2Processor 进行特征提取。
-
UniSpeechSat 模型可以使用连接主义时间分类(CTC)进行微调,因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。
-
UniSpeechSat 在说话者验证、说话者识别和说话者日程任务中表现特别好。
资源
-
音频分类任务指南
-
自动语音识别任务指南
UniSpeechSatConfig
class transformers.UniSpeechSatConfig
( 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 = 'mean' 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 num_clusters = 504 **kwargs )
参数
-
vocab_size
(int
,可选,默认为 32)— UniSpeechSat 模型的词汇大小。定义了在调用 UniSpeechSatModel 时可以表示的不同令牌的数量。模型的词汇大小。定义了可以由传递给 UniSpeechSatModel 的inputs_ids表示的不同令牌。 -
hidden_size
(int
,可选,默认为 768)— 编码器层和池化层的维度。 -
num_hidden_layers
(int
,可选,默认为 12)— Transformer 编码器中的隐藏层数。 -
num_attention_heads
(int
,可选,默认为 12)— Transformer 编码器中每个注意力层的注意力头数。 -
intermediate_size
(int
, optional, defaults to 3072) — Transformer 编码器中“中间”(即前馈)层的维度。 -
hidden_act
(str
orfunction
, optional, defaults to"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 -
hidden_dropout
(float
, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有完全连接层的 dropout 概率。 -
activation_dropout
(float
, optional, defaults to 0.1) — 完全连接层内激活的 dropout 比率。 -
attention_dropout
(float
, optional, defaults to 0.1) — 注意力概率的 dropout 比率。 -
feat_proj_dropout
(float
, optional, defaults to 0.0) — 特征编码器输出的 dropout 概率。 -
feat_quantizer_dropout
(float
, optional, defaults to 0.0) — 用于量化器使用的特征编码器输出的 dropout 概率。 -
final_dropout
(float
, optional, defaults to 0.1) — UniSpeechSatForCTC 的最终投影层的 dropout 概率。 -
layerdrop
(float
, optional, defaults to 0.1) — LayerDrop 概率。更多详情请参阅 LayerDrop 论文)。 -
initializer_range
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 -
layer_norm_eps
(float
, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。 -
feat_extract_norm
(str
, optional, defaults to"group"
) — 应用于特征编码器中的 1D 卷积层的规范化方式。可以选择"group"
表示仅对第一个 1D 卷积层进行组归一化,或者选择"layer"
表示对所有 1D 卷积层进行层归一化。 -
feat_extract_activation
(str, *optional*, defaults to
“gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数(函数或字符串)。如果是字符串,支持
“gelu”、
“relu”、
“selu”和
“gelu_new”`。 -
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, 2, 2)
) — 定义特征编码器中每个 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 编码器的稳定层归一化架构。do_stable_layer_norm is True
表示在注意力层之前应用层归一化,而do_stable_layer_norm is False
表示在注意力层之后应用层归一化。 -
apply_spec_augment
(bool
, optional, 默认为True
) — 是否对特征编码器的输出应用SpecAugment数据增强。有关详细信息,请参阅SpecAugment:用于自动语音识别的简单数据增强方法。 -
mask_time_prob
(float
, optional, 默认为 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
, optional, 默认为 10) — 沿时间轴的向量跨度长度。 -
mask_time_min_masks
(int
, optional, 默认为 2) — 沿时间轴生成的长度为mask_feature_length
的最小遮罩数量,每个时间步,与mask_feature_prob
无关。仅在“mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks”时相关。 -
mask_feature_prob
(float
, optional, 默认为 0.0) — 沿特征轴遮蔽的所有特征向量的百分比(介于 0 和 1 之间)。遮蔽过程在该轴上生成“mask_feature_problen(feature_axis)/mask_time_length”个独立的遮罩。如果从每个特征向量被选择为要遮蔽的向量跨度的起点的概率推理,mask_feature_prob*应为prob_vector_start*mask_feature_length
。请注意,重叠可能会降低实际遮蔽向量的百分比。仅在apply_spec_augment
为 True 时相关。 -
mask_feature_length
(int
, optional, 默认为 10) — 沿特征轴的向量跨度长度。 -
mask_feature_min_masks
(int
, optional, 默认为 0) — 沿特征轴生成的长度为mask_feature_length
的最小遮罩数量,每个时间步,与mask_feature_prob
无关。仅在“mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks”时相关。 -
num_codevectors_per_group
(int
, optional, 默认为 320) — 每个量化码书(组)中的条目数。 -
num_codevector_groups
(int
, optional, 默认为 2) — 产品码矢量量化的码矢量组数。 -
contrastive_logits_temperature
(float
, optional, 默认为 0.1) — 对比损失中的温度kappa。 -
num_negatives
(int
, optional, 默认为 100) — 对比损失的负样本数量。 -
codevector_dim
(int
, optional, 默认为 256) — 量化特征向量的维度。 -
proj_codevector_dim
(int
, optional, 默认为 256) — 量化和变换特征的最终投影的维度。 -
diversity_loss_weight
(int
, optional, 默认为 0.1) — 码书多样性损失组件的权重。 -
ctc_loss_reduction
(str
, optional, 默认为"mean"
) — 指定应用于torch.nn.CTCLoss
输出的减少方式。仅在训练 UniSpeechSatForCTC 实例时相关。 -
ctc_zero_infinity
(bool
, optional, 默认为False
) — 是否将torch.nn.CTCLoss
的无限损失和相关梯度置零。当输入太短无法与目标对齐时,主要会出现无限损失。仅在训练 UniSpeechSatForCTC 实例时相关。 -
use_weighted_layer_sum
(bool
,可选,默认为False
)— 是否使用带有学习权重的层输出的加权平均值。仅在使用 UniSpeechSatForSequenceClassification 的实例时相关。 -
classifier_proj_size
(int
,可选,默认为 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嵌入向量的维度。 -
pad_token_id
(int
,可选,默认为 0)— 填充标记的 id。 -
bos_token_id
(int
,可选,默认为 1)— “序列开始”标记的 id。 -
eos_token_id
(int
,可选,默认为 2)— “序列结束”标记的 id。 -
num_clusters
(int
,可选,默认为 504)— 弱标记的簇数。仅在使用 UniSpeechSatForPreTraining 的实例时相关。
这是用于存储 UniSpeechSatModel 配置的配置类。根据指定的参数实例化 UniSpeechSat 模型,定义模型架构。使用默认值实例化配置将产生类似于 UniSpeechSat microsoft/unispeech-sat-base-100h-libri-ft架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import UniSpeechSatModel, UniSpeechSatConfig
>>> # Initializing a UniSpeechSat microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> configuration = UniSpeechSatConfig()
>>> # Initializing a model from the microsoft/unispeech-sat-base-100h-libri-ft style configuration
>>> model = UniSpeechSatModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
UniSpeechSat 特定输出
class transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput
( loss: Optional = None logits: FloatTensor = None projected_states: FloatTensor = None projected_quantized_states: FloatTensor = None codevector_perplexity: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
loss
(可选,当模型处于训练模式时返回,形状为(1,)
的torch.FloatTensor
)— 总损失,作为对比损失(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
时返回)- 形状为(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 后的注意力权重,用于计算自注意力头中的加权平均值。
UniSpeechSatForPreTrainingOutput
的输出类型,具有潜在的隐藏状态和注意力。
UniSpeechSatModel
class transformers.UniSpeechSatModel
( config: UniSpeechSatConfig )
参数
config
(UniSpeechSatConfig)- 模型的配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸的 UniSpeechSat 模型变压器输出原始隐藏状态,没有特定的头部。UniSpeechSat 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在《wav2vec 2.0:自监督学习语音表示的框架》中提出的。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存等)。
此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
forward
( input_values: Optional attention_mask: Optional = None mask_time_indices: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Wav2Vec2BaseModelOutput or 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]
范围内:-
对于未被
masked
的标记为 1, -
对于被
masked
的标记为 0。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,例如microsoft/unispeech-sat-base-100h-libri-ft,在进行批量推断时应不
传递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
时)包含各种元素,这取决于配置(UniSpeechSatConfig)和输入。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
)— 模型最后一层输出的隐藏状态序列。 -
extract_features
(形状为(batch_size, sequence_length, conv_dim[-1])
的torch.FloatTensor
)— 模型最后一个卷积层提取的特征向量序列。 -
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 之后的注意力权重,用于计算自注意力头中的加权平均值。
UniSpeechSatModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoProcessor, UniSpeechSatModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatModel.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 292, 768]
UniSpeechSatForCTC
class transformers.UniSpeechSatForCTC
( config target_lang: Optional = None )
参数
-
config
(UniSpeechSatConfig) — 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,只会加载配置。 请查看 from_pretrained() 方法以加载模型权重。 -
target_lang
(str
, optional) — 适配器权重的语言 id。 适配器权重存储在格式为 adapter..safetensors 或 adapter. .bin 的文件中。 仅在使用带有适配器的 UniSpeechSatForCTC 实例时相关。 默认情况下使用 ‘eng’。
带有顶部 语言建模
的 UniSpeechSat 模型,用于 Connectionist Temporal Classification (CTC)。 UniSpeechSat 是由 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: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutput or tuple(torch.FloatTensor)
参数
-
input_values
(torch.FloatTensor
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)
, optional) — 用于避免在填充标记索引上执行卷积和注意力的掩码。 选择的掩码值在[0, 1]
中:-
1 代表
未被掩码
的标记, -
0 代表
被掩码
的标记。
什么是注意力掩码?
只有在相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。 对于所有处理器具有config.return_attention_mask == False
的模型,例如 microsoft/unispeech-sat-base-100h-libri-ft,在进行批量推断时应不
传递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, target_length)
,optional) — 用于连接主义时间分类的标签。注意target_length
必须小于或等于输出 logits 的序列长度。索引在[-100, 0, ..., config.vocab_size - 1]
中选择。所有设置为-100
的标签都被忽略(掩码),损失仅计算在[0, ..., config.vocab_size - 1]
中的标签。
返回
transformers.modeling_outputs.CausalLMOutput 或torch.FloatTensor
元组
一个 transformers.modeling_outputs.CausalLMOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(UniSpeechSatConfig)和输入的不同元素。
-
loss
(torch.FloatTensor
,形状为(1,)
,optional,当提供labels
时返回) — 语言建模损失(用于下一个标记预测)。 -
logits
(torch.FloatTensor
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
UniSpeechSatForCTC 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoProcessor, UniSpeechSatForCTC
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForCTC.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
'MISTER QUILDER 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)
39.88
UniSpeechSatForSequenceClassification
class transformers.UniSpeechSatForSequenceClassification
( config )
参数
config
(UniSpeechSatConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
UniSpeechSat 模型在顶部具有一个序列分类头(在池化输出上的线性层),用于类似 SUPERB 关键词检测的任务。
UniSpeechSat 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在《wav2vec 2.0:自监督学习语音表示的框架》中提出的。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存等)。
这个模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)
参数
-
input_values
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 输入原始语音波形的浮点值。可以通过将.flac
或.wav
音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得值,例如通过 soundfile 库(pip install soundfile
)。要准备好数组以获得input_values
,应使用 AutoProcessor 进行填充和转换为torch.FloatTensor
类型的张量。有关详细信息,请参见 Wav2Vec2Processor.call
()。 -
attention_mask
(torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 用于避免在填充令牌索引上执行卷积和注意力的掩码。掩码值选在[0, 1]
之间:-
1 表示未被掩盖的令牌,
-
0 表示被掩盖的令牌。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,例如microsoft/unispeech-sat-base-100h-libri-ft,在进行批量推断时,应不
传递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
时),包含根据配置(UniSpeechSatConfig)和输入而异的各种元素。
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类(如果 config.num_labels==1 则为回归)损失。 -
logits
(torch.FloatTensor
,形状为(batch_size, config.num_labels)
) — 分类(如果 config.num_labels==1 则为回归)得分(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) - 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层的输出一个,+ 每个层的输出一个)。模型在每个层的输出的隐藏状态加上可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) - 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。在自注意力头中使用注意力 softmax 后的注意力权重,用于计算加权平均值。
UniSpeechSatForSequenceClassification 前向方法,覆盖__call__
特殊方法。
虽然前向传播的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForSequenceClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> model = UniSpeechSatForSequenceClassification.from_pretrained("microsoft/unispeech-sat-base-100h-libri-ft")
>>> # 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]
>>> # 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
UniSpeechSatForAudioFrameClassification
class transformers.UniSpeechSatForAudioFrameClassification
( config )
参数
config
(UniSpeechSatConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。
UniSpeech-SAT 模型顶部带有用于说话人分离等任务的帧分类头。
UniSpeechSat 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在wav2vec 2.0:自监督学习语音表示的框架中提出的。
此模型继承自 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)
参数
-
input_values
(形状为(batch_size, sequence_length)
的torch.FloatTensor
) - 输入原始语音波形的浮点值。可以通过将.flac
或.wav
音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得。通过 AutoProcessor 将数组准备为input_values
,并将其转换为torch.FloatTensor
类型的张量。有关详细信息,请参阅 Wav2Vec2Processor.call
()。 -
attention_mask
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选) - 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]
中:-
对于未被
masked
的标记为 1 的标记, -
对于被
masked
的标记为 0。
什么是注意力掩码?
只有在相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,例如microsoft/unispeech-sat-base-100h-libri-ft,在进行批量推断时,应不
传递attention_mask
以避免性能下降。对于这样的模型,input_values
应该简单地用 0 填充并在不带attention_mask
的情况下传递。请注意,这些模型根据input_values
是否填充而产生略有不同的结果。 -
-
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的attentions
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。 -
labels
(形状为(batch_size,)
的torch.LongTensor
,可选)— 用于计算序列分类/回归损失的标签。索引应在[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
时)包含各种元素,具体取决于配置(UniSpeechSatConfig)和输入。
-
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)— 分类损失。 -
logits
(形状为(batch_size, sequence_length, config.num_labels)
的torch.FloatTensor
)— 分类分数(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层的输出,+ 每个层的输出)。模型在每个层的输出隐藏状态加上可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
UniSpeechSatForAudioFrameClassification 的前向方法重写了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base-plus-sd")
>>> model = UniSpeechSatForAudioFrameClassification.from_pretrained("microsoft/unispeech-sat-base-plus-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]
UniSpeechSatForXVector
class transformers.UniSpeechSatForXVector
( config )
参数
config
(UniSpeechSatConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
UniSpeech-SAT 模型在顶部使用 XVector 特征提取头,用于说话者验证等任务。
UniSpeechSat 是由 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: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.XVectorOutput or 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]
范围内:-
对于
未屏蔽
的标记, -
对于
屏蔽
的标记为 0。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,例如microsoft/unispeech-sat-base-100h-libri-ft,在进行批量推断时应不
传递attention_mask
以避免性能下降。对于这些模型,input_values
应简单地填充为 0 并在不传递attention_mask
的情况下传递。请注意,这些模型的结果也会因input_values
是否填充而略有不同。 -
-
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选) — 是否返回 ModelOutput 而不是普通元组。 -
labels
(形状为(batch_size,)
的torch.LongTensor
,可选) — 用于计算序列分类/回归损失的标签。索引应在[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
)包含各种元素,具体取决于配置(UniSpeechSatConfig)和输入。
-
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)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。模型在每一层的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
UniSpeechSatForXVector 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForXVector
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base-plus-sv")
>>> model = UniSpeechSatForXVector.from_pretrained("microsoft/unispeech-sat-base-plus-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.97
UniSpeechSatForPreTraining
class transformers.UniSpeechSatForPreTraining
( config: UniSpeechSatConfig )
参数
config
(UniSpeechSatConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
UniSpeechSat 模型具有量化器和顶部的VQ
头。UniSpeechSat 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在《wav2vec 2.0:自监督学习语音表示的框架》中提出的。
该模型继承自 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 ) → export const metadata = 'undefined';transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput or tuple(torch.FloatTensor)
参数
-
input_values
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 输入原始语音波形的浮点值。可以通过将.flac
或.wav
音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得。通过声音文件库(pip install soundfile
)等方式。要准备好数组为input_values
,应使用 AutoProcessor 进行填充和转换为torch.FloatTensor
类型的张量。有关详细信息,请参阅 Wav2Vec2Processor.call
()。 -
attention_mask
(torch.LongTensor
,形状为(batch_size, sequence_length)
,optional) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]
之间:-
1 代表未被掩盖的标记,
-
0 代表被掩盖的标记。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,例如 microsoft/unispeech-sat-base-100h-libri-ft,在进行批量推断时,应避免传递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 而不是一个普通元组。
返回
transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.unispeech_sat.modeling_unispeech_sat.UniSpeechSatForPreTrainingOutput 或一个 torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含各种元素,取决于配置(UniSpeechSatConfig)和输入。
-
loss
(optional,在模型处于训练模式时返回,形状为(1,)
的torch.FloatTensor
) — 总损失,作为对比损失(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
时返回) — 形状为(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 之后,用于计算自注意力头中的加权平均值。
UniSpeechSatForPreTraining 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在之后调用Module
实例,而不是这个函数,因为前者会负责运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> import torch
>>> from transformers import AutoFeatureExtractor, UniSpeechSatForPreTraining
>>> from transformers.models.unispeech_sat.modeling_unispeech_sat import _compute_mask_indices
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/unispeech-sat-base")
>>> model = UniSpeechSatForPreTraining.from_pretrained("microsoft/unispeech-sat-base")
>>> # TODO: Add full pretraining example
UnivNet
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/univnet
概述
UnivNet 模型是由 Won Jang、Dan Lim、Jaesam Yoon、Bongwan Kin 和 Juntae Kim 在UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation中提出的。UnivNet 模型是一个生成对抗网络(GAN),用于合成高保真度语音波形。在transformers
中共享的 UnivNet 模型是生成器,它将一个条件化的对数梅尔频谱图和可选的噪声序列映射到语音波形(例如声码器)。推理只需要生成器。用于训练生成器
的鉴别器没有实现。
论文摘要如下:
大多数神经声码器使用带限制的梅尔频谱图来生成波形。如果将全频段谱特征用作输入,则声码器可以提供尽可能多的声学信息。然而,在一些使用全频段梅尔频谱图的模型中,会出现过度平滑的问题,其中生成了非锐利的频谱图。为了解决这个问题,我们提出了 UnivNet,一个能够实时合成高保真波形的神经声码器。受到语音活动检测领域的研究启发,我们添加了一个多分辨率谱图鉴别器,该鉴别器使用了使用不同参数集计算的多个线性谱图幅度。通过使用全频段梅尔频谱图作为输入,我们希望通过添加一个使用多个分辨率谱图作为输入的鉴别器来生成高分辨率信号。在包含数百位说话者信息的数据集上进行评估时,UnivNet 在看到和未看到的说话者方面获得了最佳客观和主观结果。这些结果,包括文本转语音的最佳主观评分,展示了快速适应新说话者的潜力,而无需从头开始训练。
提示:
-
UnivNetModel.forward()的
noise_sequence
参数应为标准的高斯噪声(例如来自torch.randn
),形状为([batch_size], noise_length, model.config.model_in_channels)
,其中noise_length
应与input_features
参数的长度维度(维度 1)匹配。如果未提供,将随机生成;可以向generator
参数提供torch.Generator
,以便可以重现前向传递。(请注意,UnivNetFeatureExtractor 默认会返回生成的噪声,因此通常不需要手动生成noise_sequence
。) -
通过
UnivNetFeatureExtractor.batch_decode()
方法可以从 UnivNetModel 输出中移除 UnivNetFeatureExtractor 添加的填充,如下面的用法示例所示。 -
在每个波形的末尾填充静音可以减少生成音频样本末尾的伪影。可以通过在 UnivNetFeatureExtractor.call()中提供
pad_end = True
来实现。更多细节请参见此问题。
用法示例:
import torch
from scipy.io.wavfile import write
from datasets import Audio, load_dataset
from transformers import UnivNetFeatureExtractor, UnivNetModel
model_id_or_path = "dg845/univnet-dev"
model = UnivNetModel.from_pretrained(model_id_or_path)
feature_extractor = UnivNetFeatureExtractor.from_pretrained(model_id_or_path)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
# Resample the audio to the model and feature extractor's sampling rate.
ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
# Pad the end of the converted waveforms to reduce artifacts at the end of the output audio samples.
inputs = feature_extractor(
ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], pad_end=True, return_tensors="pt"
)
with torch.no_grad():
audio = model(**inputs)
# Remove the extra padding at the end of the output.
audio = feature_extractor.batch_decode(**audio)[0]
# Convert to wav file
write("sample_audio.wav", feature_extractor.sampling_rate, audio)
该模型由dg845贡献。据我所知,没有官方代码发布,但可以在maum-ai/univnet找到非官方实现,预训练检查点在这里。
UnivNetConfig
class transformers.UnivNetConfig
( model_in_channels = 64 model_hidden_channels = 32 num_mel_bins = 100 resblock_kernel_sizes = [3, 3, 3] resblock_stride_sizes = [8, 8, 4] resblock_dilation_sizes = [[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]] kernel_predictor_num_blocks = 3 kernel_predictor_hidden_channels = 64 kernel_predictor_conv_size = 3 kernel_predictor_dropout = 0.0 initializer_range = 0.01 leaky_relu_slope = 0.2 **kwargs )
参数
-
model_in_channels
(int
,可选,默认为 64)- UnivNet 残差网络的输入通道数。这应该对应于noise_sequence.shape[1]
和 UnivNetFeatureExtractor 类中使用的值。 -
model_hidden_channels
(int
,可选,默认为 32)- UnivNet 残差网络中每个残差块的隐藏通道数。 -
num_mel_bins
(int
,可选,默认为 100)- 条件对数梅尔频谱图中的频率箱数。这应该对应于 UnivNetFeatureExtractor 类中使用的值。 -
resblock_kernel_sizes
(Tuple[int]
或List[int]
,可选,默认为[3, 3, 3]
)- 一个整数元组,定义了 UnivNet 残差网络中 1D 卷积层的内核大小。resblock_kernel_sizes
的长度定义了 resnet 块的数量,并应与resblock_stride_sizes
和resblock_dilation_sizes
相匹配。 -
resblock_stride_sizes
(Tuple[int]
或List[int]
,可选,默认为[8, 8, 4]
)- 一个整数元组,定义了 UnivNet 残差网络中 1D 卷积层的步幅大小。resblock_stride_sizes
的长度应与resblock_kernel_sizes
和resblock_dilation_sizes
相匹配。 -
resblock_dilation_sizes
(Tuple[Tuple[int]]
或List[List[int]]
,可选,默认为[[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]
)- 一个嵌套的整数元组,定义了 UnivNet 残差网络中扩张的 1D 卷积层的扩张率。resblock_dilation_sizes
的长度应与resblock_kernel_sizes
和resblock_stride_sizes
相匹配。resblock_dilation_sizes
中每个嵌套列表的长度定义了每个 resnet 块中的卷积层数量。 -
kernel_predictor_num_blocks
(int
,可选,默认为 3)- 核预测网络中的残差块数量,用于计算 UnivNet 残差网络中每个位置变量卷积层的内核和偏置。 -
kernel_predictor_hidden_channels
(int
,可选,默认为 64)- 核预测网络中每个残差块的隐藏通道数。 -
kernel_predictor_conv_size
(int
,可选,默认为 3)- 核预测网络中每个 1D 卷积层的内核大小。 -
kernel_predictor_dropout
(float
,可选,默认为 0.0)- 核预测网络中每个残差块的丢失概率。 -
initializer_range
(float
,可选,默认为 0.01)- 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
leaky_relu_slope
(float
,可选,默认为 0.2)- leaky ReLU 激活函数使用的负斜率的角度。
这是一个配置类,用于存储 UnivNetModel 的配置。根据指定的参数实例化一个 UnivNet 声码器模型,定义模型架构。使用默认值实例化配置将产生类似于 UnivNet dg845/univnet-dev架构的配置,该架构对应于maum-ai/univnet中的‘c32’架构。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import UnivNetModel, UnivNetConfig
>>> # Initializing a Tortoise TTS style configuration
>>> configuration = UnivNetConfig()
>>> # Initializing a model (with random weights) from the Tortoise TTS style configuration
>>> model = UnivNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
UnivNetFeatureExtractor
class transformers.UnivNetFeatureExtractor
( feature_size: int = 1 sampling_rate: int = 24000 padding_value: float = 0.0 do_normalize: bool = False num_mel_bins: int = 100 hop_length: int = 256 win_length: int = 1024 win_function: str = 'hann_window' filter_length: Optional = 1024 max_length_s: int = 10 fmin: float = 0.0 fmax: Optional = None mel_floor: float = 1e-09 center: bool = False compression_factor: float = 1.0 compression_clip_val: float = 1e-05 normalize_min: float = -11.512925148010254 normalize_max: float = 2.3143386840820312 model_in_channels: int = 64 pad_end_length: int = 10 return_attention_mask = True **kwargs )
参数
-
feature_size
(int
, optional, 默认为 1) — 提取特征的特征维度。 -
sampling_rate
(int
, optional, 默认为 24000) — 音频文件应该以赫兹(Hz)表示的数字化采样率。 -
padding_value
(float
, optional, 默认为 0.0) — 在应用由padding
参数定义的填充策略时要填充的值,应与音频静音对应。__call__
中的pad_end
参数也将使用此填充值。 -
do_normalize
(bool
, optional, 默认为False
) — 是否对输入执行 Tacotron 2 标准化。标准化可以帮助一些模型显著提高性能。 -
num_mel_bins
(int
, optional, 默认为 100) — 提取的频谱图特征中的梅尔频率箱数。这应该与UnivNetModel.config.num_mel_bins
匹配。 -
hop_length
(int
, optional, 默认为 256) — 滑动窗口之间的直接样本数。在许多论文中也称为“shift”。请注意,这与其他音频特征提取器(如 SpeechT5FeatureExtractor — 每个滑动窗口的直接样本数。请注意,这与其他音频特征提取器(如 SpeechT5FeatureExtractor — 用于窗口化的窗口函数的名称,必须通过torch.{win_function}
访问。 -
filter_length
(int
, optional, 默认为 1024) — 要使用的 FFT 组件数。如果为None
,则使用transformers.audio_utils.optimal_fft_length
来确定。 -
max_length_s
(int
, optional, 默认为 10) — 模型的最大输入长度,以秒为单位。这用于填充音频。 -
fmin
(float
, optional, 默认为 0.0) — 最小的梅尔频率,以赫兹为单位。 -
fmax
(float
, optional) — 最大的梅尔频率,以赫兹为单位。如果未设置,默认为sampling_rate / 2
。 -
mel_floor
(float
, optional, 默认为 1e-09) — 梅尔频率银行的最小值。请注意,UnivNetFeatureExtractor 使用mel_floor
的方式与 transformers.audio_utils.spectrogram() 中的方式不同。 -
center
(bool
, optional, 默认为False
) — 是否填充波形,使帧t
围绕时间t * hop_length
居中。如果为False
,帧t
将从时间t * hop_length
开始。 -
compression_factor
(float
, optional, 默认为 1.0) — 动态范围压缩期间的乘法压缩因子。 -
compression_clip_val
(float
, optional, 默认为 1e-05) — 在应用动态范围压缩期间应用于波形的剪切值。 -
normalize_min
(float
, 可选, 默认为-11.512925148010254) — 用于 Tacotron 2 风格线性归一化的最小值。默认值是 Tacotron 2 实现的原始值。 -
normalize_max
(float
, 可选, 默认为 2.3143386840820312) — 用于 Tacotron 2 风格线性归一化的最大值。默认值是 Tacotron 2 实现的原始值。 -
model_in_channels
(int
, 可选, 默认为 64) — UnivNetModel 模型的输入通道数。这应该与UnivNetModel.config.model_in_channels
匹配。 -
pad_end_length
(int
, 可选, 默认为 10) — 如果在每个波形的末尾填充,要附加的样本的频谱图帧数。附加的样本数将为pad_end_length * hop_length
。 -
return_attention_mask
(bool
, 可选, 默认为True
) —call
()是否应返回attention_mask
。
构建一个 UnivNet 特征提取器。
该类使用短时傅里叶变换(STFT)从原始语音中提取对数梅尔滤波器组特征。STFT 实现遵循 TacoTron 2 和 Hifi-GAN 的实现。
该特征提取器继承自 SequenceFeatureExtractor,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
__call__
( raw_speech: Union sampling_rate: Optional = None padding: Union = True max_length: Optional = None truncation: bool = True pad_to_multiple_of: Optional = None return_noise: bool = True generator: Optional = None pad_end: bool = False pad_length: Optional = None do_normalize: Optional = None return_attention_mask: Optional = None return_tensors: Union = None )
参数
-
raw_speech
(np.ndarray
,List[float]
,List[np.ndarray]
,List[List[float]]
) — 要填充的序列或批次序列。每个序列可以是一个 numpy 数组,一个浮点值列表,一个 numpy 数组列表或一个浮点值列表的列表。必须是单声道音频,不是立体声,即每个时间步长一个浮点数。 -
sampling_rate
(int
, 可选) — 输入raw_speech
采样的采样率。强烈建议在前向调用时传递sampling_rate
,以防止静默错误并允许自动语音识别流水线。 -
padding
(bool
,str
或 PaddingStrategy, 可选, 默认为True
) — 选择一种策略来填充输入raw_speech
波形(根据模型的填充方向和填充索引):-
True
或'longest'
:填充到批次中最长的序列(如果只提供一个序列,则不填充)。 -
'max_length'
:填充到指定的最大长度,该长度由参数max_length
指定,或者如果未提供该参数,则填充到模型的最大可接受输入长度。 -
False
或'do_not_pad'
(默认):不填充(即,可以输出具有不同长度序列的批次)。
如果
pad_end = True
,则填充将在应用padding
策略之前发生。 -
-
max_length
(int
, 可选) — 返回列表的最大长度和可选填充长度(见上文)。 -
truncation
(bool
, 可选, 默认为True
) — 激活截断,将长于max_length
的输入序列截断为max_length
。 -
pad_to_multiple_of
(int
, 可选) — 如果设置,将序列填充到提供的值的倍数。这对于在 NVIDIA 硬件上启用 Tensor Cores 特别有用,其计算能力为
>= 7.5
(Volta),或者对于受益于序列长度为 128 的倍数的 TPU。 -
return_noise
(bool
, 可选, 默认为True
) — 是否生成并返回用于 UnivNetModel.forward()的噪声波形。 -
generator
(numpy.random.Generator
, 可选, 默认为None
) — 生成噪音时要使用的可选numpy.random.Generator
随机数生成器。 -
pad_end
(bool
, 可选, 默认为False
) — 是否在每个波形的末尾填充静音。这可以帮助减少生成音频样本末尾的伪影。有关更多详细信息,请参阅github.com/seungwonpark/melgan/issues/8
。此填充将在执行padding
中指定的填充策略之前完成。 -
pad_length
(int
, 可选, 默认为None
) — 如果在每个波形的末尾填充,填充在频谱图帧中的长度。如果未设置,将默认为self.config.pad_end_length
。 -
do_normalize
(bool
, 可选) — 是否对输入执行 Tacotron 2 标准化。标准化可以帮助显著提高某些模型的性能。如果未设置,将默认为self.config.do_normalize
。 -
return_attention_mask
(bool
, 可选) — 是否返回注意力掩码。如果保持默认设置,将根据特定的 feature_extractor 默认返回注意力掩码。什么是注意力掩码?
-
return_tensors
(str
或 TensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:-
'tf'
: 返回 TensorFlowtf.constant
对象。 -
'pt'
: 返回 PyTorchtorch.np.array
对象。 -
'np'
: 返回 Numpynp.ndarray
对象。
-
对一个或多个序列进行特征化和准备模型的主要方法。
UnivNetModel
class transformers.UnivNetModel
( config: UnivNetConfig )
参数
config
(UnivNetConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
UnivNet GAN 语音合成器。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_features: FloatTensor noise_sequence: Optional = None padding_mask: Optional = None generator: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.univnet.modeling_univnet.UnivNetModelOutput or tuple(torch.FloatTensor)
参数
-
input_features
(torch.FloatTensor
) — 包含对数梅尔频谱图的张量。可以是批处理的,形状为(batch_size, sequence_length, config.num_mel_channels)
,也可以是非批处理的,形状为(sequence_length, config.num_mel_channels)
。 -
noise_sequence
(torch.FloatTensor
, 可选) — 包含标准高斯噪音的噪音序列的张量。可以是批处理的,形状为(batch_size, sequence_length, config.model_in_channels)
,或者非批处理的,形状为(sequence_length, config.model_in_channels)
。如果未提供,则将随机生成。 -
padding_mask
(torch.BoolTensor
, 可选) — 指示每个序列的哪些部分被填充的掩码。掩码值在[0, 1]
中选择:-
1 用于未被“masked”的标记
-
对于被
masked
的标记
掩码可以是批处理的,形状为
(batch_size, sequence_length)
,也可以是非批处理的,形状为(sequence_length,)
。 -
-
generator
(torch.Generator
,可选)— 一个用于使生成过程确定性的torch 生成器。return_dict — 是否返回一个 ModelOutput 子类而不是一个普通元组。
返回
transformers.models.univnet.modeling_univnet.UnivNetModelOutput
或tuple(torch.FloatTensor)
一个transformers.models.univnet.modeling_univnet.UnivNetModelOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(UnivNetConfig)和输入的不同元素。
-
waveforms
(形状为(batch_size, sequence_length)
的torch.FloatTensor
)— 批量的 1D(单声道)输出音频波形。 -
waveform_lengths
(形状为(batch_size,)
的torch.FloatTensor
)—waveforms
中每个未填充波形的批量长度(以样本为单位)。
UnivNetModel
的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
将噪声波形和一个条件谱图转换为语音波形。传递一批 log-mel 谱图返回一批语音波形。传递一个单独的、未批处理的 log-mel 谱图返回一个单独的、未批处理的语音波形。
示例:
>>> from transformers import UnivNetFeatureExtractor, UnivNetModel
>>> from datasets import load_dataset, Audio
>>> model = UnivNetModel.from_pretrained("dg845/univnet-dev")
>>> feature_extractor = UnivNetFeatureExtractor.from_pretrained("dg845/univnet-dev")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> # Resample the audio to the feature extractor's sampling rate.
>>> ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
>>> inputs = feature_extractor(
... ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> audio = model(**inputs).waveforms
>>> list(audio.shape)
[1, 140288]
VITS
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/vits
概述
VITS 模型是由 Jaehyeon Kim,Jungil Kong,Juhee Son 在端到端文本到语音的条件变分自动编码器与对抗学习中提出的。
VITS(端到端文本到语音的变分推断与对抗学习)是一种端到端语音合成模型,根据输入文本序列预测语音波形。它是由后验编码器、解码器和条件先验组成的条件变分自动编码器(VAE)。
基于流的模块预测了一组基于频谱图的声学特征,该模块由基于 Transformer 的文本编码器和多个耦合层组成。使用一堆转置卷积层对频谱图进行解码,这与 HiFi-GAN 声码器的风格非常相似。受 TTS 问题的一对多性质的启发,其中相同的文本输入可以以多种方式发音,该模型还包括一个随机持续时间预测器,允许模型从相同的输入文本中合成具有不同节奏的语音。
该模型通过从变分下界和对抗训练导出的损失的组合进行端到端训练。为了提高模型的表现力,将归一化流应用于条件先验分布。在推断过程中,基于持续时间预测模块对文本编码进行上采样,然后使用一系列流模块和 HiFi-GAN 解码器将其映射到波形中。由于持续时间预测器的随机性质,该模型是非确定性的,因此需要一个固定的种子来生成相同的语音波形。
论文的摘要如下:
最近提出了几种端到端文本到语音(TTS)模型,实现了单阶段训练和并行采样,但它们的样本质量不及两阶段 TTS 系统。在这项工作中,我们提出了一种并行端到端 TTS 方法,其生成的音频听起来比当前的两阶段模型更自然。我们的方法采用了变分推断,增加了归一化流和对抗训练过程,提高了生成建模的表现力。我们还提出了一个随机持续时间预测器,用于从输入文本中合成具有不同节奏的语音。通过对潜在变量进行不确定性建模和随机持续时间预测器,我们的方法表达了自然的一对多关系,即文本输入可以以不同的音高和节奏发音。对 LJ Speech(单个说话者数据集)的主观人类评估(平均意见分数,或 MOS)显示,我们的方法优于最佳公开可用的 TTS 系统,并实现了与地面真相相当的 MOS。
这个模型也可以与大规模多语言语音(MMS)的 TTS 检查点一起使用,因为这些检查点使用相同的架构和稍作修改的分词器。
这个模型是由Matthijs和sanchit-gandhi贡献的。原始代码可以在这里找到。
用法示例
VITS 和 MMS-TTS 检查点都可以使用相同的 API。由于基于流的模型是非确定性的,最好设置一个种子以确保输出的可重现性。对于使用罗马字母表的语言,如英语或法语,可以直接使用分词器对文本输入进行预处理。以下代码示例运行了一个前向传递,使用了 MMS-TTS 英语检查点:
import torch
from transformers import VitsTokenizer, VitsModel, set_seed
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng")
inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")
set_seed(555) # make deterministic
with torch.no_grad():
outputs = model(**inputs)
waveform = outputs.waveform[0]
生成的波形可以保存为.wav
文件:
import scipy
scipy.io.wavfile.write("techno.wav", rate=model.config.sampling_rate, data=waveform)
或在 Jupyter Notebook / Google Colab 中显示:
from IPython.display import Audio
Audio(waveform, rate=model.config.sampling_rate)
对于某些具有非罗马字母表的语言,如阿拉伯语、普通话或印地语,需要使用uroman
perl 包对文本输入进行预处理,转换为罗马字母表。
您可以通过检查预训练的tokenizer
的is_uroman
属性来确定您的语言是否需要uroman
包。
from transformers import VitsTokenizer
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
print(tokenizer.is_uroman)
如果需要,应在将文本输入传递给VitsTokenizer
之前先对其应用 uroman 包,因为目前分词器不支持执行预处理。
要执行此操作,首先将 uroman 存储库克隆到本地计算机,并将 bash 变量UROMAN
设置为本地路径:
git clone https://github.com/isi-nlp/uroman.git
cd uroman
export UROMAN=$(pwd)
然后,您可以使用以下代码片段对文本输入进行预处理。您可以依赖使用 bash 变量UROMAN
指向 uroman 存储库,或者将 uroman 目录作为参数传递给uromaize
函数:
import torch
from transformers import VitsTokenizer, VitsModel, set_seed
import os
import subprocess
tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-kor")
model = VitsModel.from_pretrained("facebook/mms-tts-kor")
def uromanize(input_string, uroman_path):
"""Convert non-Roman strings to Roman using the `uroman` perl package."""
script_path = os.path.join(uroman_path, "bin", "uroman.pl")
command = ["perl", script_path]
process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
# Execute the perl command
stdout, stderr = process.communicate(input=input_string.encode())
if process.returncode != 0:
raise ValueError(f"Error {process.returncode}: {stderr.decode()}")
# Return the output as a string and skip the new-line character at the end
return stdout.decode()[:-1]
text = "이봐 무슨 일이야"
uromaized_text = uromanize(text, uroman_path=os.environ["UROMAN"])
inputs = tokenizer(text=uromaized_text, return_tensors="pt")
set_seed(555) # make deterministic
with torch.no_grad():
outputs = model(inputs["input_ids"])
waveform = outputs.waveform[0]
VitsConfig
class transformers.VitsConfig
( vocab_size = 38 hidden_size = 192 num_hidden_layers = 6 num_attention_heads = 2 window_size = 4 use_bias = True ffn_dim = 768 layerdrop = 0.1 ffn_kernel_size = 3 flow_size = 192 spectrogram_bins = 513 hidden_act = 'relu' hidden_dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 use_stochastic_duration_prediction = True num_speakers = 1 speaker_embedding_size = 0 upsample_initial_channel = 512 upsample_rates = [8, 8, 2, 2] upsample_kernel_sizes = [16, 16, 4, 4] resblock_kernel_sizes = [3, 7, 11] resblock_dilation_sizes = [[1, 3, 5], [1, 3, 5], [1, 3, 5]] leaky_relu_slope = 0.1 depth_separable_channels = 2 depth_separable_num_layers = 3 duration_predictor_flow_bins = 10 duration_predictor_tail_bound = 5.0 duration_predictor_kernel_size = 3 duration_predictor_dropout = 0.5 duration_predictor_num_flows = 4 duration_predictor_filter_channels = 256 prior_encoder_num_flows = 4 prior_encoder_num_wavenet_layers = 4 posterior_encoder_num_wavenet_layers = 16 wavenet_kernel_size = 5 wavenet_dilation_rate = 1 wavenet_dropout = 0.0 speaking_rate = 1.0 noise_scale = 0.667 noise_scale_duration = 0.8 sampling_rate = 16000 **kwargs )
参数
-
vocab_size
(int
, optional, defaults to 38) — VITS 模型的词汇量。定义了可以由传递给 VitsModel 的inputs_ids
表示的不同令牌数量。 -
hidden_size
(int
, optional, defaults to 192) — 文本编码器层的维度。 -
num_hidden_layers
(int
, optional, defaults to 6) — Transformer 编码器中的隐藏层数量。 -
num_attention_heads
(int
, optional, defaults to 2) — Transformer 编码器中每个注意力层的注意力头数。 -
window_size
(int
, optional, defaults to 4) — Transformer 编码器中注意力层的相对位置嵌入的窗口大小。 -
use_bias
(bool
, optional, defaults toTrue
) — 是否在 Transformer 编码器中的键、查询、值投影层中使用偏置。 -
ffn_dim
(int
, optional, defaults to 768) — Transformer 编码器中“中间”(即前馈)层的维度。 -
layerdrop
(float
, optional, defaults to 0.1) — 编码器的 LayerDrop 概率。有关更多详细信息,请参阅 LayerDrop paper)。 -
ffn_kernel_size
(int
, optional, defaults to 3) — Transformer 编码器中前馈网络使用的 1D 卷积层的核大小。 -
flow_size
(int
, optional, defaults to 192) — 流层的维度。 -
spectrogram_bins
(int
, optional, defaults to 513) — 目标频谱图中的频率箱数。 -
hidden_act
(str
orfunction
, optional, defaults to"relu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 -
hidden_dropout
(float
, optional, defaults to 0.1) — 嵌入层和编码器中所有全连接层的 dropout 概率。 -
attention_dropout
(float
, optional, defaults to 0.1) — 注意力概率的 dropout 比率。 -
activation_dropout
(float
, optional, defaults to 0.1) — 全连接层内激活的 dropout 比率。 -
initializer_range
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
layer_norm_eps
(float
, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。 -
use_stochastic_duration_prediction
(bool
, optional, defaults toTrue
) — 是否使用随机持续时间预测模块或常规持续时间预测器。 -
num_speakers
(int
, optional, defaults to 1) — 如果这是多说话者模型,则说话者数量。 -
speaker_embedding_size
(int
, optional, 默认为 0) — 说话者嵌入使用的通道数量。对于单说话者模型,该值为零。 -
upsample_initial_channel
(int
, optional, 默认为 512) — HiFi-GAN 上采样网络的输入通道数。 -
upsample_rates
(Tuple[int]
或List[int]
, optional, 默认为[8, 8, 2, 2]
) — 一个整数元组,定义 HiFi-GAN 上采样网络中每个 1D 卷积层的步幅。upsample_rates
的长度定义了卷积层的数量,并且必须与upsample_kernel_sizes
的长度匹配。 -
upsample_kernel_sizes
(Tuple[int]
或List[int]
, optional, 默认为[16, 16, 4, 4]
) — 一个整数元组,定义 HiFi-GAN 上采样网络中每个 1D 卷积层的核大小。upsample_kernel_sizes
的长度定义了卷积层的数量,并且必须与upsample_rates
的长度匹配。 -
resblock_kernel_sizes
(Tuple[int]
或List[int]
, optional, 默认为[3, 7, 11]
) — 一个整数元组,定义 HiFi-GAN 多接受域融合(MRF)模块中 1D 卷积层的核大小。 -
resblock_dilation_sizes
(Tuple[Tuple[int]]
或List[List[int]]
, optional, 默认为[[1, 3, 5], [1, 3, 5], [1, 3, 5]]
) — 一个嵌套的整数元组,定义 HiFi-GAN 多接受域融合(MRF)模块中扩张 1D 卷积层的扩张率。 -
leaky_relu_slope
(float
, optional, 默认为 0.1) — leaky ReLU 激活中使用的负斜率的角度。 -
depth_separable_channels
(int
, optional, 默认为 2) — 每个深度可分离块中要使用的通道数。 -
depth_separable_num_layers
(int
, optional, 默认为 3) — 每个深度可分离块中要使用的卷积层数量。 -
duration_predictor_flow_bins
(int
, optional, 默认为 10) — 在持续时间预测模型中使用无约束有理样条映射的通道数量。 -
duration_predictor_tail_bound
(float
, optional, 默认为 5.0) — 计算持续时间预测模型中无约束有理样条时的尾部区间边界值。 -
duration_predictor_kernel_size
(int
, optional, 默认为 3) — 用于持续时间预测模型中的 1D 卷积层的核大小。 -
duration_predictor_dropout
(float
, optional, 默认为 0.5) — 持续时间预测模型的丢失比率。 -
duration_predictor_num_flows
(int
, optional, 默认为 4) — 持续时间预测模型使用的流阶段数量。 -
duration_predictor_filter_channels
(int
, optional, 默认为 256) — 持续时间预测模型中使用的卷积层的通道数。 -
prior_encoder_num_flows
(int
, optional, 默认为 4) — 先验编码器流模型使用的流阶段数量。 -
prior_encoder_num_wavenet_layers
(int
, optional, 默认为 4) — 先验编码器流模型使用的 WaveNet 层数量。 -
posterior_encoder_num_wavenet_layers
(int
, optional, 默认为 16) — 后验编码器模型使用的 WaveNet 层数量。 -
wavenet_kernel_size
(int
, optional, 默认为 5) — WaveNet 模型中使用的 1D 卷积层的核大小。 -
wavenet_dilation_rate
(int
, optional, 默认为 1) — WaveNet 模型中使用的扩张 1D 卷积层的扩张率。 -
wavenet_dropout
(float
, optional, 默认为 0.0) — WaveNet 层的丢失比率。 -
speaking_rate
(float
, optional, 默认为 1.0) — 说话速率。较大的值会导致合成语音速度更快。 -
noise_scale
(float
, optional, 默认为 0.667) — 语音预测的随机程度。较大的值会导致预测语音的变化更大。 -
noise_scale_duration
(float
, optional, 默认为 0.8) — 持续时间预测的随机程度。较大的值会导致预测持续时间的变化更大。 -
sampling_rate
(int
, optional, 默认为 16000) — 输出音频波形的数字化采样率,以赫兹(Hz)表示。
这是用于存储 VitsModel 配置的配置类。它用于根据指定的参数实例化 VITS 模型,定义模型架构。使用默认值实例化配置将产生类似于VITS架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import VitsModel, VitsConfig
>>> # Initializing a "facebook/mms-tts-eng" style configuration
>>> configuration = VitsConfig()
>>> # Initializing a model (with random weights) from the "facebook/mms-tts-eng" style configuration
>>> model = VitsModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
VitsTokenizer
class transformers.VitsTokenizer
( vocab_file pad_token = '<pad>' unk_token = '<unk>' language = None add_blank = True normalize = True phonemize = True is_uroman = False **kwargs )
参数
-
vocab_file
(str
) — 词汇表文件的路径。 -
language
(str
, optional) — 语言标识符。 -
add_blank
(bool
, optional, 默认为True
) — 是否在其他标记之间插入标记 id 0。 -
normalize
(bool
, optional, 默认为True
) — 是否通过删除所有大小写和标点来规范化输入文本。 -
phonemize
(bool
, optional, 默认为True
) — 是否将输入文本转换为音素。 -
is_uroman
(bool
, optional, 默认为False
) — 是否在分词之前需要将uroman
罗马化器应用于输入文本。
构建一个 VITS 分词器。还支持 MMS-TTS。
此分词器继承自 PreTrainedTokenizer,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
__call__
( 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 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 ) → export const metadata = 'undefined';BatchEncoding
参数
-
text
(str
,List[str]
,List[List[str]]
, optional) — 要编码的序列或批量序列。每个序列可以是字符串或字符串列表(预分词字符串)。如果提供的序列是字符串列表(预分词),必须设置is_split_into_words=True
(以消除与批量序列的歧义)。 -
text_pair
(str
,List[str]
,List[List[str]]
, optional) — 要编码的序列或批量序列。每个序列可以是字符串或字符串列表(预分词字符串)。如果提供的序列是字符串列表(预分词),必须设置is_split_into_words=True
(以消除与批量序列的歧义)。 -
text_target
(str
,List[str]
,List[List[str]]
, optional) — 要编码为目标文本的序列或批量序列。每个序列可以是字符串或字符串列表(预分词字符串)。如果提供的序列是字符串列表(预分词),必须设置is_split_into_words=True
(以消除与批量序列的歧义)。 -
text_pair_target
(str
,List[str]
,List[List[str]]
, optional) — 要编码为目标文本的序列或批量序列。每个序列可以是字符串或字符串列表(预分词字符串)。如果提供的序列是字符串列表(预分词),必须设置is_split_into_words=True
(以消除与批量序列的歧义)。 -
add_special_tokens
(bool
, optional, 默认为True
) — 在编码序列时是否添加特殊标记。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens
函数,该函数定义了自动添加到输入 id 的标记。如果要自动添加bos
或eos
标记,则这很有用。 -
padding
(bool
,str
或 PaddingStrategy,可选,默认为False
)— 激活和控制填充。接受以下值:-
True
或'longest'
: 填充到批次中最长的序列(如果只提供单个序列,则不进行填充)。 -
'max_length'
: 填充到指定的最大长度,该长度由参数max_length
指定,或者如果未提供该参数,则填充到模型可接受的最大输入长度。 -
False
或'do_not_pad'
(默认):不进行填充(即,可以输出具有不同长度序列的批次)。
-
-
truncation
(bool
,str
或 TruncationStrategy,可选,默认为False
)— 激活和控制截断。接受以下值:-
True
或'longest_first'
: 仅截断到指定的最大长度,该长度由参数max_length
指定,或者如果未提供该参数,则截断到模型可接受的最大输入长度。如果提供了一对序列(或一批序列),则将逐个标记截断,从一对序列中最长的序列中删除一个标记。 -
'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
时返回的溢出标记将包含截断序列末尾的一些标记,以提供截断和溢出序列之间的一些重叠。此参数的值定义重叠标记的数量。 -
is_split_into_words
(bool
,可选,默认为False
)— 输入是否已经预分词(例如,已分割为单词)。如果设置为True
,则分词器会假定输入已经分割为单词(例如,通过在空格上分割),然后对其进行分词。这对于 NER 或标记分类很有用。 -
pad_to_multiple_of
(int
,可选)— 如果设置,将序列填充到提供的值的倍数。需要激活padding
。这对于启用具有计算能力>= 7.5
(Volta)的 NVIDIA 硬件上的 Tensor Cores 特别有用。 -
return_tensors
(str
或 TensorType,可选)— 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:-
'tf'
: 返回 TensorFlowtf.constant
对象。 -
'pt'
: 返回 PyTorchtorch.Tensor
对象。 -
'np'
: 返回 Numpynp.ndarray
对象。
-
-
return_token_type_ids
(bool
,可选)— 是否返回标记类型 ID。如果保持默认设置,将根据特定分词器的默认设置返回标记类型 ID,由return_outputs
属性定义。什么是标记类型 ID?
-
return_attention_mask
(bool
, 可选) — 是否返回注意力掩码。如果保持默认设置,将根据特定标记化器的默认值返回注意力掩码,由return_outputs
属性定义。什么是注意力掩码?
-
return_overflowing_tokens
(bool
, 可选, 默认为False
) — 是否返回溢出的标记序列。如果提供了一对输入 ID 序列(或一批对)并且truncation_strategy = longest_first
或True
,则会引发错误,而不是返回溢出的标记。 -
return_special_tokens_mask
(bool
, 可选, 默认为False
) — 是否返回特殊标记掩码信息。 -
return_offsets_mapping
(bool
, 可选, 默认为False
) — 是否返回每个标记的(char_start, char_end)
。这仅适用于继承自 PreTrainedTokenizerFast 的快速标记化器,如果使用 Python 的标记化器,此方法将引发
NotImplementedError
。 -
return_length
(bool
, 可选, 默认为False
) — 是否返回编码输入的长度。 -
verbose
(bool
, 可选, 默认为True
) — 是否打印更多信息和警告。**kwargs — 传递给self.tokenize()
方法
返回
BatchEncoding
一个包含以下字段的 BatchEncoding:
-
input_ids
— 要提供给模型的标记 ID 列表。什么是输入 IDs?
-
token_type_ids
— 要提供给模型的标记类型 ID 列表(当return_token_type_ids=True
或token_type_ids
在self.model_input_names
中时)。什么是 token type IDs?
-
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
时)
标记化和准备模型一个或多个序列或一个或多个序列对的主要方法。
save_vocabulary
( save_directory: str filename_prefix: Optional = None )
VitsModel
class transformers.VitsModel
( config: VitsConfig )
参数
config
(VitsConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
用于文本到语音合成的完整 VITS 模型。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型也是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: Optional = None attention_mask: Optional = None speaker_id: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.models.vits.modeling_vits.VitsModelOutput or tuple(torch.FloatTensor)
参数
-
input_ids
(torch.LongTensor
,形状为(batch_size, sequence_length)
) — 输入序列标记在词汇表中的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.
call
()。什么是输入 ID?
-
attention_mask
(torch.Tensor
,形状为(batch_size, sequence_length)
,可选的) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]
之间:-
1 表示
未被掩码
的标记, -
0 表示
被掩码
的标记。
什么是注意力掩码?
-
-
speaker_id
(int
, 可选的) — 要使用的说话者嵌入。仅用于多说话者模型。 -
output_attentions
(bool
, 可选的) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
。 -
output_hidden_states
(bool
, 可选的) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。 -
return_dict
(bool
, 可选的) — 是否返回一个 ModelOutput 而不是一个普通的元组。 -
labels
(torch.FloatTensor
,形状为(batch_size, config.spectrogram_bins, sequence_length)
,可选的) — 目标频谱图的浮点值。时间步设置为-100.0
将被忽略(掩码)用于损失计算。
返回
transformers.models.vits.modeling_vits.VitsModelOutput
或tuple(torch.FloatTensor)
一个transformers.models.vits.modeling_vits.VitsModelOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或者当config.return_dict=False
时)包含根据配置(VitsConfig)和输入的各种元素。
-
waveform
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 模型预测的最终音频波形。 -
sequence_lengths
(torch.FloatTensor
,形状为(batch_size,)
) —waveform
批次中每个元素的样本长度。 -
spectrogram
(torch.FloatTensor
,形状为(batch_size, sequence_length, num_bins)
) — 在流模型输出处预测的对数梅尔频谱图。此频谱图传递给 Hi-Fi GAN 解码器模型以获得最终的音频波形。 -
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 之后,用于计算自注意力头中的加权平均值。
VitsModel 的前向方法覆盖了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则会默默地忽略它们。
示例:
>>> from transformers import VitsTokenizer, VitsModel, set_seed
>>> import torch
>>> tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
>>> model = VitsModel.from_pretrained("facebook/mms-tts-eng")
>>> inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")
>>> set_seed(555) # make deterministic
>>> with torch.no_grad():
... outputs = model(inputs["input_ids"])
>>> outputs.waveform.shape
torch.Size([1, 45824])
Wav2Vec2
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/wav2vec2
概述
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 倍。仅使用十分钟的标记数据并在 53k 小时的未标记数据上进行预训练仍然实现了 4.8/8.2 的 WER。这证明了在有限的标记数据量下进行语音识别的可行性。
此模型由patrickvonplaten贡献。
使用提示
-
Wav2Vec2 是一个接受与语音信号的原始波形对应的浮点数组的语音模型。
-
Wav2Vec2 模型是使用连接主义时间分类(CTC)进行训练的,因此模型输出必须使用 Wav2Vec2CTCTokenizer 进行解码。
资源
一份官方 Hugging Face 和社区(由🌎表示)资源列表,可帮助您开始使用 Wav2Vec2。如果您有兴趣提交资源以包含在此处,请随时打开 Pull Request,我们将进行审查!资源应该理想地展示一些新内容,而不是重复现有资源。
音频分类
-
一个关于如何利用预训练的 Wav2Vec2 模型进行情感分类的笔记本。🌎
-
音频分类任务指南
自动语音识别
-
一个关于如何通过使用 Wav2Vec2 转录音频从任何视频创建 YouTube 字幕的笔记本。🌎
-
Wav2Vec2ForCTC 受到一篇关于如何在英语中微调语音识别模型的笔记本和如何在任何语言中微调语音识别模型的笔记本的支持。
-
自动语音识别任务指南
🚀 部署
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
, optional, defaults to 32) — Wav2Vec2 模型的词汇表大小。定义了在调用 Wav2Vec2Model 或 TFWav2Vec2Model 时可以表示的不同标记数量。模型的词汇表大小。定义了在调用 Wav2Vec2Model 的 forward 方法时可以表示的不同标记数量。 -
hidden_size
(int
, optional, defaults to 768) — 编码器层和池化器层的维度。 -
num_hidden_layers
(int
, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。 -
num_attention_heads
(int
, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。 -
intermediate_size
(int
, optional, defaults to 3072) — Transformer 编码器中“中间”(即前馈)层的维度。 -
hidden_act
(str
orfunction
, optional, defaults to"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 -
hidden_dropout
(float
, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有完全连接层的 dropout 概率。 -
activation_dropout
(float
, optional, defaults to 0.1) — 完全连接层内激活的 dropout 比率。 -
attention_dropout
(float
, optional, defaults to 0.1) — 注意力概率的 dropout 比率。 -
final_dropout
(float
, optional, defaults to 0.1) — Wav2Vec2ForCTC 最终投影层的 dropout 概率。 -
layerdrop
(float
, optional, defaults to 0.1) — LayerDrop 概率。有关更多详细信息,请参阅 LayerDrop 论文)。 -
initializer_range
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
layer_norm_eps
(float
, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。 -
feat_extract_norm
(str
, optional, defaults to"group"
) — 应用于特征编码器中 1D 卷积层的规范化。"group"
表示仅对第一个 1D 卷积层进行组归一化,"layer"
表示对所有 1D 卷积层进行层归一化。 -
feat_proj_dropout
(float
, optional, defaults to 0.0) — 特征编码器输出的 dropout 概率。 -
feat_extract_activation
(str,
optional, defaults to
“gelu”) -- 特征提取器中 1D 卷积层的非线性激活函数(函数或字符串)。如果是字符串,支持
“gelu”、
“relu”、
“selu”和
“gelu_new”`。 -
feat_quantizer_dropout
(float
, optional, defaults to 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 为 True
表示在注意力层之前应用层归一化,而do_stable_layer_norm 为 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_problen(time_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选择为掩盖的向量跨度起始的概率推理, mask_time_prob *应为prob_vector_start*mask_time_length
。请注意,重叠可能会降低实际掩盖向量的百分比。仅在apply_spec_augment 为 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_problen(feature_axis)/mask_time_length”个独立的掩码。如果从每个特征向量被选择为掩盖的向量跨度起始的概率推理, mask_feature_prob *应为prob_vector_start*mask_feature_length
。请注意,重叠可能会降低实际掩盖向量的百分比。仅在apply_spec_augment 为 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
, 可选, 默认为 0.1) — 对比损失中的温度 kappa。 -
feat_quantizer_dropout
(float
, 可选, 默认为 0.0) — 用于量化器使用的特征编码器输出的丢弃概率。 -
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
(int
, 可选, 默认为 256) — 用于分类的令牌均值池化之前的投影维度。 -
tdnn_dim
(Tuple[int]
或List[int]
, 可选, 默认为(512, 512, 512, 512, 1500)
) — 一个整数元组,定义了 XVector 模型中 TDNN 模块中每个一维卷积层的输出通道数。tdnn_dim 的长度定义了 TDNN 层的数量。 -
tdnn_kernel
(Tuple[int]
或List[int]
, 可选, 默认为(5, 3, 3, 1, 1)
) — 一个整数元组,定义了 XVector 模型中 TDNN 模块中每个一维卷积层的内核大小。tdnn_kernel 的长度必须与 tdnn_dim 的长度相匹配。 -
tdnn_dilation
(Tuple[int]
或List[int]
, 可选, 默认为(1, 2, 3, 1, 1)
) — 一个整数元组,定义了 XVector 模型中 TDNN 模块中每个一维卷积层的膨胀因子。tdnn_dilation 的长度必须与 tdnn_dim 的长度相匹配。 -
xvector_output_dim
(int
, 可选, 默认为 512) — XVector 嵌入向量的维度。 -
add_adapter
(bool
, 可选, 默认为False
) — 是否在 Wav2Vec2 编码器顶部堆叠卷积网络。对于 Warm-starting Wav2Vec2 for SpeechEncoderDecoder 模型非常有用。 -
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
( 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: 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 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 ) → export const metadata = 'undefined';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]]
, optional) — 要编码为目标文本的序列或批量序列。每个序列可以是一个字符串或一个字符串列表(预先标记化的字符串)。如果序列以字符串列表(预先标记化)的形式提供,则必须设置is_split_into_words=True
(以消除批量序列的歧义)。 -
add_special_tokens
(bool
, optional, 默认为True
) — 在编码序列时是否添加特殊标记。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens
函数,该函数定义了自动添加到输入 id 的标记。如果要自动添加bos
或eos
标记,则这很有用。 -
padding
(bool
,str
或 PaddingStrategy, optional, 默认为False
) — 激活和控制填充。接受以下值:-
True
或'longest'
:填充到批量中最长的序列(如果只提供单个序列,则不填充)。 -
'max_length'
:填充到由参数max_length
指定的最大长度,或者填充到模型的最大可接受输入长度(如果未提供该参数)。 -
False
或'do_not_pad'
(默认):不填充(即,可以输出长度不同的序列批次)。
-
-
truncation
(bool
,str
或 TruncationStrategy, optional, 默认为False
) — 激活和控制截断。接受以下值:-
True
或'longest_first'
:截断到由参数max_length
指定的最大长度,或者截断到模型的最大可接受输入长度(如果未提供该参数)。如果提供了一对序列(或一批对),则将逐标记截断,从一对序列中最长的序列中删除一个标记。 -
'only_first'
:截断到由参数max_length
指定的最大长度,或者截断到模型的最大可接受输入长度(如果未提供该参数)。如果提供了一对序列(或一批对),则只会截断第一个序列。 -
'only_second'
:截断到由参数max_length
指定的最大长度,或者截断到模型的最大可接受输入长度(如果未提供该参数)。如果提供了一对序列(或一批对),则只会截断第二个序列。 -
False
或'do_not_truncate'
(默认):不截断(即,可以输出长度大于模型最大可接受输入大小的序列批次)。
-
-
max_length
(int
, optional) — 控制截断/填充参数之一使用的最大长度。如果未设置或设置为
None
,则将使用预定义的模型最大长度(如果截断/填充参数之一需要最大长度)。如果模型没有特定的最大输入长度(如 XLNet),则将禁用截断/填充到最大长度。 -
stride
(int
, optional, 默认为 0) — 如果与max_length
一起设置为一个数字,则当return_overflowing_tokens=True
时返回的溢出标记将包含从截断序列末尾返回的一些标记,以提供截断和溢出序列之间的一些重叠。该参数的值定义了重叠标记的数量。 -
is_split_into_words
(bool
, optional, 默认为False
) — 输入是否已经预标记化(例如,已分割为单词)。如果设置为True
,则分词器会假定输入已经分割为单词(例如,通过在空格上分割),然后对其进行标记化。这对于命名实体识别或标记分类很有用。 -
pad_to_multiple_of
(int
, 可选) — 如果设置,将序列填充到提供的值的倍数。需要激活padding
。这对于在具有计算能力>= 7.5
(Volta)的 NVIDIA 硬件上启用 Tensor Cores 特别有用。 -
return_tensors
(str
或 TensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:-
'tf'
: 返回 TensorFlowtf.constant
对象。 -
'pt'
: 返回 PyTorchtorch.Tensor
对象。 -
'np'
: 返回 Numpynp.ndarray
对象。
-
-
return_token_type_ids
(bool
, 可选) — 是否返回 token type IDs。如果保持默认设置,将根据特定标记化器的默认值返回 token type IDs,由return_outputs
属性定义。什么是 token type IDs?
-
return_attention_mask
(bool
, 可选) — 是否返回注意力掩码。如果保持默认设置,将根据特定标记化器的默认值返回注意力掩码,由return_outputs
属性定义。什么是 attention masks?
-
return_overflowing_tokens
(bool
, 可选, 默认为False
) — 是否返回溢出的 token 序列。如果提供了一对输入 id 序列(或一批对)并且truncation_strategy = longest_first
或True
,则会引发错误,而不是返回溢出的 tokens。 -
return_special_tokens_mask
(bool
, 可选, 默认为False
) — 是否返回特殊 token 掩码信息。 -
return_offsets_mapping
(bool
, 可选, 默认为False
) — 是否返回每个 token 的(char_start, char_end)
。这仅适用于继承自 PreTrainedTokenizerFast 的快速标记化器,如果使用 Python 的标记化器,此方法将引发
NotImplementedError
。 -
return_length
(bool
, 可选, 默认为False
) — 是否返回编码输入的长度。 -
verbose
(bool
, 可选, 默认为True
) — 是否打印更多信息和警告。**kwargs — 传递给self.tokenize()
方法
返回
BatchEncoding
一个具有以下字段的 BatchEncoding:
-
input_ids
— 要提供给模型的 token id 列表。什么是 input IDs?
-
token_type_ids
— 要提供给模型的 token type ids 列表(当return_token_type_ids=True
或token_type_ids
在self.model_input_names
中时)。什么是 token type IDs?
-
attention_mask
— 指定哪些 token 应该被模型关注的索引列表(当return_attention_mask=True
或attention_mask
在self.model_input_names
中时)。什么是 attention masks?
-
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
时)
将主要方法标记化并为模型准备一个或多个序列或一个或多个序列对。
save_vocabulary
( save_directory: str filename_prefix: Optional = None )
decode
( 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 ) → export const metadata = 'undefined';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 转换为字符串,使用分词器和词汇表,可以选择删除特殊标记并清理分词空格。
类似于执行self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))
。
示例:
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)
>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = feature_extractor(sample["audio"]["array"], return_tensors="pt").input_values
>>> logits = model(input_values).logits[0]
>>> pred_ids = torch.argmax(logits, axis=-1)
>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = tokenizer.decode(pred_ids, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / feature_extractor.sampling_rate
>>> word_offsets = [
... {
... "word": d["word"],
... "start_time": round(d["start_offset"] * time_offset, 2),
... "end_time": round(d["end_offset"] * time_offset, 2),
... }
... for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:3]
[{'word': 'THE', 'start_time': 0.7, 'end_time': 0.78}, {'word': 'TRICK', 'start_time': 0.88, 'end_time': 1.08}, {'word': 'APPEARS', 'start_time': 1.2, 'end_time': 1.64}]
batch_decode
( sequences: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None output_char_offsets: bool = False output_word_offsets: bool = False **kwargs ) → export const metadata = 'undefined';List[str] or Wav2Vec2CTCTokenizerOutput
参数
-
sequences
(Union[List[int], List[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
) — 是否输出字符偏移量。字符偏移量可以与采样率和模型下采样率结合使用,计算转录字符的时间戳。请查看 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
。
通过调用解码函数,将一系列 token id 的列表转换为字符串列表。
set_target_lang
( target_lang: str )
设置嵌套多语言字典的目标语言
Wav2Vec2FeatureExtractor
class transformers.Wav2Vec2FeatureExtractor
( feature_size = 1 sampling_rate = 16000 padding_value = 0.0 return_attention_mask = False do_normalize = True **kwargs )
参数
-
feature_size
(int
,默认为 1)— 提取特征的特征维度。 -
sampling_rate
(int
,默认为 16000)— 应以赫兹(Hz)表示的音频文件数字化的采样率。 -
padding_value
(float
,默认为 0.0)— 用于填充值的值。 -
do_normalize
(bool
,可选,默认为True
)— 是否对输入进行零均值单位方差归一化。归一化可以帮助一些模型显著提高性能,例如 wav2vec2-lv60。 -
return_attention_mask
(bool
,可选,默认为False
)— 是否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__
( 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
,可选)— 如果设置,将填充序列到提供的值的倍数。这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用,其计算能力
>= 7.5
(Volta),或者对于受益于序列长度为 128 的倍数的 TPU。 -
return_attention_mask
(bool
,可选)— 是否返回注意力掩码。如果保持默认值,将根据特定 feature_extractor 的默认值返回注意力掩码。什么是注意力掩码?
对于设置了
config.feat_extract_norm == "group"
的 Wav2Vec2 模型,例如 wav2vec2-base,没有使用attention_mask
进行训练。对于这样的模型,input_values
应该简单地用 0 填充,不应传递attention_mask
。对于设置了
config.feat_extract_norm == "layer"
的 Wav2Vec2 模型,例如 wav2vec2-lv60,应该为批量推断传递attention_mask
。 -
return_tensors
(str
或 TensorType, 可选) — 如果设置,将返回张量而不是 Python 整数列表。可接受的值为:-
'tf'
: 返回 TensorFlowtf.constant
对象。 -
'pt'
: 返回 PyTorchtorch.Tensor
对象。 -
'np'
: 返回 Numpynp.ndarray
对象。
-
-
sampling_rate
(int
, 可选) —raw_speech
输入采样的采样率。强烈建议在前向调用时传递sampling_rate
以防止静默错误。 -
padding_value
(float
, 默认为 0.0) —
对一个或多个序列进行特征化和为模型准备的主要方法。
Wav2Vec2Processor
class transformers.Wav2Vec2Processor
( feature_extractor tokenizer )
参数
-
feature_extractor
(Wav2Vec2FeatureExtractor
) — Wav2Vec2FeatureExtractor 的一个实例。特征提取器是必需的输入。 -
tokenizer
(PreTrainedTokenizer) — PreTrainedTokenizer 的一个实例。分词器是必需的输入。
构建一个 Wav2Vec2 处理器,将 Wav2Vec2 特征提取器和 Wav2Vec2 CTC 分词器封装成一个单一处理器。
Wav2Vec2Processor 提供了 Wav2Vec2FeatureExtractor 和 PreTrainedTokenizer 的所有功能。查看 call() 和 decode() 的文档字符串以获取更多信息。
__call__
( *args **kwargs )
在正常模式下使用时,此方法将所有参数转发到 Wav2Vec2FeatureExtractor 的 call() 并返回其输出。如果在上下文 as_target_processor()
中使用此方法,将所有参数转发到 PreTrainedTokenizer 的 call()。请参考上述两个方法的文档字符串以获取更多信息。
pad
( *args **kwargs )
在正常模式下使用时,此方法将所有参数转发到 Wav2Vec2FeatureExtractor 的 pad()并返回其输出。如果在上下文as_target_processor()
中使用,此方法将所有参数转发到 PreTrainedTokenizer 的 pad()。有关更多信息,请参考上述两种方法的文档字符串。
from_pretrained
( pretrained_model_name_or_path **kwargs )
save_pretrained
( save_directory push_to_hub: bool = False **kwargs )
参数
-
save_directory
(str
或os.PathLike
)— 特征提取器 JSON 文件和分词器文件将保存在的目录(如果目录不存在,则将创建目录)。 -
push_to_hub
(bool
,可选,默认为False
)— 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用repo_id
指定要推送到的存储库(将默认为您的命名空间中的save_directory
名称)。 -
kwargs
(Dict[str, Any]
,可选)— 传递给 push_to_hub()方法的额外关键字参数。
将此处理器的属性(特征提取器、分词器等)保存在指定目录中,以便可以使用 from_pretrained()方法重新加载。
这个类方法只是调用 save_pretrained()和 save_pretrained()。有关更多信息,请参考上述方法的文档字符串。
batch_decode
( *args **kwargs )
此方法将所有参数转发到 PreTrainedTokenizer 的 batch_decode()。有关更多信息,请参考此方法的文档字符串。
decode
( *args **kwargs )
此方法将所有参数转发到 PreTrainedTokenizer 的 decode()。有关更多信息,请参考此方法的文档字符串。
Wav2Vec2ProcessorWithLM
class transformers.Wav2Vec2ProcessorWithLM
( feature_extractor: FeatureExtractionMixin tokenizer: PreTrainedTokenizerBase decoder: BeamSearchDecoderCTC )
参数
-
feature_extractor
(Wav2Vec2FeatureExtractor 的一个实例。特征提取器是必需的输入。 -
tokenizer
(Wav2Vec2CTCTokenizer 的一个实例。分词器是必需的输入。 -
decoder
(pyctcdecode.BeamSearchDecoderCTC
)—pyctcdecode.BeamSearchDecoderCTC
的一个实例。解码器是必需的输入。
构建一个 Wav2Vec2 处理器,将 Wav2Vec2 特征提取器、Wav2Vec2 CTC 分词器和具有语言模型支持的解码器包装到一个单一的处理器中,用于语言模型增强的语音识别解码。
__call__
( *args **kwargs )
在正常模式下使用时,此方法将所有参数转发到 Wav2Vec2FeatureExtractor 的call(),并返回其输出。如果在上下文中使用as_target_processor()
,此方法将所有参数转发到 Wav2Vec2CTCTokenizer 的call()。请参考上述两种方法的文档字符串以获取更多信息。
pad
( *args **kwargs )
在正常模式下使用时,此方法将所有参数转发到 Wav2Vec2FeatureExtractor 的 pad(),并返回其输出。如果在上下文中使用as_target_processor()
,此方法将所有参数转发到 Wav2Vec2CTCTokenizer 的 pad()。请参考上述两种方法的文档字符串以获取更多信息。
from_pretrained
( pretrained_model_name_or_path **kwargs )
参数
-
pretrained_model_name_or_path
(str
oros.PathLike
) — 可以是:-
预训练特征提取器的模型 ID的字符串,托管在 huggingface.co 上的模型存储库中。有效的模型 ID 可以位于根级别,如
bert-base-uncased
,或者在用户或组织名称下命名空间化,如dbmdz/bert-base-german-cased
。 -
一个包含使用 save_pretrained()方法保存的特征提取器文件的目录路径,例如
./my_model_directory/
。 -
从预训练的特征提取器 JSON 文件的路径或 URL,例如
./my_model_directory/preprocessor_config.json
。**kwargs — 传递给 SequenceFeatureExtractor 和 PreTrainedTokenizer 的额外关键字参数
-
从预训练的 Wav2Vec2 处理器实例化一个 Wav2Vec2ProcessorWithLM。
这个类方法只是调用了 Wav2Vec2FeatureExtractor 的 from_pretrained(),Wav2Vec2CTCTokenizer 的 from_pretrained(),以及pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub
。
请参考上述方法的文档字符串以获取更多信息。
save_pretrained
( save_directory )
batch_decode
( 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 向量,表示每个标记的对数概率。 -
pool
(multiprocessing.Pool
, optional) — 可选的用户管理的池。如果未设置,将自动创建并关闭一个池。池应在Wav2Vec2ProcessorWithLM
之后实例化。否则,LM 将不可用于池的子进程。目前,只有使用“fork”上下文创建的池才能使用。如果传递了“spawn”池,它将被忽略,而将使用顺序解码。
-
num_processes
(int
, optional) — 如果未设置pool
,则应该在哪些进程上并行化函数。默认为可用 CPU 的数量。 -
beam_width
(int
, optional) — 解码过程中每一步的最大 beam 数。默认为 pyctcdecode 的 DEFAULT_BEAM_WIDTH。 -
beam_prune_logp
(int
, optional) — 比最佳 beam 差很多的 beam 将被修剪。默认为 pyctcdecode 的 DEFAULT_PRUNE_LOGP。 -
token_min_logp
(int
, optional) — 低于此 logp 的标记将被跳过,除非它们是帧的 argmax。默认为 pyctcdecode 的 DEFAULT_MIN_TOKEN_LOGP。 -
hotwords
(List[str]
, optional) — 具有额外重要性的单词列表,可以是 LM 的 OOV -
hotword_weight
(int
, optional) — 热词重要性的权重因子,默认为 pyctcdecode 的 DEFAULT_HOTWORD_WEIGHT。 -
alpha
(float
, optional) — 浅融合期间语言模型的权重 -
beta
(float
, optional) — 在评分过程中长度得分调整的权重 -
unk_score_offset
(float
, optional) — 未知标记的对数分数偏移量 -
lm_score_boundary
(bool
, optional) — 在评分时是否让 kenlm 尊重边界 -
output_word_offsets
(bool
, optional, 默认为False
) — 是否输出单词偏移量。单词偏移量可以与采样率和模型下采样率结合使用,以计算转录单词的时间戳。 -
n_best
(int
, optional, 默认为1
) — 要返回的最佳假设数量。如果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
( 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
) — 代表每个标记的对数概率的模型输出向量。 -
beam_width
(int
, optional) — 解码过程中每一步的最大 beam 数。默认为 pyctcdecode 的 DEFAULT_BEAM_WIDTH。 -
beam_prune_logp
(int
, optional) — 一个用于修剪 log-probs 小于 best_beam_logp + beam_prune_logp 的阈值。该值应 <= 0。默认为 pyctcdecode 的 DEFAULT_PRUNE_LOGP。 -
token_min_logp
(int
,optional) — log-probs 低于 token_min_logp 的标记将被跳过,除非它们是话语的最大 log-prob。默认为 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) — 未知标记的 log 分数偏移量 -
lm_score_boundary
(bool
, optional) — 是否在评分时让 kenlm 尊重边界 -
output_word_offsets
(bool
, optional, 默认为False
) — 是否输出单词偏移量。单词偏移量可以与采样率和模型下采样率结合使用,计算转录单词的时间戳。 -
n_best
(int
,optional,默认为1
) — 要返回的最佳假设数量。如果n_best
大于 1,则返回的text
将是一个字符串列表,logit_score
将是一个浮点数列表,lm_score
将是一个浮点数列表,这些列表的长度将对应于返回的假设数量。该值应大于等于 1。请查看下面的示例,以更好地理解如何使用
output_word_offsets
。
使用语言模型支持将输出逻辑解码为音频转录。
示例:
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)
>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
... logits = model(input_values).logits[0].cpu().numpy()
>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
>>> word_offsets = [
... {
... "word": d["word"],
... "start_time": round(d["start_offset"] * time_offset, 2),
... "end_time": round(d["end_offset"] * time_offset, 2),
... }
... for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]
解码多个音频
如果您计划解码多批音频,应考虑使用 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
( text: Union logit_score: Union = None lm_score: Union = None word_offsets: Union = None )
参数
-
text
(str
列表或str
) — 文本中的解码逻辑。通常是语音转录。 -
logit_score
(float
列表或float
) — 与生成文本相关的 beam 的总 logit 分数。 -
lm_score
(float
列表) — 与生成文本相关的 beam 的融合 lm_score。 -
word_offsets
(List[Dict[str, Union[int, str]]]
或List[Dict[str, Union[int, str]]]
列表 — 解码单词的偏移量。结合采样率和模型下采样率,单词偏移量可用于计算每个单词的时间戳。
Wav2Vec2DecoderWithLM
的输出类型,带有转录。
class transformers.modeling_outputs.Wav2Vec2BaseModelOutput
( last_hidden_state: FloatTensor = None extract_features: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )
参数
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
) — 模型最后一层的隐藏状态序列。 -
extract_features
(形状为(batch_size, sequence_length, conv_dim[-1])
的torch.FloatTensor
) — 模型最后一个卷积层的提取特征向量序列。 -
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 后的注意力权重,用于计算自注意力头中的加权平均值。
使用 Wav2Vec2 损失目标进行训练的模型的基类。
class transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput
( 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
时返回,torch.FloatTensor
of shape(1,)
) — 总损失,由对比损失(L_m)和多样性损失(L_d)的和组成,如官方论文中所述。 (分类)损失。 -
projected_states
(torch.FloatTensor
of shape(batch_size, sequence_length, config.proj_codevector_dim)
) — 模型的隐藏状态投影到config.proj_codevector_dim,可用于预测掩码的投影量化状态。 -
projected_quantized_states
(torch.FloatTensor
of shape(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
时返回) — 形状为(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
时返回,torch.FloatTensor
of shape(1,)
) — 对比损失(L_m),如官方论文中所述。 -
diversity_loss
(可选, 当传递sample_negative_indices
时返回,torch.FloatTensor
of shape(1,)
) — 多样性损失(L_d),如官方论文中所述。
Wav2Vec2ForPreTraining 的输出类型,具有潜在的隐藏状态和注意力。
class transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput
( last_hidden_state: Array = None extract_features: Array = None hidden_states: Optional = None attentions: Optional = None )
参数
-
last_hidden_state
(jnp.ndarray
of shape(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。 -
extract_features
(jnp.ndarray
of shape(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 后的注意力权重,用于计算自注意力头中的加权平均值。
FlaxWav2Vec2BaseModelOutput
的输出类型,具有潜在的隐藏状态和注意力。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
class transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput
( 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
(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
元组(一个用于嵌入输出,一个用于每一层的输出)。模型在每一层输出处的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的jnp.ndarray
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
FlaxWav2Vec2ForPreTrainingOutput
的输出类型,具有潜在的隐藏状态和注意力。
replace
( **updates )
“返回一个用新值替换指定字段的新对象。
PytorchHide Pytorch 内容
Wav2Vec2Model
class transformers.Wav2Vec2Model
( config: Wav2Vec2Config )
参数
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
( input_values: Optional attention_mask: Optional = None mask_time_indices: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Wav2Vec2BaseModelOutput or 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)
, optional) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[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
是否填充会产生略有不同的结果。 -
-
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 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
of shape(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
时返回) — 形状为(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 后的注意力权重,用于计算自注意力头中的加权平均值。
Wav2Vec2Model 的 forward 方法,覆盖了 __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")
>>> 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
( config target_lang: Optional = None )
参数
-
config
(Wav2Vec2Config) — 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法来加载模型权重。 -
target_lang
(str
,可选的) — 适配器权重的语言 id。适配器权重存储在格式为 adapter..safetensors 或 adapter. .bin 的文件中。仅在使用带有适配器的 Wav2Vec2ForCTC 实例时相关。默认使用 ‘eng’。
带有顶部 语言建模
的 Wav2Vec2 模型,用于 Connectionist Temporal Classification (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
( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutput or tuple(torch.FloatTensor)
参数
-
input_values
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 输入原始语音波形的浮点值。值可以通过将.flac
或.wav
音频文件加载到类型为List[float]
或numpy.ndarray
的数组中获得,例如通过 soundfile 库 (pip install soundfile
)。要准备好数组为input_values
,应使用 AutoProcessor 进行填充和转换为torch.FloatTensor
类型的张量。有关详细信息,请参阅 Wav2Vec2Processor.call
()。 -
attention_mask
(torch.LongTensor
of shape(batch_size, sequence_length)
, 可选) — 用于避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[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
是否填充而产生略有不同的结果。 -
-
output_attentions
(bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
。 -
output_hidden_states
(bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。 -
return_dict
(bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。 -
labels
(torch.LongTensor
of shape(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
of shape(1,)
, 可选, 当提供labels
时返回) — 语言建模损失(用于下一个标记的预测)。 -
logits
(torch.FloatTensor
of shape(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型具有嵌入层的输出,则为嵌入的输出+每层的输出)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
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")
>>> 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
( target_lang: str force_load = True **kwargs )
参数
-
target_lang
(str
) — 必须是现有适配器权重的语言 ID。适配器权重存储在格式 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
(bool
, 可选, 默认为False
) — 是否删除接收不完整的文件。如果存在这样的文件,将尝试恢复下载。 -
proxies
(Dict[str, str]
, 可选) — 一个按协议或端点使用的代理服务器字典,例如,{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}
。每个请求都会使用代理。 -
local_files_only(bool,
可选, 默认为False
) — 是否仅查看本地文件(即不尝试下载模型)。 -
token
(str
或bool
, 可选) — 用作远程文件的 HTTP bearer 授权的令牌。如果为True
,或未指定,将使用运行huggingface-cli login
时生成的令牌(存储在~/.huggingface
中)。 -
revision
(str
, 可选, 默认为"main"
) — 要使用的特定模型版本。它可以是分支名称、标签名称或提交 ID,因为我们在 huggingface.co 上使用基于 git 的系统存储模型和其他工件,所以revision
可以是 git 允许的任何标识符。要测试您在 Hub 上提交的拉取请求,可以传递 `revision=“refs/pr/<pr_number>“。</pr_number>
-
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 是由 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: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)
参数
-
input_values
(torch.FloatTensor
,形状为(batch_size, sequence_length)
) — 输入原始语音波形的浮点值。可以通过将.flac
或.wav
音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得值,例如通过声音文件库(pip install soundfile
)。要将数组准备为input_values
,应使用 AutoProcessor 进行填充和转换为torch.FloatTensor
类型的张量。有关详细信息,请参阅 Wav2Vec2Processor.call
()。 -
attention_mask
(torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 用于避免在填充标记索引上执行卷积和注意力的掩码。选择的掩码值在[0, 1]
范围内:-
对于未被掩码的标记为
1
, -
对于被掩码的标记为
0
。
什么是注意力掩码?
只有在相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器具有config.return_attention_mask == False
的模型,例如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
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
)- 分类(如果config.num_labels==1
则为回归)分数(SoftMax 之前)。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出,如果模型有一个嵌入层,+ 一个用于每个层的输出)。模型在每个层的输出的隐藏状态加上可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
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")
>>> 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 模型,用于 Speaker Diarization 等任务。
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: Optional attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)
参数
-
input_values
(形状为(batch_size, sequence_length)
的torch.FloatTensor
)- 输入原始语音波形的浮点值。 值可以通过将.flac
或.wav
音频文件加载到List[float]
类型的数组或numpy.ndarray
中获得,例如 通过声音文件库(pip install soundfile
)。 要将数组准备成input_values
,应使用 AutoProcessor 进行填充并转换为torch.FloatTensor
类型的张量。 有关详细信息,请参阅 Wav2Vec2Processor.call
()。 -
attention_mask
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 用于避免在填充标记索引上执行卷积和注意力的掩码。 选择的掩码值在[0, 1]
中:-
对于“未屏蔽”的标记,
-
对于被
masked
的标记为 0。
注意力掩码是什么?
只有在相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器具有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.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)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层的输出,则为嵌入层的输出 + 每层的输出)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
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")
>>> 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
( config )
参数
config
(Wav2Vec2Config)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
Wav2Vec2 模型在顶部具有 XVector 特征提取头,用于 Speaker Verification 等任务。
Wav2Vec2 是由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 提出的wav2vec 2.0:自监督学习语音表示的框架。
这个模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法(如下载或保存等)。
这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_values: Optional attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.XVectorOutput or 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]
范围内的掩码值:-
对于未被
masked
的标记,值为 1, -
对于被
masked
的标记,值为 0。
什么是注意力掩码?
只有在相应的处理器具有
config.return_attention_mask == True
时才应传递attention_mask
。对于所有处理器具有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
(形状为(batch_size,)
的torch.LongTensor
,可选)— 用于计算序列分类/回归损失的标签。索引应在[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,)
,可选,当提供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
时返回)— 形状为(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 之后,用于计算自注意力头中的加权平均值。
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")
>>> 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() 方法以加载模型权重。
Wav2Vec2 模型带有量化器和顶部的 VQ
头。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: 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 ) → export const metadata = 'undefined';transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput or 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]
中:-
对于
未屏蔽
的标记, -
对于
被屏蔽
的标记。
什么是注意力掩码?
只有当相应的处理器具有
config.return_attention_mask == True
时,才应传递attention_mask
。对于所有处理器具有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 而不是普通元组。 -
mask_time_indices
(形状为(batch_size, sequence_length)
的torch.BoolTensor
,可选)— 用于对比损失中掩盖提取特征的索引。在训练模式下,模型学习在config.proj_codevector_dim空间中预测被掩盖的提取特征。 -
sampled_negative_indices
(形状为(batch_size, sequence_length, num_negatives)
的torch.BoolTensor
,可选)— 指示哪些量化目标向量在对比损失中用作负采样向量的索引。预训练所需的输入。
返回
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
时返回,形状为(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 的前向方法,覆盖__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
TensorFlow 隐藏 TensorFlow 内容
TFWav2Vec2Model
class transformers.TFWav2Vec2Model
( config: Wav2Vec2Config *inputs **kwargs )
参数
config
(Wav2Vec2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸 TFWav2Vec2 模型变压器输出原始隐藏状态,没有特定的头部。
该模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
该模型也是tf.keras.Model子类。将其用作常规 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取有关一般用法和行为的所有信息。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
-
将所有输入作为关键字参数(类似于 PyTorch 模型),或
-
将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持,当使用model.fit()
等方法时,应该可以“正常工作” - 只需传递您的输入和标签以任何model.fit()
支持的格式!但是,如果您想在 Keras 方法之外使用第二种格式,例如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可用于收集第一个位置参数中的所有输入张量:
-
一个仅包含
input_values
的单个张量,没有其他内容:model(input_values)
-
一个长度不同的列表,其中包含按照文档字符串中给定的顺序的一个或多个输入张量:
model([input_values, attention_mask])
或model([input_values, attention_mask, token_type_ids])
-
一个字典,其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量:
model({"input_values": input_values, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像将输入传递给任何其他 Python 函数一样传递输入!
call
( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)
参数
-
input_values
(np.ndarray
,tf.Tensor
,List[tf.Tensor]
,Dict[str, tf.Tensor]
或Dict[str, np.ndarray]
,每个示例的形状必须为({0})
)— 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.
call
()和 PreTrainedTokenizer.encode()。什么是输入 ID?
-
attention_mask
(形状为({0})
的np.ndarray
或tf.Tensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:-
对于
未屏蔽
的标记, -
对于
被屏蔽
的标记为 0。
什么是注意力掩码?
-
-
token_type_ids
(形状为({0})
的np.ndarray
或tf.Tensor
,可选)— 段标记索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:-
0 对应于句子 A标记。
-
1 对应于句子 B标记。
什么是标记类型 ID?
-
-
position_ids
(形状为({0})
的np.ndarray
或tf.Tensor
,可选)— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。什么是位置 ID?
-
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的np.ndarray
或tf.Tensor
,可选)— 用于使自注意力模块的选定头部无效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未
被屏蔽
, -
0 表示头部是
屏蔽
的。
-
-
inputs_embeds
(形状为({0}, hidden_size)
的np.ndarray
或tf.Tensor
,可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_values
。如果您想要更多控制权来将input_values
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。 -
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。此参数仅在急切模式下可用,在图模式下将使用配置中的值。 -
output_hidden_states
(bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。此参数仅在急切模式下可用,在图模式下将使用配置中的值。 -
return_dict
(bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用,在图模式下该值将始终设置为 True。 -
training
(bool
, 可选,默认为`False“) — 是否在训练模式下使用模型(一些模块如 dropout 模块在训练和评估之间有不同的行为)。
返回
transformers.modeling_tf_outputs.TFBaseModelOutput 或tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个tf.Tensor
元组(如果传递return_dict=False
或config.return_dict=False
时)包含根据配置(Wav2Vec2Config)和输入的各种元素。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)的 tf.Tensor
) — 模型最后一层的隐藏状态序列。 -
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
TFWav2Vec2ForSequenceClassification
class transformers.TFWav2Vec2ForSequenceClassification
( config )
call
( 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
( config: Wav2Vec2Config *inputs **kwargs )
参数
config
(Wav2Vec2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
TFWav2Vec2 模型,在 Connectionist Temporal Classification (CTC)顶部具有语言建模
头。
这个模型继承自 TFPreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
-
将所有输入作为关键字参数(类似于 PyTorch 模型),或者
-
将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持,当使用model.fit()
等方法时,应该可以“正常工作” - 只需以model.fit()
支持的任何格式传递输入和标签即可!但是,如果您想在 Keras 方法之外(如fit()
和predict()
)使用第二种格式,比如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可以用来收集第一个位置参数中的所有输入张量:
-
一个仅包含
input_values
的单个张量,没有其他内容:model(input_values)
-
一个长度可变的列表,其中包含一个或多个与文档字符串中给定的顺序相对应的输入张量:
model([input_values, attention_mask])
或model([input_values, attention_mask, token_type_ids])
-
一个字典,其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量:
model({"input_values": input_values, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心这些问题,因为您可以像将输入传递给任何其他 Python 函数一样传递输入!
call
( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None labels: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFCausalLMOutput or tuple(tf.Tensor)
参数
-
input_values
(np.ndarray
,tf.Tensor
,List[tf.Tensor]
,Dict[str, tf.Tensor]
或Dict[str, np.ndarray]
,每个示例的形状必须为({0})
)—词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.
call
()和 PreTrainedTokenizer.encode()。什么是输入 ID?
-
attention_mask
(形状为({0})
的np.ndarray
或tf.Tensor
,可选)—用于避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]
:-
1 表示“未被掩码”的标记,
-
0 表示“被掩码”的标记。
什么是注意力掩码?
-
-
token_type_ids
(形状为({0})
的np.ndarray
或tf.Tensor
,可选)—段标记索引,用于指示输入的第一部分和第二部分。索引选择在[0, 1]
中:-
0 对应于句子 A标记,
-
1 对应于句子 B标记。
什么是标记类型 ID?
-
-
position_ids
(形状为({0})
的np.ndarray
或tf.Tensor
,可选)—每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。什么是位置 ID?
-
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的np.ndarray
或tf.Tensor
,可选)—用于使自注意力模块中选择的头部失效的掩码。选择的掩码值为[0, 1]
:-
1 表示头部是
not masked
。 -
0 表示头部被
masked
。
-
-
inputs_embeds
(形状为({0}, hidden_size)
的np.ndarray
或tf.Tensor
,可选) — 可选地,可以直接传递嵌入表示,而不是传递input_values
。如果您想要更多控制如何将input_values
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。 -
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。此参数仅在急切模式下使用,在图模式下将使用配置中的值。 -
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。此参数仅在急切模式下使用,在图模式下将使用配置中的值。 -
return_dict
(bool
,可选) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用,在图模式下该值将始终设置为 True。 -
training
(bool
,可选,默认为False
) — 是否在训练模式下使用模型(某些模块,如 dropout 模块,在训练和评估之间具有不同的行为)。 -
labels
(形状为(batch_size, sequence_length)
的tf.Tensor
或np.ndarray
,可选) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]
范围内(参见input_values
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅计算具有标签在[0, ..., config.vocab_size]
范围内的标记。
返回
transformers.modeling_tf_outputs.TFCausalLMOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFCausalLMOutput 或一个tf.Tensor
元组(如果传递return_dict=False
或config.return_dict=False
时)包含各种元素,具体取决于配置(Wav2Vec2Config)和输入。
-
loss
(形状为(n,)
的tf.Tensor
,可选,其中 n 是非掩码标签的数量,在提供labels
时返回) — 语言建模损失(用于下一个标记预测)。 -
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的tf.Tensor
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递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 之后,用于计算自注意力头中的加权平均值。
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
JAXHide JAX 内容
FlaxWav2Vec2Model
class transformers.FlaxWav2Vec2Model
( 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,不影响模型参数的 dtype。
如果要更改模型参数的 dtype,请参阅 to_fp16()和 to_bf16()。
裸 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 ) → export const metadata = 'undefined';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]
中:-
对于未被
masked
的标记,值为 1, -
对于被
masked
的标记,值为 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
(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
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每一层的输出的隐藏状态加上初始嵌入输出。
-
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
class transformers.FlaxWav2Vec2ForCTC
( 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
执行。请注意,这仅指定计算的数据类型,不会影响模型参数的数据类型。
如果要更改模型参数的数据类型,请参阅 to_fp16() 和 to_bf16()。
Wav2Vec2 模型在顶部带有“语言建模”头部,用于 Connectionist Temporal Classification (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__
( 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 ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxMaskedLMOutput or tuple(torch.FloatTensor)
参数
-
input_values
(形状为(batch_size, sequence_length)
的jnp.ndarray
) — 输入原始语音波形的浮点值。可以通过将.flac
或.wav
音频文件加载到类型为List[float]
或numpy.ndarray
的数组中获得。要将数组准备成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
(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.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
(jnp.ndarray
,形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 前每个词汇标记的分数)。 -
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
class transformers.FlaxWav2Vec2ForPreTraining
( 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
进行。请注意,这仅指定计算的数据类型,不会影响模型参数的数据类型。
如果要更改模型参数的数据类型,请参阅 to_fp16()和 to_bf16()。
带有量化器和顶部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 ) → export const metadata = 'undefined';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
(jnp.ndarray
of shape(batch_size, sequence_length)
, 可选) — 避免在填充标记索引上执行卷积和注意力的掩码。掩码值选择在[0, 1]
中:-
对于未被
masked
的标记为 1。 -
对于被
masked
的标记为 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
(jnp.ndarray
,形状为(batch_size, sequence_length)
,optional) — 用于对比损失中掩码提取特征的索引。在训练模式下,模型学习在config.proj_codevector_dim空间中预测掩码提取特征。 -
output_attentions
(bool
, *optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的
attentions`。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 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
(optional,在训练模式下返回,形状为(1,)
的jnp.ndarray
) — 总损失,作为对比损失(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)
,optional,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出,一个用于每一层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(jnp.ndarray)
,optional,当传递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
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 一个费力不讨好的项目,让我损失了近一半的绩效!
· 清华大学推出第四讲使用 DeepSeek + DeepResearch 让科研像聊天一样简单!
· 实操Deepseek接入个人知识库
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库