Transformers 文档
SpeechT5
并获得增强的文档体验
开始使用
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（文本到文本转换 Transformer）在预训练自然语言处理模型中取得成功的激励，我们提出了一个统一模态的 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 的 forward 方法的inputs_ids表示的不同 token 的数量。 - 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 论文](see https://arxiv.org/abs/1909.11556)。 - decoder_layers (
int, 可选, 默认为 6) — Transformer 解码器中隐藏层的数量。 - decoder_attention_heads (
int, 可选, 默认为 12) — Transformer 解码器中每个注意力层的注意力头数。 - decoder_ffn_dim (
int, 可选, 默认为 3072) — Transformer 解码器中“中间”（通常称为前馈）层的维度。 - decoder_layerdrop (
float, 可选, 默认为 0.1) — 解码器的 LayerDrop 概率。 有关更多详细信息，请参见 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。 - hidden_act (
str或function, 可选的, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"selu"和"gelu_new"。 - positional_dropout (
float, 可选的, 默认为 0.1) — 文本位置编码层的 dropout 概率。 - hidden_dropout (
float, 可选的, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 - attention_dropout (
float, 可选的, 默认为 0.1) — 注意力概率的 dropout 比率。 - activation_dropout (
float, 可选的, 默认为 0.1) — 全连接层内部激活的 dropout 比率。 - initializer_range (
float, 可选的, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float, 可选的, 默认为 1e-5) — 层归一化层使用的 epsilon 值。 - scale_embedding (
bool, 可选的, 默认为False) — 通过除以 sqrt(d_model) 来缩放嵌入。 - feat_extract_norm (
str, 可选的, 默认为"group") — 应用于语音编码器预网络中 1D 卷积层的归一化方法。可以是"group"（仅对第一个 1D 卷积层进行组归一化）或"layer"（对所有 1D 卷积层进行层归一化）。 - feat_proj_dropout (
float, 可选的, 默认为 0.0) — 语音编码器预网络输出的 dropout 概率。 - feat_extract_activation (
str, 可选的, 默认为"gelu") — 特征提取器 1D 卷积层中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"selu"和"gelu_new"。 - conv_dim (
Tuple[int]或List[int], 可选的, 默认为(512, 512, 512, 512, 512, 512, 512)) — 定义语音编码器预网络中每个 1D 卷积层的输入和输出通道数的整数元组。conv_dim 的长度定义了 1D 卷积层的数量。 - conv_stride (
Tuple[int]或List[int], 可选的, 默认为(5, 2, 2, 2, 2, 2, 2)) — 定义语音编码器预网络中每个 1D 卷积层步长的整数元组。conv_stride 的长度定义了卷积层的数量，并且必须与 conv_dim 的长度匹配。 - conv_kernel (
Tuple[int]或List[int], 可选的, 默认为(10, 3, 3, 3, 3, 3, 3)) — 定义语音编码器预网络中每个 1D 卷积层内核大小的整数元组。conv_kernel 的长度定义了卷积层的数量，并且必须与 conv_dim 的长度匹配。 - conv_bias (
bool, 可选的, 默认为False) — 1D 卷积层是否具有偏置。 - num_conv_pos_embeddings (
int, 可选的, 默认为 128) — 卷积位置嵌入的数量。定义 1D 卷积位置嵌入层的内核大小。 - num_conv_pos_embedding_groups (
int, 可选的, 默认为 16) — 1D 卷积位置嵌入层的组数。 - apply_spec_augment (
bool, 可选的, 默认为True) — 是否将 SpecAugment 数据增强应用于语音编码器预网络的输出。有关参考，请参阅 SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。 - mask_time_prob (
float, 可选的, 默认为 0.05) — 沿时间轴将被屏蔽的所有特征向量的百分比（介于 0 和 1 之间）。屏蔽过程沿轴生成 “mask_time_problen(time_axis)/mask_time_length” 个独立掩码。如果从每个特征向量被选为要屏蔽的向量跨度的起点的概率来推断，则 mask_time_prob 应为 `prob_vector_startmask_time_length`。请注意，重叠可能会减少实际屏蔽向量的百分比。这仅在apply_spec_augment为 True 时相关。 - mask_time_length (
int, 可选的, 默认为 10) — 沿时间轴的向量跨度长度。 - mask_time_min_masks (
int, 可选的, 默认为 2) — 沿时间轴生成的长度为mask_feature_length的掩码的最小数量，每个时间步，与mask_feature_prob无关。仅在 “mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks” 时相关 - mask_feature_prob (
float, 可选的, 默认为 0.0) — 沿特征轴将被屏蔽的所有特征向量的百分比（介于 0 和 1 之间）。屏蔽过程沿轴生成 “mask_feature_problen(feature_axis)/mask_time_length” 个独立掩码。如果从每个特征向量被选为要屏蔽的向量跨度的起点的概率来推断，则 mask_feature_prob 应为 `prob_vector_startmask_feature_length`。请注意，重叠可能会减少实际屏蔽向量的百分比。这仅在apply_spec_augment为 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_mel_bins (
int, 可选的, 默认为 80) — 每个输入特征使用的 mel 特征的数量。由语音解码器预网络使用。应与 SpeechT5Processor 类中使用的值相对应。 - speech_decoder_prenet_layers (
int, 可选, 默认为 2) — 语音解码器预网络中的层数。 - speech_decoder_prenet_units (
int, 可选, 默认为 256) — 语音解码器预网络中各层的维度。 - speech_decoder_prenet_dropout (
float, 可选, 默认为 0.5) — 语音解码器预网络层的 dropout 概率。 - speaker_embedding_dim (
int, 可选, 默认为 512) — XVector 嵌入向量的维度。 - speech_decoder_postnet_layers (
int, 可选, 默认为 5) — 语音解码器后网络中的层数。 - speech_decoder_postnet_units (
int, 可选, 默认为 256) — 语音解码器后网络中各层的维度。 - speech_decoder_postnet_kernel (
int, 可选, 默认为 5) — 语音解码器后网络中卷积滤波器通道的数量。 - speech_decoder_postnet_dropout (
float, 可选, 默认为 0.5) — 语音解码器后网络层的 dropout 概率。 - reduction_factor (
int, 可选, 默认为 2) — 语音解码器输入的频谱图长度缩减因子。 - max_speech_positions (
int, 可选, 默认为 4000) — 此模型可能使用的语音特征的最大序列长度。 - max_text_positions (
int, 可选, 默认为 450) — 此模型可能使用的文本特征的最大序列长度。 - encoder_max_relative_position (
int, 可选, 默认为 160) — 编码器中相对位置嵌入的最大距离。 - use_guided_attention_loss (
bool, 可选, 默认为True) — 是否在训练 TTS 模型时应用引导注意力损失。 - guided_attention_loss_num_heads (
int, 可选, 默认为 2) — 将引导注意力损失应用于的注意力头的数量。 使用 -1 将此损失应用于所有注意力头。 - guided_attention_loss_sigma (
float, 可选, 默认为 0.4) — 引导注意力损失的标准差。 - guided_attention_loss_scale (
float, 可选, 默认为 10.0) — 引导注意力损失的缩放系数（也称为 lambda）。 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
这是用于存储 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.configSpeechT5HifiGanConfig
class transformers.SpeechT5HifiGanConfig
< source >( 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, 可选, 默认为 80) — 输入 log-mel 频谱图中频率 bins 的数量。 - sampling_rate (
int, 可选, 默认为 16000) — 将生成输出音频的采样率，以赫兹 (Hz) 表示。 - upsample_initial_channel (
int, 可选, 默认为 512) — 上采样网络中输入通道的数量。 - upsample_rates (
Tuple[int]或List[int], 可选, 默认为[4, 4, 4, 4]) — 定义上采样网络中每个 1D 卷积层步长的整数元组。 upsample_rates 的长度定义了卷积层的数量，并且必须与 upsample_kernel_sizes 的长度匹配。 - upsample_kernel_sizes (
Tuple[int]或List[int], 可选, 默认为[8, 8, 8, 8]) — 定义上采样网络中每个 1D 卷积层内核大小的整数元组。 upsample_kernel_sizes 的长度定义了卷积层的数量，并且必须与 upsample_rates 的长度匹配。 - resblock_kernel_sizes (
Tuple[int]或List[int], 可选, 默认为[3, 7, 11]) — 定义多感受野融合 (MRF) 模块中 1D 卷积层内核大小的整数元组。 - resblock_dilation_sizes (
Tuple[Tuple[int]]或List[List[int]], 可选, 默认为[[1, 3, 5], [1, 3, 5], [1, 3, 5]]) — 定义多感受野融合 (MRF) 模块中扩张的 1D 卷积层扩张率的嵌套整数元组。 - initializer_range (
float, optional, 默认值是 0.01) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - leaky_relu_slope (
float, optional, 默认值是 0.1) — leaky ReLU 激活函数使用的负斜率的角度。 - normalize_before (
bool, optional, 默认值是True) — 是否在使用声码器的学习均值和方差进行声码处理之前，对频谱图进行归一化。
这是用于存储 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.configSpeechT5Tokenizer
class transformers.SpeechT5Tokenizer
< source >( vocab_file bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' normalize = False sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None **kwargs )
参数
- vocab_file (
str) — SentencePiece 文件（通常具有 .spm 扩展名），其中包含实例化 tokenizer 所需的词汇表。 - bos_token (
str, optional, 默认值是"<s>") — 序列开始 token。 - eos_token (
str, optional, 默认值是"</s>") — 序列结束 token。 - unk_token (
str, optional, 默认值是"<unk>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，而是设置为此 token。 - pad_token (
str, optional, 默认值是"<pad>") — 用于填充的 token，例如在批量处理不同长度的序列时。 - normalize (
bool, optional, 默认值是False) — 是否将文本中的数字量转换为其拼写的英文对应项。 - sp_model_kwargs (
dict, optional) — 将传递给SentencePieceProcessor.__init__()方法。SentencePiece 的 Python 封装器 可以用于设置以下内容：-
enable_sampling: 启用子词正则化。 -
nbest_size: unigram 的采样参数。对 BPE-Dropout 无效。nbest_size = {0,1}: 不执行采样。nbest_size > 1: 从 nbest_size 结果中采样。nbest_size < 0: 假设 nbest_size 是无限的，并使用前向滤波和后向采样算法从所有假设（格）中采样。
-
alpha: unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的 dropout 概率。
-
- sp_model (
SentencePieceProcessor) — 用于每次转换（字符串、token 和 ID）的 SentencePiece 处理器。
构建 SpeechT5 tokenizer。基于 SentencePiece。
此 tokenizer 继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
__call__
< source >( text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None text_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None text_pair_target: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 is_split_into_words: bool = False pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → BatchEncoding
参数
- text (
str,List[str],List[List[str]], optional) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预 token 化的字符串）。如果序列以字符串列表（预 token 化）的形式提供，则必须设置is_split_into_words=True（以消除与序列批次的歧义）。 - text_pair (
str,List[str],List[List[str]], optional) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预 token 化的字符串）。如果序列以字符串列表（预 token 化）的形式提供，则必须设置is_split_into_words=True（以消除与序列批次的歧义）。 - text_target (
str,List[str],List[List[str]], optional) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预 token 化的字符串）。如果序列以字符串列表（预 token 化）的形式提供，则必须设置is_split_into_words=True（以消除与序列批次的歧义）。 - text_pair_target (
str,List[str],List[List[str]], optional) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预 token 化的字符串）。如果序列以字符串列表（预 token 化）的形式提供，则必须设置is_split_into_words=True（以消除与序列批次的歧义）。 - add_special_tokens (
bool, optional, 默认值是True) — 是否在编码序列时添加特殊 token。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了哪些 token 会自动添加到 input ids 中。如果您想自动添加bos或eostoken，这将非常有用。 - padding (
bool,str或 PaddingStrategy, optional, 默认值是False) — 激活和控制填充。接受以下值：True或'longest': 填充到批次中最长序列的长度（如果仅提供单个序列，则不进行填充）。'max_length': 填充到由参数max_length指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'(默认): 不填充（即，可以输出具有不同长度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, 可选, 默认为False) — 激活并控制截断。接受以下值：True或'longest_first'： 截断至通过参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐 token 进行截断，如果提供了一对序列（或一批序列对），则从较长的序列中移除 token。'only_first'： 截断至通过参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断第一个序列。'only_second'： 截断至通过参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断第二个序列。False或'do_not_truncate'(默认)： 不进行截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
- max_length (
int, 可选) — 控制截断/填充参数之一使用的最大长度。如果未设置或设置为
None，如果截断/填充参数之一需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将停用截断/填充至最大长度的功能。 - stride (
int, 可选, 默认为 0) — 如果与max_length一起设置，当return_overflowing_tokens=True时返回的溢出 token 将包含来自截断序列末尾的一些 token，以便在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool, 可选, 默认为False) — 输入是否已预先 token 化（例如，拆分为单词）。如果设置为True，则 tokenizer 假设输入已拆分为单词（例如，通过在空格上拆分），它将对其进行 token 化。这对于 NER 或 token 分类很有用。 - pad_to_multiple_of (
int, 可选) — 如果设置，将序列填充到所提供值的倍数。需要激活padding。这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Cores 的使用尤其有用。 - padding_side (
str, 可选) — 模型应在其上应用填充的一侧。应从 [‘right’, ‘left’] 中选择。默认值从同名类属性中选取。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'tf'： 返回 TensorFlowtf.constant对象。'pt'： 返回 PyTorchtorch.Tensor对象。'np'： 返回 Numpynp.ndarray对象。
- return_token_type_ids (
bool, 可选) — 是否返回 token 类型 ID。如果保留为默认值，将根据特定 tokenizer 的默认值返回 token 类型 ID，由return_outputs属性定义。 - return_attention_mask (
bool, 可选) — 是否返回 attention mask。如果保留为默认值，将根据特定 tokenizer 的默认值返回 attention mask，由return_outputs属性定义。 - return_overflowing_tokens (
bool, 可选, 默认为False) — 是否返回溢出的 token 序列。如果提供了一对输入 id 序列（或一批序列对），且truncation_strategy = longest_first或True，则会引发错误，而不是返回溢出的 token。 - return_special_tokens_mask (
bool, 可选, 默认为False) — 是否返回特殊 token 掩码信息。 - return_offsets_mapping (
bool, 可选, 默认为False) — 是否返回每个 token 的(char_start, char_end)。这仅在继承自 PreTrainedTokenizerFast 的快速 tokenizer 上可用，如果使用 Python 的 tokenizer，此方法将引发
NotImplementedError。 - return_length (
bool, 可选, 默认为False) — 是否返回编码后输入的长度。 - verbose (
bool, 可选, 默认为True) — 是否打印更多信息和警告。 - **kwargs — 传递给
self.tokenize()方法
返回值
一个 BatchEncoding，包含以下字段
-
input_ids — 要馈送到模型的 token ID 列表。
-
token_type_ids — 要馈送到模型的 token 类型 ID 列表（当
return_token_type_ids=True或如果 “token_type_ids” 在self.model_input_names中时）。 -
attention_mask — 指定模型应注意哪些 token 的索引列表（当
return_attention_mask=True或如果 “attention_mask” 在self.model_input_names中时）。 -
overflowing_tokens — 溢出的 token 序列列表（当指定了
max_length且return_overflowing_tokens=True时）。 -
num_truncated_tokens — 截断的 token 数量（当指定了
max_length且return_overflowing_tokens=True时）。 -
special_tokens_mask — 0 和 1 的列表，其中 1 表示添加的特殊 token，0 表示常规序列 token（当
add_special_tokens=True且return_special_tokens_mask=True时）。 -
length — 输入的长度（当
return_length=True时）
对一个或多个序列或一对或多对序列进行 token 化和模型准备的主要方法。
decode
< source >( token_ids: typing.Union[int, typing.List[int], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → str
参数
- token_ids (
Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]) — Token 化的输入 ID 列表。可以使用__call__方法获得。 - skip_special_tokens (
bool, 可选, 默认为False) — 是否在解码中移除特殊 token。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理 token 化空格。如果为None，则默认为self.clean_up_tokenization_spaces。 - kwargs (附加关键字参数, 可选) — 将传递给底层模型特定的解码方法。
返回值
str
解码后的句子。
使用 tokenizer 和词汇表将 ID 序列转换为字符串，可以选择移除特殊 token 并清理 token 化空格。
类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。
batch_decode
< source >( sequences: typing.Union[typing.List[int], typing.List[typing.List[int]], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → List[str]
参数
- sequences (
Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]) — Token 化的输入 ID 列表。可以使用__call__方法获得。 - skip_special_tokens (
bool, 可选, 默认为False) — 是否在解码中移除特殊 token。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理 token 化空格。如果为None，则默认为self.clean_up_tokenization_spaces。 - kwargs (附加关键字参数，可选) — 将会传递给底层模型特定的解码方法。
返回值
List[str]
解码句子的列表。
通过调用 decode，将 token id 列表的列表转换为字符串列表。
SpeechT5FeatureExtractor
class transformers.SpeechT5FeatureExtractor
< source >( 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, 可选, 默认为 1) — 提取特征的特征维度。 - sampling_rate (
int, 可选, 默认为 16000) — 音频文件应被数字化的采样率，以赫兹 (Hz) 表示。 - padding_value (
float, 可选, 默认为 0.0) — 用于填充 padding 值的数值。 - do_normalize (
bool, 可选, 默认为False) — 是否对输入进行零均值单位方差归一化。归一化可以显著提高某些模型的性能。 - num_mel_bins (
int, 可选, 默认为 80) — 提取的频谱图特征中 mel 频率箱的数量。 - hop_length (
int, 可选, 默认为 16) — 窗口之间的毫秒数。在许多论文中也称为 “shift”。 - win_length (
int, 可选, 默认为 64) — 每个窗口的毫秒数。 - win_function (
str, 可选, 默认为"hann_window") — 用于窗口化的窗口函数名称，必须可以通过torch.{win_function}访问 - frame_signal_scale (
float, 可选, 默认为 1.0) — 在应用 DFT 之前，创建帧时所乘的常数。此参数已弃用。 - fmin (
float, 可选, 默认为 80) — 最小 mel 频率，单位为 Hz。 - fmax (
float, 可选, 默认为 7600) — 最大 mel 频率，单位为 Hz。 - mel_floor (
float, 可选, 默认为 1e-10) — mel 频率组的最小值。 - reduction_factor (
int, 可选, 默认为 2) — 频谱图长度缩减因子。此参数已弃用。 - return_attention_mask (
bool, 可选, 默认为True) — 是否 call() 应该返回attention_mask。
构建 SpeechT5 特征提取器。
此类可以通过（可选地）归一化为零均值单位方差来预处理原始语音信号，以供 SpeechT5 语音编码器 prenet 使用。
此类还可以从原始语音中提取 log-mel 滤波器组特征，以供 SpeechT5 语音解码器 prenet 使用。
此特征提取器继承自 SequenceFeatureExtractor，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
__call__
< source >( audio: typing.Union[numpy.ndarray, typing.List[float], typing.List[numpy.ndarray], typing.List[typing.List[float]], NoneType] = None audio_target: typing.Union[numpy.ndarray, typing.List[float], typing.List[numpy.ndarray], typing.List[typing.List[float]], NoneType] = None padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False max_length: typing.Optional[int] = None truncation: bool = False pad_to_multiple_of: typing.Optional[int] = None return_attention_mask: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None sampling_rate: typing.Optional[int] = 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) — 选择一种策略来填充返回的序列（根据模型的 padding 侧和 padding 索引）：True或'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不进行填充）。'max_length'：填充到使用参数max_length指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'(默认)：不填充（即，可以输出具有不同长度序列的批次）。
- max_length (
int, 可选) — 返回列表的最大长度，以及可选的 padding 长度（见上文）。 - truncation (
bool) — 激活截断，将长于 max_length 的输入序列截断为 max_length。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充为所提供值的倍数。这对于在计算能力
>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Cores 的使用，或者在受益于序列长度为 128 倍数的 TPU 上尤其有用。 - return_attention_mask (
bool, 可选) — 是否返回 attention mask。如果保留为默认值，则将根据特定 feature_extractor 的默认值返回 attention mask。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensors 而不是 python 整数列表。可接受的值为：'tf'：返回 TensorFlowtf.constant对象。'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- sampling_rate (
int, optional) —audio或audio_target输入被采样的采样率。强烈建议在前向调用时传递sampling_rate，以防止静默错误。
用于特征化并为模型准备一个或多个序列的主要方法。
传入 audio 的值以提取波形特征。传入 audio_target 的值以提取 log-mel 频谱图特征。
SpeechT5Processor
class transformers.SpeechT5Processor
< source >( feature_extractor tokenizer )
参数
- feature_extractor (
SpeechT5FeatureExtractor) — SpeechT5FeatureExtractor 的实例。特征提取器是必需的输入。 - tokenizer (
SpeechT5Tokenizer) — SpeechT5Tokenizer 的实例。分词器是必需的输入。
构建一个 SpeechT5 处理器，它将特征提取器和分词器包装成一个单独的处理器。
SpeechT5Processor 提供了 SpeechT5FeatureExtractor 和 SpeechT5Tokenizer 的所有功能。 有关更多信息，请参阅 call() 和 decode() 的文档字符串。
处理音频和文本输入，以及音频和文本目标。
您可以使用参数 audio 处理音频，或使用参数 audio_target 处理音频目标。 这会将参数转发到 SpeechT5FeatureExtractor 的 call()。
您可以使用参数 text 处理文本，或使用参数 text_target 处理文本标签。 这会将参数转发到 SpeechT5Tokenizer 的 call()。
有效的输入组合是
- 仅
text - 仅
audio - 仅
text_target - 仅
audio_target text和audio_targetaudio和audio_targettext和text_targetaudio和text_target
有关更多信息，请参阅上述两种方法的文档字符串。
将音频和文本输入及其目标整理成一个填充批次。
音频输入由 SpeechT5FeatureExtractor 的 pad() 填充。文本输入由 SpeechT5Tokenizer 的 pad() 填充。
有效的输入组合是
- 仅
input_ids - 仅
input_values - 仅
labels，log-mel 频谱图或文本 tokens input_ids和 log-mel 频谱图labelsinput_values和文本labels
有关更多信息，请参阅上述两种方法的文档字符串。
from_pretrained
< source >( pretrained_model_name_or_path: typing.Union[str, os.PathLike] cache_dir: typing.Union[str, os.PathLike, NoneType] = None force_download: bool = False local_files_only: bool = False token: typing.Union[str, bool, NoneType] = None revision: str = 'main' **kwargs )
参数
- pretrained_model_name_or_path (
str或os.PathLike) — 可以是以下之一：- 一个字符串，即托管在 huggingface.co 上的模型仓库内的预训练 feature_extractor 的模型 ID。
- 一个目录的路径，其中包含使用 save_pretrained() 方法保存的特征提取器文件，例如，
./my_model_directory/。 - 已保存的特征提取器 JSON 文件的路径或 URL，例如，
./my_model_directory/preprocessor_config.json。
- **kwargs — 传递给 from_pretrained() 和
~tokenization_utils_base.PreTrainedTokenizer.from_pretrained的其他关键字参数。
实例化与预训练模型关联的处理器。
此类方法只是调用特征提取器 from_pretrained()、图像处理器 ImageProcessingMixin 和分词器 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 方法。 有关更多信息，请参阅上述方法的文档字符串。
save_pretrained
< source >( save_directory push_to_hub: bool = False **kwargs )
参数
- save_directory (
str或os.PathLike) — 将在其中保存特征提取器 JSON 文件和分词器文件的目录（如果目录不存在，则会创建）。 - push_to_hub (
bool, 可选, 默认为False) — 是否在保存模型后将其推送到 Hugging Face 模型 Hub。 您可以使用repo_id指定要推送到的存储库（默认为您命名空间中save_directory的名称）。 - kwargs (
Dict[str, Any], 可选) — 传递给 push_to_hub() 方法的其他关键字参数。
将此处理器（特征提取器、分词器...）的属性保存在指定目录中，以便可以使用 from_pretrained() 方法重新加载它。
此类方法只是调用 save_pretrained() 和 save_pretrained()。 有关更多信息，请参阅上述方法的文档字符串。
此方法将其所有参数转发到 SpeechT5Tokenizer 的 batch_decode()。 有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 SpeechT5Tokenizer 的 decode()。 有关更多信息，请参阅此方法的文档字符串。
SpeechT5Model
class transformers.SpeechT5Model
< source >( config: SpeechT5Config encoder: typing.Optional[torch.nn.modules.module.Module] = None decoder: typing.Optional[torch.nn.modules.module.Module] = 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
< source >( input_values: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_values: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None use_cache: typing.Optional[bool] = None speaker_embeddings: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- 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是否填充而略有不同。 - 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 表示头 未被掩盖，
- 0 表示头 被掩盖。
- 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(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 (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，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - input_values (
torch.Tensor，形状为(batch_size, sequence_length)) — 根据正在使用的编码器，input_values可以是：原始语音波形的浮点值，或词汇表中输入序列标记的索引，或隐藏状态。 - decoder_input_values (
torch.Tensor，形状为(batch_size, target_sequence_length)，可选) — 根据正在使用的解码器，decoder_input_values可以是：从原始语音波形中提取的 log-mel 滤波器组特征的浮点值，或词汇表中解码器输入序列标记的索引，或隐藏状态。 - speaker_embeddings (
torch.FloatTensor，形状为(batch_size, config.speaker_embedding_dim)，可选) — 包含说话人嵌入的张量。
返回值
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqModelOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (SpeechT5Config) 和输入。
-
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的输出处的隐藏状态序列。如果使用
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(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时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每层输出处的隐藏状态，加上可选的初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每层输出处的隐藏状态，加上可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
SpeechT5Model forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
SpeechT5ForSpeechToText
class transformers.SpeechT5ForSpeechToText
< source >( config: SpeechT5Config )
参数
- config (SpeechT5Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有语音编码器和文本解码器的 SpeechT5 模型。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如，下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取与常规用法和行为相关的所有事项。
forward
< source >( input_values: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- attention_mask (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于避免在 padding token 索引上执行卷积和注意力机制的掩码。掩码值在[0, 1]中选择：- 1 表示 token 未被掩盖，
- 0 表示 token 已被掩盖。
只有当相应的 processor 具有
config.return_attention_mask == True时，才应传递attention_mask。对于所有 processor 具有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中的 padding token。默认情况下，也会使用因果掩码。如果您想更改 padding 行为，则应阅读
SpeechT5Decoder._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)的torch.FloatTensor, 可选) — 用于置空编码器中注意力模块的选定 head 的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.FloatTensor, 可选) — 用于置空解码器中注意力模块的选定 head 的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor, 可选) — 用于置空交叉注意力模块的选定 head 的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), 可选) — 由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成的元组。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state（可选）是编码器最后一层的输出处的隐藏状态序列。在解码器的交叉注意力中使用。 - 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类型的数组中来获得，例如 通过 soundfile 库 (pip install soundfile)。为了将数组准备为input_values，应使用 SpeechT5Processor 进行填充并转换为torch.FloatTensor类型的张量。有关详细信息，请参见 SpeechT5Processor.call()。 - decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor, 可选) — 词汇表中解码器输入序列 token 的索引。索引可以使用 SpeechT5Tokenizer 获得。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
SpeechT5 使用
eos_token_id作为decoder_input_ids生成的起始 token。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于计算语言建模损失的标签。索引应为[0, ..., config.vocab_size]或 -100 (请参阅input_ids文档字符串)。索引设置为-100的 token 将被忽略（掩盖），损失仅针对标签在[0, ..., config.vocab_size]中的 token 计算。标签索引可以使用 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 (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — 语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模 head 的预测分数（SoftMax 之前每个词汇表 token 的分数）。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(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时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
SpeechT5ForSpeechToText forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import SpeechT5Processor, SpeechT5ForSpeechToText
>>> from datasets import load_dataset
>>> dataset = load_dataset(
... "hf-internal-testing/librispeech_asr_demo", "clean", split="validation", trust_remote_code=True
... ) # 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'SpeechT5ForTextToSpeech
class transformers.SpeechT5ForTextToSpeech
< source >( config: SpeechT5Config )
参数
- config (SpeechT5Config) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，而只会加载配置。查看 from_pretrained() 方法来加载模型权重。
带有文本编码器和语音解码器的 SpeechT5 模型。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_values: typing.Optional[torch.FloatTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None speaker_embeddings: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.FloatTensor] = None stop_labels: typing.Optional[torch.Tensor] = None ) → transformers.modeling_outputs.Seq2SeqSpectrogramOutput 或 tuple(torch.FloatTensor)
参数
- attention_mask (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于避免在 padding token 索引上执行卷积和注意力机制的掩码。掩码值在[0, 1]中选择：- 1 表示 token 未被掩盖，
- 0 表示 token 已被掩盖。
只有当相应的 processor 具有
config.return_attention_mask == True时，才应传递attention_mask。对于所有 processor 具有config.return_attention_mask == False的模型，不应传递attention_mask，以避免在进行批量推理时性能下降。对于此类模型，input_values应仅使用 0 进行填充，并在不使用attention_mask的情况下传递。请注意，这些模型也会根据input_values是否填充而产生略有不同的结果。 - decoder_attention_mask (
torch.LongTensorof shape(batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，该张量忽略decoder_input_values中的 pad 标记。默认情况下，也会使用因果掩码。如果您想更改 padding 行为，您应该阅读
SpeechT5Decoder._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参见论文中的图 1。 - head_mask (
torch.FloatTensorof shape(encoder_layers, encoder_attention_heads), optional) — 用于置空编码器中注意力模块的选定 head 的掩码。在[0, 1]中选择掩码值：- 1 表示 head 不被掩蔽，
- 0 表示 head 被掩蔽。
- decoder_head_mask (
torch.FloatTensorof shape(decoder_layers, decoder_attention_heads), optional) — 用于置空解码器中注意力模块的选定 head 的掩码。在[0, 1]中选择掩码值：- 1 表示 head 不被掩蔽，
- 0 表示 head 被掩蔽。
- cross_attn_head_mask (
torch.Tensorof shape(decoder_layers, decoder_attention_heads), optional) — 用于置空交叉注意力模块的选定 head 的掩码。在[0, 1]中选择掩码值：- 1 表示 head 不被掩蔽，
- 0 表示 head 被掩蔽。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), optional) — 由 (last_hidden_state, optional:hidden_states, optional:attentions) 组成的元组。last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，optional) 是编码器最后一层的输出处的隐藏状态序列。在解码器的交叉注意力中使用。 - past_key_values (
tuple(tuple(torch.FloatTensor)), optional, returned whenuse_cache=Trueis passed or whenconfig.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 (torch.FloatTensorof shape(batch_size, target_sequence_length, hidden_size), optional): 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_values。如果使用past_key_values，则可以选择仅输入最后一次的decoder_inputs_embeds（参见past_key_values）。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将decoder_input_values索引转换为关联向量，这将非常有用。 - use_cache (
bool, optional) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。 - input_ids (
torch.LongTensorof shape(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。索引可以使用 SpeechT5Tokenizer 获得。 有关详细信息，请参见 encode() 和 call()。
- decoder_input_values (
torch.FloatTensorof shape(batch_size, sequence_length, config.num_mel_bins)) — 输入梅尔频谱的浮点值。SpeechT5 使用全零频谱作为
decoder_input_values生成的起始标记。如果使用past_key_values，则可以选择仅输入最后一次的decoder_input_values（参见past_key_values）。 - speaker_embeddings (
torch.FloatTensorof shape(batch_size, config.speaker_embedding_dim), optional) — 包含说话人嵌入的张量。 - labels (
torch.FloatTensorof shape(batch_size, sequence_length, config.num_mel_bins), optional) — 目标梅尔频谱的浮点值。设置为-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 (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 频谱生成损失。 -
spectrogram (
torch.FloatTensorof shape(batch_size, sequence_length, num_bins)) — 预测的频谱。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(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时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
SpeechT5ForTextToSpeech forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应调用 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=speaker_embeddings, vocoder=vocoder)
>>> speech.shape
torch.Size([15872])generate
< source >( input_ids: LongTensor attention_mask: typing.Optional[torch.LongTensor] = None speaker_embeddings: typing.Optional[torch.FloatTensor] = None threshold: float = 0.5 minlenratio: float = 0.0 maxlenratio: float = 20.0 vocoder: typing.Optional[torch.nn.modules.module.Module] = None output_cross_attentions: bool = False return_output_lengths: bool = False **kwargs ) → tuple(torch.FloatTensor) comprising various elements depending on the inputs
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。索引可以使用 SpeechT5Tokenizer 获得。 有关详细信息，请参见 encode() 和 call()。
- attention_mask (
torch.LongTensorof shape(batch_size, sequence_length)) — 来自 tokenizer 的注意力掩码，批量推理时需要它来向模型指示忽略来自 input_ids 的 padding 标记。 - speaker_embeddings (
torch.FloatTensorof shape(batch_size, config.speaker_embedding_dim), optional) — 包含说话人嵌入的张量。 - threshold (
float, optional, defaults to 0.5) — 当预测的停止标记概率超过此值时，生成的序列结束。 - minlenratio (
float, optional, defaults to 0.0) — 用于计算输出序列的最小所需长度。 - maxlenratio (
float, optional, defaults to 20.0) — 用于计算输出序列的最大允许长度。 - vocoder (
nn.Module, optional) — 将梅尔频谱转换为语音波形的声码器。 如果为None，则输出为梅尔频谱。 - output_cross_attentions (
bool, optional, defaults toFalse) — 是否返回解码器的交叉注意力层的注意力张量。 - return_output_lengths (
bool, 可选, 默认为False) — 是否返回具体的频谱图/波形长度。
返回值
tuple(torch.FloatTensor)，包含取决于输入的各种元素
- 当
return_output_lengths为 False 时- spectrogram (可选, 当未提供
vocoder时返回)torch.FloatTensor，形状为(output_sequence_length, config.num_mel_bins)— 预测的 log-mel 频谱图。 - 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)— 解码器交叉注意力层的输出。
- spectrogram (可选, 当未提供
- 当
return_output_lengths为 True 时- spectrograms (可选, 当未提供
vocoder时返回)torch.FloatTensor，形状为(batch_size, output_sequence_length, config.num_mel_bins)— 预测的 log-mel 频谱图，已填充到最大长度。 - 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)— 解码器交叉注意力层的输出。
- spectrograms (可选, 当未提供
将输入 tokens 序列转换为 mel 频谱图序列，然后使用声码器将频谱图转换为语音波形。
SpeechT5ForSpeechToSpeech
class transformers.SpeechT5ForSpeechToSpeech
< source >( config: SpeechT5Config )
参数
- config (SpeechT5Config) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有语音编码器和语音解码器的 SpeechT5 模型。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取与常规用法和行为相关的所有事项。
forward
< source >( input_values: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_values: typing.Optional[torch.FloatTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None speaker_embeddings: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.FloatTensor] = None stop_labels: typing.Optional[torch.Tensor] = None ) → transformers.modeling_outputs.Seq2SeqSpectrogramOutput 或 tuple(torch.FloatTensor)
参数
- attention_mask (
torch.LongTensor，形状为(batch_size, sequence_length), 可选) — 掩码，用于避免在 padding token 索引上执行卷积和注意力机制。掩码值在[0, 1]中选择：- 1 表示 token 未被掩码，
- 0 表示 token 已被掩码。
只有当相应的 processor 的
config.return_attention_mask == True时，才应传递attention_mask。 对于所有 processor 的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中 pad tokens 的 tensor。默认情况下也会使用因果掩码。如果要更改 padding 行为，您应该阅读
SpeechT5Decoder._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。 - head_mask (
torch.FloatTensor，形状为(encoder_layers, encoder_attention_heads), 可选) — 掩码，用于 nullify 编码器中注意力模块的选定 head。掩码值在[0, 1]中选择：- 1 表示 head 未被掩码，
- 0 表示 head 已被掩码。
- decoder_head_mask (
torch.FloatTensor，形状为(decoder_layers, decoder_attention_heads), 可选) — 掩码，用于 nullify 解码器中注意力模块的选定 head。掩码值在[0, 1]中选择：- 1 表示 head 未被掩码，
- 0 表示 head 已被掩码。
- cross_attn_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — 掩码，用于 nullify 交叉注意力模块的选定 head。掩码值在[0, 1]中选择：- 1 表示 head 未被掩码，
- 0 表示 head 已被掩码。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), 可选) — Tuple 由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成。last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层的输出处的 hidden-states 序列。在解码器的交叉注意力中使用。 - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或config.use_cache=True时返回) —tuple(torch.FloatTensor)的 tuple，长度为config.n_layers，每个 tuple 有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的 tensors 和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的额外 tensors。包含预先计算的 hidden-states（自注意力模块和交叉注意力模块中的 key 和 values），可用于（参见
past_key_values输入）加速顺序解码。如果使用
past_key_values，用户可以选择仅输入最后一次的decoder_input_values（那些没有将其过去的 key value states 提供给此模型的），形状为(batch_size, 1)，而不是所有形状为(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_valueskey value states，并可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的 attentions tensors。有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通的 tuple。 - input_values (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 输入原始语音波形的浮点值。值可以通过将 .flac 或 .wav 音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如 通过 soundfile 库 (pip install soundfile)。为了将数组准备为input_values，应使用 SpeechT5Processor 进行 padding 并转换为torch.FloatTensor类型的 tensor。 有关详细信息，请参见 SpeechT5Processor.call()。 - decoder_input_values (
torch.FloatTensor，形状为(batch_size, sequence_length, config.num_mel_bins)) — 输入 mel 频谱图的浮点值。SpeechT5 使用全零频谱作为
decoder_input_values生成的起始 token。如果使用past_key_values，则可以选择仅输入最后一次的decoder_input_values（参见past_key_values）。 - speaker_embeddings (
torch.FloatTensor，形状为(batch_size, config.speaker_embedding_dim), 可选) — 包含说话人嵌入的 Tensor。 - labels (
torch.FloatTensor，形状为(batch_size, sequence_length, config.num_mel_bins), 可选) — 目标 mel 频谱图的浮点值。频谱图可以使用 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.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 频谱生成损失。 -
spectrogram (
torch.FloatTensorof shape(batch_size, sequence_length, num_bins)) — 预测的频谱。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(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时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出处的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
SpeechT5ForSpeechToSpeech 的 forward 方法覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但之后应调用 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", trust_remote_code=True
... ) # 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
< source >( input_values: FloatTensor speaker_embeddings: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None threshold: float = 0.5 minlenratio: float = 0.0 maxlenratio: float = 20.0 vocoder: typing.Optional[torch.nn.modules.module.Module] = None output_cross_attentions: bool = False return_output_lengths: bool = False ) → tuple(torch.FloatTensor) 包括各种元素，具体取决于输入
参数
- input_values (形状为
(batch_size, sequence_length)的torch.FloatTensor) — 输入原始语音波形的浮点值。这些值可以通过将 .flac 或 .wav 音频文件加载到
List[float]类型的数组或numpy.ndarray中获得，例如，通过 soundfile 库 (pip install soundfile)。为了将数组准备为input_values，应该使用 SpeechT5Processor 进行填充并转换为torch.FloatTensor类型的张量。 有关详细信息，请参阅 SpeechT5Processor.call()。 - speaker_embeddings (形状为
(batch_size, config.speaker_embedding_dim)的torch.FloatTensor, 可选) — 包含说话人嵌入的张量。 - attention_mask (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于避免在填充 token 索引上执行卷积和注意力的掩码。 掩码值在[0, 1]中选择：- 1 表示 未被掩盖 的 token，
- 0 表示 被掩盖 的 token。
- threshold (
float, 可选, 默认为 0.5) — 当预测的停止 token 概率超过此值时，生成的序列结束。 - minlenratio (
float, 可选, 默认为 0.0) — 用于计算输出序列的最小所需长度。 - maxlenratio (
float, 可选, 默认为 20.0) — 用于计算输出序列的最大允许长度。 - vocoder (
nn.Module, 可选, 默认为None) — 将梅尔频谱图转换为语音波形的声码器。 如果为None，则输出为梅尔频谱图。 - output_cross_attentions (
bool, 可选, 默认为False) — 是否返回解码器交叉注意力层的注意力张量。 - return_output_lengths (
bool, 可选, 默认为False) — 是否返回具体的频谱图/波形长度。
返回值
tuple(torch.FloatTensor)，包含取决于输入的各种元素
- 当
return_output_lengths为 False 时- spectrogram (可选, 当未提供
vocoder时返回)torch.FloatTensor，形状为(output_sequence_length, config.num_mel_bins)— 预测的 log-mel 频谱图。 - 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)— 解码器交叉注意力层的输出。
- spectrogram (可选, 当未提供
- 当
return_output_lengths为 True 时- spectrograms (可选, 当未提供
vocoder时返回)torch.FloatTensor，形状为(batch_size, output_sequence_length, config.num_mel_bins)— 预测的 log-mel 频谱图，已填充到最大长度。 - 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)— 解码器交叉注意力层的输出。
- spectrograms (可选, 当未提供
将原始语音波形转换为梅尔频谱图序列，然后使用声码器将梅尔频谱图序列转换回语音波形。
SpeechT5HifiGan
class transformers.SpeechT5HifiGan
< source >( config: SpeechT5HifiGanConfig )
参数
- config (SpeechT5HifiGanConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
HiFi-GAN 声码器。 此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取与常规用法和行为相关的所有事项。
forward
< source >( spectrogram: FloatTensor ) → torch.FloatTensor
将对数梅尔频谱图转换为语音波形。 传递一批对数梅尔频谱图将返回一批语音波形。 传递单个、非批处理的对数梅尔频谱图将返回单个、非批处理的语音波形。