Hugging Face's logo

Transformers documentation

SpeechT5

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2021-10-14 在 HF papers 上发布，并于 2023-02-03 贡献至 Hugging Face Transformers。

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（Text-To-Text Transfer Transformer）在预训练自然语言处理模型中取得成功的启发，我们提出了一个统一模态的 SpeechT5 框架，该框架探索了用于自监督语音/文本表示学习的编码器-解码器预训练。SpeechT5 框架由一个共享的编码器-解码器网络和六个模态特定（语音/文本）的前置/后置网络组成。在通过前置网络对输入语音/文本进行预处理后，共享的编码器-解码器网络对序列到序列的转换进行建模，随后后置网络基于解码器的输出，在语音/文本模态下生成输出。利用大规模无标签语音和文本数据，我们对 SpeechT5 进行预训练以学习统一模态的表示，期望提升对语音和文本的建模能力。为了将文本和语音信息对齐到这一统一语义空间中，我们提出了一种跨模态向量量化方法，该方法随机混合语音/文本状态与潜在单元，作为编码器与解码器之间的接口。大量评估表明，所提出的 SpeechT5 框架在多种口语语言处理任务上均表现出优越性，包括自动语音识别、语音合成、语音翻译、语音转换、语音增强和说话人识别。

该模型由 Matthijs 贡献。原始代码可在此处找到。

在 from_pretrained() 中设置 use_kernels=True，即可用 Hub 上的优化内核替换受支持的层。有关详细信息，请参阅 加载内核。

SpeechT5Config

class transformers.SpeechT5Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 81hidden_size: int = 768encoder_layers: int = 12encoder_attention_heads: int = 12encoder_ffn_dim: int = 3072encoder_layerdrop: float | int = 0.1decoder_layers: int = 6decoder_ffn_dim: int = 3072decoder_attention_heads: int = 12decoder_layerdrop: float | int = 0.1hidden_act: str = 'gelu'positional_dropout: float | int = 0.1hidden_dropout: float | int = 0.1attention_dropout: float | int = 0.1activation_dropout: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05scale_embedding: bool = Falsefeat_extract_norm: str = 'group'feat_proj_dropout: float | int = 0.0feat_extract_activation: str = 'gelu'conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)conv_bias: bool = Falsenum_conv_pos_embeddings: int = 128num_conv_pos_embedding_groups: int = 16apply_spec_augment: bool = Truemask_time_prob: float | int = 0.05mask_time_length: int = 10mask_time_min_masks: int = 2mask_feature_prob: float | int = 0.0mask_feature_length: int = 10mask_feature_min_masks: int = 0pad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2decoder_start_token_id: int | None = 2num_mel_bins: int = 80speech_decoder_prenet_layers: int = 2speech_decoder_prenet_units: int = 256speech_decoder_prenet_dropout: float | int = 0.5speaker_embedding_dim: int = 512speech_decoder_postnet_layers: int = 5speech_decoder_postnet_units: int = 256speech_decoder_postnet_kernel: int = 5speech_decoder_postnet_dropout: float | int = 0.5reduction_factor: int = 2max_speech_positions: int = 4000max_text_positions: int = 450encoder_max_relative_position: int = 160use_guided_attention_loss: bool = Trueguided_attention_loss_num_heads: int = 2guided_attention_loss_sigma: float = 0.4guided_attention_loss_scale: float = 10.0use_cache: bool = Truetie_word_embeddings: bool = True )

参数

  • is_encoder_decoder (bool，可选，默认为 True) — 指示该模型是否用作编码器/解码器。
  • vocab_size (int，可选，默认为 81) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 的数量。
  • hidden_size (int，可选，默认为 768) — 隐藏表示的维度。
  • encoder_layers (int，可选，默认为 12) — Transformer 编码器中的隐藏层数量。如果未设置，将使用与 num_layers 相同的值。
  • encoder_attention_heads (int，可选，默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • encoder_ffn_dim (int，可选，默认为 3072) — 编码器中“中间”（通常称为前馈）层的维度。
  • encoder_layerdrop (Union[float, int]，可选，默认值为 0.1) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](参见 https://huggingface.co/papers/1909.11556)。
  • decoder_layers (int, 可选，默认为 6) — Transformer 解码器中的隐藏层数量。如果未设置，将使用与 num_layers 相同的值。
  • decoder_ffn_dim (int，可选，默认为 3072) — 解码器中“中间”（通常称为前馈）层的维度。
  • decoder_attention_heads (int，可选，默认为 12) — Transformer 解码器中每个注意力层的注意力头数量。
  • decoder_layerdrop (Union[float, int]，可选，默认值为 0.1) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 [LayerDrop 论文](参见 https://huggingface.co/papers/1909.11556)。
  • hidden_act (str，可选，默认为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
  • positional_dropout (float，可选，默认为 0.1) — 文本位置编码层的 dropout 概率。
  • hidden_dropout (Union[float, int]，可选，默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。
  • attention_dropout (Union[float, int]，可选，默认为 0.1) — 注意力概率的 dropout 比率。
  • activation_dropout (Union[float, int]，可选，默认为 0.1) — 全连接层内部激活值的 dropout 比率。
  • initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float，可选，默认为 1e-05) — 层归一化层所使用的 epsilon 值。
  • scale_embedding (bool，可选，默认为 False) — 是否通过将嵌入除以 sqrt(d_model) 来对嵌入进行缩放。
  • feat_extract_norm (str，可选，默认为 "group") — 应用于语音编码器前置网络中一维卷积层的归一化方式。取值为 "group" 表示仅对第一个一维卷积层进行组归一化，或 "layer" 表示对所有的一维卷积层进行层归一化。
  • feat_proj_dropout (float, 可选，默认值为 0.0) — 语音编码器前置网络的输出 dropout 概率。
  • feat_extract_activation (str, optional, defaults to “gelu”) -- The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, “gelu”, “relu”, “selu”and“gelu_new”` are supported.
  • conv_dim (tuple[int] 或 list[int]，可选，默认为 (512, 512, 512, 512, 512, 512, 512)) — 一个整数元组，用于定义语音编码器前置网络中每个一维卷积层的输入和输出通道数。conv_dim 的长度决定了一维卷积层的数量。
  • conv_stride (tuple[int] 或 list[int]，可选，默认为 (5, 2, 2, 2, 2, 2, 2)) — 一个整数元组，用于定义语音编码器前置网络中每个一维卷积层的步长。conv_stride 的长度决定了卷积层的数量，并且必须与 conv_dim 的长度相匹配。
  • conv_kernel (tuple[int] 或 list[int]，可选，默认为 (10, 3, 3, 3, 3, 3, 3)) — 一个整数元组，用于定义语音编码器前置网络中每个一维卷积层的卷积核大小。 conv_kernel 的长度定义了卷积层的数量，并且必须与 conv_dim 的长度相匹配。
  • conv_bias (bool，可选，默认为 False) — 一维卷积层是否包含偏置。
  • num_conv_pos_embeddings (int，可选，默认为 128) — 卷积位置嵌入的数量。定义一维卷积位置嵌入层的核大小。
  • num_conv_pos_embedding_groups (int，可选，默认为 16) — 一维卷积位置嵌入层的组数。
  • apply_spec_augment (bool，可选，默认为 True) — 是否对语音编码器前置网络的输出应用 SpecAugment 数据增强。参考 SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。
  • mask_time_prob (float, optional, defaults to 0.05) — Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking procedure generates ”mask_time_problen(time_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_time_prob should be `prob_vector_startmask_time_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if apply_spec_augment is True`.
  • mask_time_length (int，可选，默认为 10) — 沿时间轴方向的向量跨度长度。
  • mask_time_min_masks (int，可选，默认为 2)，— 沿时间轴生成的、长度为 mask_feature_length 的最小掩码数量，针对每个时间步，且不考虑 mask_feature_prob。仅当 “mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks” 时相关
  • mask_feature_prob (float, optional, defaults to 0.0) — Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The masking procedure generates ”mask_feature_problen(feature_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_feature_prob should be `prob_vector_startmask_feature_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if apply_spec_augment is True`.
  • mask_feature_prob (Union[float, int]，可选，默认值为 0.0) — 沿特征轴被掩码的所有特征向量的百分比（介于 0 和 1 之间）。掩码过程会在该轴上生成 mask_feature_prob*len(feature_axis)/mask_time_length 个独立的掩码。如果从每个特征向量被选为待掩码向量跨度起点的概率来推导，mask_feature_prob 应为 prob_vector_start*mask_feature_length。请注意，重叠可能会降低实际被掩码的向量百分比。仅当 apply_spec_augment 为 True 时，此参数才相关。
  • mask_feature_length (int，可选，默认为 10) — 沿特征轴方向的向量跨度长度。
  • mask_feature_min_masks (int，可选，默认为 0)，— 沿特征轴生成的、长度为 mask_feature_length 的掩码的最小数量，每个时间步均适用，与 mask_feature_prob 无关。仅当 “mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks” 时相关。
  • num_mel_bins (int, 可选，默认为 80) — 每个输入特征所使用的 mel 特征数量。由语音解码器的前置网络使用。应与 SpeechT5Processor 类中使用的值相对应。
  • pad_token_id (int，可选，默认为 1) — 词表中用于填充的 token id。
  • bos_token_id (int，可选，默认为 0) — 词汇表中用于表示流起始的 Token id。
  • eos_token_id (Union[int, list[int]]，可选，默认为 2) — 词汇表中用于表示流结束（end-of-stream）的 token id。
  • decoder_start_token_id (int，可选，默认为 2) — 如果编码器-解码器模型使用不同于 bos 的 token 开始解码，则指定该 token 的 id。
  • num_mel_bins (int，可选，默认为 80) — 每个输入帧使用的 mel 特征数量。应与 AutoFeatureExtractor 类中使用的值相对应。
  • 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) — 语音解码器后网络（post-net）的层数。
  • 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) — 模型是否应返回最后一次键/值注意力（并非所有模型都使用）。仅当 config.is_decoder=True 或模型为仅解码器生成式模型时相关。
  • tie_word_embeddings (bool，可选，默认为 True) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。

这是用于存储 SpeechT5Model 配置的类。它根据指定的参数实例化 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

类 transformers.SpeechT5HifiGanConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonemodel_in_dim: int = 80sampling_rate: int = 16000upsample_initial_channel: int = 512upsample_rates: list[int] | tuple[int, ...] = (4, 4, 4, 4)upsample_kernel_sizes: list[int] | tuple[int, ...] = (8, 8, 8, 8)resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11)resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5))initializer_range: float = 0.01leaky_relu_slope: float = 0.1normalize_before: bool = True )

参数

  • model_in_dim (int，可选，默认为 80) — 输入对数梅尔频谱图中的频率分箱数量。
  • sampling_rate (int，可选，默认为 16000) — 音频文件应被数字化时的采样率，以赫兹（Hz）为单位。
  • upsample_initial_channel (int, 可选，默认为 512) — 上采样网络的输入通道数。
  • upsample_rates (tuple[int] 或 list[int]，可选，默认为 [4, 4, 4, 4]) — 一个整数元组，用于定义上采样网络中每个一维卷积层的步长。upsample_rates 的长度定义了卷积层的数量，并且必须与 upsample_kernel_sizes 的长度相匹配。
  • upsample_kernel_sizes (tuple[int] 或 list[int]，可选，默认为 [8, 8, 8, 8]) — 一个整数元组，用于定义上采样网络中每个一维卷积层的卷积核大小。upsample_kernel_sizes 的长度定义了卷积层的数量，并且必须与 upsample_rates 的长度相匹配。
  • resblock_kernel_sizes (tuple[int] 或 list[int]，可选，默认为 [3, 7, 11]) — 一个整数元组，用于定义多感受野融合（MRF）模块中一维卷积层的卷积核大小。
  • resblock_dilation_sizes (tuple[tuple[int]] 或 list[list[int]]，可选，默认为 [[1, 3, 5], [1, 3, 5], [1, 3, 5]]) — 一个嵌套的整数元组，用于定义多感受野融合（MRF）模块中膨胀一维卷积层的膨胀率。
  • initializer_range (float，可选，默认为 0.01) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • leaky_relu_slope (float，可选，默认为 0.1) — Leaky ReLU 激活函数所使用的负斜率角度。
  • normalize_before (bool，可选，默认为 True) — 是否在使用声码器进行声码化之前，利用声码器学习到的均值和方差对频谱图进行归一化。

这是用于存储 SpeechT5Model 配置的类。它根据指定的参数实例化 Speecht5 模型，并定义模型架构。使用默认值实例化配置，将得到与 microsoft/speecht5_asr 类似的配置。

配置对象继承自 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_filebos_token = '<s>'eos_token = '</s>'unk_token = '<unk>'pad_token = '<pad>'normalize = Falsesp_model_kwargs: dict[str, typing.Any] | None = 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：用于一元采样（unigram sampling）的平滑参数，以及 BPE-dropout 中合并操作的 dropout 概率。

  • sp_model (SentencePieceProcessor) — 用于所有转换（字符串、token 和 ID）的 SentencePiece 处理器。

构建 SpeechT5 分词器。基于 SentencePiece。

该分词器继承自 PreTrainedTokenizer，其中包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。

__call__

< >

( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**kwargs ) → BatchEncoding

参数

  • text (str、list[str]、list[list[str]]、可选) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果以字符串列表（预分词）形式提供序列，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
  • text_pair (str、list[str]、list[list[str]]、可选) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果以字符串列表（预分词）形式提供序列，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
  • text_target (str、list[str]、list[list[str]]、可选) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果以字符串列表（预分词）的形式提供序列，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
  • text_pair_target (str、list[str]、list[list[str]]、可选) — 要编码为目标文本的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）的形式提供，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。
  • tokenizer_kwargs (dict[str, Any], 可选) — 传递给 tokenizer 的额外 kwargs。这些 kwargs 将与显式参数及其他 kwargs 合并，其中显式参数具有更高的优先级。
  • add_special_tokens (bool，可选，默认为 True) — 在编码序列时是否添加特殊标记。此操作将使用底层的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函数，该函数定义了哪些标记会自动添加到输入 ID 中。如果您希望自动添加 bos 或 eos 标记，此功能非常有用。
  • padding (bool, str 或 PaddingStrategy, ，可选, ，默认为 False) — 启用并控制填充。接受以下值：
    • True 或 'longest'：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。
    • 'max_length'：填充至由参数 max_length 指定的最大长度；若未提供该参数，则填充至模型可接受的最大输入长度。
    • False 或 'do_not_pad'（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。
  • truncation (bool, str 或 TruncationStrategy, ，可选, ，默认为 False) — 启用并控制截断。接受以下值：
    • True 或 'longest_first'：截断至由参数 max_length 指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一批序列对），则会从该对中最长的序列中移除一个 token。
    • 'only_first'：截断至由参数 max_length 指定的最大长度，或者在未提供该参数时，截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断其中的第一个序列。
    • 'only_second'：截断至由参数 max_length 指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。仅当提供了一对序列（或一批序列对）时，才会截断其中的第二个序列。
    • False 或 'do_not_truncate'（默认值）：不进行截断（即，可以输出序列长度大于模型最大可接受输入大小的批次）。
  • max_length (int, 可选) — 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 None，则当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（如 XLNet），则禁用截断/填充到最大长度的功能。

    如果未设置或设置为 None，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。

  • stride (int，可选，默认为 0) — 如果与 max_length 一起设置为某个数值，则当 return_overflowing_tokens=True 时，返回的溢出 token 将包含截断序列末尾的若干 token，以在截断序列和溢出序列之间提供一定的重叠。此参数的值定义了重叠 token 的数量。
  • is_split_into_words (bool，可选，默认为 False) — 输入是否已经预先分词（例如，已拆分为单词）。如果设置为 True，分词器将假设输入已经拆分为单词（例如，通过按空白字符拆分），然后对其进行分词。这对于命名实体识别（NER）或 token 分类非常有用。
  • pad_to_multiple_of (int, 可选) — 如果设置，则将序列填充为所提供值的倍数。需要启用 padding。 这对于在计算能力为 >= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。
  • padding_side (str, 可选) — 模型应应用填充的一侧。应在 [‘right’, ‘left’] 之间进行选择。 默认值取自同名的类属性。
  • return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 Numpy np.ndarray 对象。
  • return_token_type_ids (bool, 可选) — 是否返回 token type ID。如果保持默认值，将根据特定分词器的默认设置返回 token type ID，该设置由 return_outputs 属性定义。

    什么是 token type ID？

  • return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果保持默认值，将根据特定分词器的默认设置返回注意力掩码，该设置由 return_outputs 属性定义。

    什么是注意力掩码？

  • return_overflowing_tokens (bool，可选，默认为 False) — 是否返回溢出的 token 序列。如果提供了输入 id 的序列对（或序列对批次），且 truncation_strategy = longest_first 或 True，则会抛出错误，而不是返回溢出的 token。
  • return_special_tokens_mask (bool，可选，默认为 False) — 是否返回特殊 token 掩码信息。
  • return_offsets_mapping (bool, 可选, 默认为 False) — 是否返回 (char_start, char_end) 每个 token 的。

    此功能仅在继承自 PreTrainedTokenizerFast 的快速分词器上可用。如果使用 Python 分词器，此方法将抛出 NotImplementedError。

  • return_length (bool，可选，默认为 False) — 是否返回编码后输入的长度。
  • verbose (bool，可选，默认为 True) — 是否打印更多信息和警告。
  • **kwargs — 传递给 self.tokenize() 方法

返回值

BatchEncoding

一个包含以下字段的 BatchEncoding：

  • input_ids — 要输入模型的 token id 列表。

    什么是输入 ID？

  • token_type_ids — 要输入模型的 token 类型 ID 列表（当 return_token_type_ids=True 或 self.model_input_names 中包含 “token_type_ids” 时）。

    什么是 token type ID？

  • attention_mask — 索引列表，指定模型应关注哪些 token（当 return_attention_mask=True 或 “attention_mask” 位于 self.model_input_names 中时）。

    什么是注意力掩码？

  • overflowing_tokens — 溢出 token 序列的列表（当指定了 max_length 且 return_overflowing_tokens=True 时）。

  • num_truncated_tokens — 被截断的 token 数量（当指定了 max_length 且 return_overflowing_tokens=True 时）。

  • special_tokens_mask — 由 0 和 1 组成的列表，其中 1 表示添加的特殊标记，0 表示常规序列标记（当 add_special_tokens=True 且 return_special_tokens_mask=True 时）。

  • length — 输入的长度（当 return_length=True 时）

用于对一条或多条序列，或一对或多对序列进行分词并准备输入模型的主要方法。

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None ) → tuple(str)

参数

  • save_directory (str) — 用于保存词汇表的目录。
  • filename_prefix (str, 可选) — 一个可选的前缀，用于添加到保存文件的名称中。

返回值

tuple(str)

已保存文件的路径。

将 sentencepiece 词表（复制原始文件）保存到一个目录中。

decode

< >

( token_ids: int | list[int] | list[list[int]] | np.ndarray | torch.Tensorskip_special_tokens: bool = False**kwargs ) → Union[str, list[str]]

参数

  • token_ids (Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]) — 单个序列或一批（序列列表）的标记化输入 ID。可通过 __call__ 方法获取。
  • skip_special_tokens（bool，可选，默认为 False）— 是否在解码过程中移除特殊标记。
  • kwargs（额外的关键字参数，可选） — 将传递给底层模型特定的解码方法。

返回值

Union[str, list[str]]

单个序列的解码字符串，或一批序列的解码字符串列表。

使用分词器和词汇表将 id 序列转换为字符串，或将序列列表转换为字符串列表，并支持移除特殊标记和清理分词空格等选项。

类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

batch_decode

< >

( sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensorskip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]

参数

  • sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — 分词后的输入 ID 列表。可通过 __call__ 方法获取。
  • skip_special_tokens（bool，可选，默认为 False）— 是否在解码过程中移除特殊标记。
  • clean_up_tokenization_spaces (bool, 可选) — 是否清理分词空格。如果为 None，则默认为 self.clean_up_tokenization_spaces。
  • kwargs（额外的关键字参数，可选） — 将传递给底层模型特定的解码方法。

返回值

list[str]

解码后的句子列表。

通过调用 decode，将 token id 的列表的列表转换为字符串列表。

此方法是为了向后兼容而提供的。decode 方法现在原生支持批量输入，因此您可以直接使用 decode 而无需使用 batch_decode。

SpeechT5FeatureExtractor

类 transformers.SpeechT5FeatureExtractor

< >

( feature_size: int = 1sampling_rate: int = 16000padding_value: float = 0.0do_normalize: bool = Falsenum_mel_bins: int = 80hop_length: int = 16win_length: int = 64win_function: str = 'hann_window'fmin: float = 80fmax: float = 7600mel_floor: float = 1e-10return_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) — 提取的频谱特征中梅尔频率分箱的数量。
  • hop_length (int，可选，默认为 16) — 窗口之间的毫秒数。在许多论文中也被称为“shift”。
  • win_length (int，可选，默认为 64) — 每个窗口的毫秒数。
  • win_function (str，可选，默认为 "hann_window") — 用于加窗的窗函数名称，必须可通过 torch.{win_function} 访问
  • fmin (float，可选，默认值为 80) — 最小梅尔频率，单位为 Hz。
  • fmax (float，可选，默认值为 7600) — 最大 mel 频率，单位为 Hz。
  • mel_floor (float，可选，默认为 1e-10) — 梅尔频率银行的最低值。
  • return_attention_mask (bool，可选，默认为 True) — 是否让 call() 返回 attention_mask。

构建 SpeechT5 特征提取器。

此类可对原始语音信号进行预处理（可选地将其归一化为零均值、单位方差），供 SpeechT5 语音编码器前馈网络使用。

此类还可以从原始语音中提取对数梅尔滤波器组特征，供 SpeechT5 语音解码器的 prenet 使用。

该特征提取器继承自 SequenceFeatureExtractor，其中包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。

__call__

< >

( audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]] | None = Noneaudio_target: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]] | None = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsemax_length: int | None = Nonetruncation: bool = Falsepad_to_multiple_of: int | None = Nonereturn_attention_mask: bool | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = None**kwargs )

参数

  • 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 数组列表或浮点值列表的列表。此参数输出对数梅尔频谱特征。
  • padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 选择一种策略，根据模型的填充侧和填充索引对返回的序列进行填充，可选策略如下：
    • True 或 'longest'：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。
    • 'max_length'：填充至由参数 max_length 指定的最大长度；若未提供该参数，则填充至模型可接受的最大输入长度。
    • False 或 'do_not_pad'（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。
  • max_length (int，可选) — 返回列表的最大长度，以及可选的填充长度（见上文）。
  • truncation (bool) — 启用截断，将长度超过 max_length 的输入序列截断为 max_length。
  • pad_to_multiple_of (int, 可选) — 如果设置，将把序列填充为所提供值的倍数。

    这在启用 NVIDIA 硬件（计算能力 >= 7.5，即 Volta 架构）上的 Tensor Cores 使用时尤为有用，或者在 TPU 上使用时也特别有益，因为 TPU 在序列长度为 128 的倍数时性能更佳。

  • return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果保持默认值，将根据特定 feature_extractor 的默认设置返回注意力掩码。

    什么是注意力掩码？

  • return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 Numpy np.ndarray 对象。
  • sampling_rate (int, 可选) — audio 或 audio_target 输入被采样时的采样率。强烈建议在 forward 调用时传入 sampling_rate，以防止出现静默错误。

用于对一条或多条序列进行特征化并准备输入模型的主要方法。

传入 audio 的值以提取波形特征。传入 audio_target 的值以提取对数梅尔频谱图特征。

SpeechT5Processor

class transformers.SpeechT5Processor

< >

( feature_extractortokenizer )

参数

  • feature_extractor (SpeechT5FeatureExtractor) — 特征提取器是必需的输入。
  • tokenizer（SpeechT5Tokenizer）— 分词器是必需的输入。

构建一个 SpeechT5Processor，它将特征提取器和分词器封装为单个处理器。

SpeechT5Processor 提供了 SpeechT5FeatureExtractor 和 SpeechT5Tokenizer 的所有功能。有关更多信息，请参阅 ~SpeechT5FeatureExtractor 和 ~SpeechT5Tokenizer。

__call__

< >

( *args**kwargs )

参数

  • return_tensors (str 或 TensorType, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 NumPy np.ndarray 对象。

填充

< >

( *args**kwargs )

将音频和文本输入及其对应的目标整理为填充后的批次。

音频输入由 SpeechT5FeatureExtractor 的 pad() 进行填充。文本输入由 SpeechT5Tokenizer 的 pad() 进行填充。

有效的输入组合为：

  • 仅 input_ids
  • 仅 input_values
  • labels，即对数梅尔频谱图或文本标记
  • input_ids 和对数梅尔频谱图 labels
  • input_values 和文本 labels

有关更多信息，请参阅上述两个方法的文档字符串。

from_pretrained

< >

( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )

参数

  • pretrained_model_name_or_path (str 或 os.PathLike) — 可以是以下之一：
    • 一个字符串，即托管在 huggingface.co 上某个模型仓库中的预训练 feature_extractor 的 model id。
    • 指向一个目录的路径，该目录包含使用 save_pretrained() 方法保存的特征提取器文件，例如 ./my_model_directory/。
    • 指向已保存的特征提取器 JSON 文件的路径，例如 ./my_model_directory/preprocessor_config.json。
  • **kwargs — 同时传递给 from_pretrained() 和 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 的额外关键字参数。

实例化与预训练模型关联的处理器。

此类的该方法只是调用了特征提取器的 from_pretrained()、图像处理器 ImageProcessingMixin 以及分词器的 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 方法。有关更多信息，请参阅上述方法的文档字符串。

save_pretrained

< >

( save_directorypush_to_hub: bool = False**kwargs )

参数

  • save_directory (str 或 os.PathLike) — 用于保存特征提取器 JSON 文件和分词器文件的目录（如果该目录不存在，则会自动创建）。
  • push_to_hub (bool，可选，默认为 False) — 是否在保存模型后将其推送到 Hugging Face 模型库。您可以使用 repo_id 指定要推送到的仓库（默认使用您命名空间中 save_directory 的名称）。
  • kwargs (dict[str, Any]，可选) — 传递给 push_to_hub() 方法的额外关键字参数。

将此处理器的属性（特征提取器、分词器……）保存到指定目录中，以便使用 from_pretrained() 方法重新加载。

此类的该方法只是调用了 save_pretrained() 和 save_pretrained()。有关更多信息，请参阅上述方法的文档字符串。

batch_decode

< >

( *args**kwargs )

此方法会将其所有参数转发给 PreTrainedTokenizer 的 batch_decode()。有关更多信息，请参阅该方法的文档字符串。

decode

< >

( *args**kwargs )

此方法会将其所有参数转发给 PreTrainedTokenizer 的 decode()。有关更多信息，请参阅该方法的文档字符串。

SpeechT5Model

类 transformers.SpeechT5Model

< >

( config: SpeechT5Configencoder: typing.Optional[torch.nn.Module] = Nonedecoder: typing.Optional[torch.nn.Module] = None )

参数

  • config (SpeechT5Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
  • encoder (PreTrainedModel，可选) — 要使用的编码器模型。
  • decoder (PreTrainedModel，可选) — 要使用的解码器模型。

原始的 SpeechT5 Encoder-Decoder 模型，直接输出原始隐藏状态，不包含任何特定的前置或后置网络。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_values: typing.Optional[torch.Tensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = Nonespeaker_embeddings: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → Seq2SeqModelOutput or tuple(torch.Tensor)

参数

  • input_values（形状为 (batch_size, sequence_length) 的 torch.Tensor）— 根据所使用的编码器，input_values 可以是：输入原始语音波形的浮点值、词汇表中输入序列令牌的索引，或隐藏状态。
  • attention_mask (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 [0, 1]：1 表示未屏蔽的标记，0 表示被屏蔽的标记。什么是注意力掩码？ [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • decoder_input_values (torch.Tensor，形状为 (batch_size, target_sequence_length)，可选) — 根据所使用的解码器，decoder_input_values 可以是：从原始语音波形中提取的 log-mel 滤波器组特征的浮点值、词汇表中解码器输入序列令牌的索引，或隐藏状态。
  • decoder_attention_mask (torch.LongTensor 形状为 (batch_size, target_sequence_length), ，可选) — 默认行为：生成一个张量，用于忽略 decoder_input_values. 中的填充标记。默认情况下还会使用因果掩码。

    如果您想更改填充（padding）行为，请阅读 SpeechT5Decoder._prepare_decoder_attention_mask 并根据需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。

  • encoder_outputs (tuple[tuple[torch.Tensor]]，可选) — 元组由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成 last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • speaker_embeddings (torch.Tensor，形状为 (batch_size, config.speaker_embedding_dim)，可选) — 包含说话人嵌入的张量。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

Seq2SeqModelOutput 或 tuple(torch.Tensor)

一个 Seq2SeqModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（SpeechT5Config）和输入。

SpeechT5Model 的 forward 方法会重写 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

  • last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor）— 模型解码器最后一层输出的隐藏状态序列。

    如果使用了 past_key_values，则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values（EncoderDecoderCache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(torch.Tensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

  • decoder_attentions (tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

  • cross_attentions (tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。

  • encoder_last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选）— 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.Tensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    编码器每层输出处的隐藏状态，以及可选的初始嵌入输出。

  • encoder_attentions（tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

SpeechT5ForSpeechToText

类 transformers.SpeechT5ForSpeechToText

< >

( config: SpeechT5Config )

参数

  • config (SpeechT5Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

SpeechT5 模型，包含语音编码器和文本解码器。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs ) → Seq2SeqLMOutput or tuple(torch.Tensor)

参数

  • input_values (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。可以通过将 .flac 或 .wav 音频文件加载为 list[float]、numpy.ndarray 或 torch.Tensor 类型的数组来获取这些值，例如 使用 torchcodec 库（pip install torchcodec）或 soundfile 库（pip install soundfile）。要将该数组准备为 input_values，应使用 SpeechT5Processor 进行填充并转换为 torch.Tensor 类型的张量。详情请参见 SpeechT5Processor.call()。
  • attention_mask (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 [0, 1]：1 表示未屏蔽的标记，0 表示被屏蔽的标记。什么是注意力掩码？ [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor 形状为 (batch_size, target_sequence_length), 可选) — 解码器输入序列中各 token 在词汇表中的索引。可通过 SpeechT5Tokenizer 获取这些索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是解码器输入 ID？SpeechT5 使用 eos_token_id 作为生成 decoder_input_ids 的起始 token。如果使用 past_key_values，则只需输入最后一个 decoder_input_ids（参见 past_key_values）。

    可以使用 SpeechT5Tokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    SpeechT5 使用 eos_token_id 作为 decoder_input_ids 生成的起始 token。如果使用了 past_key_values，则可以选择性地仅输入最后一个 decoder_input_ids（参见 past_key_values）。

  • decoder_attention_mask (torch.LongTensor 形状为 (batch_size, target_sequence_length), ，可选) — 默认行为：生成一个张量，用于忽略 decoder_input_values. 中的填充标记。默认情况下还会使用因果掩码。

    如果您想更改填充（padding）行为，请阅读 SpeechT5Decoder._prepare_decoder_attention_mask 并根据需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。

  • encoder_outputs (tuple[tuple[torch.Tensor]]，可选) — 元组由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成 last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • labels (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 用于计算语言建模损失的标签。索引值应在 [0, ..., config.vocab_size] 范围内，或为 -100（参见 input_ids 的文档字符串）。索引值设为 -100 的 token 将被忽略（屏蔽），损失仅针对标签在 [0, ..., config.vocab_size].

    标签索引可以使用 SpeechT5Tokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

返回值

Seq2SeqLMOutput 或 tuple(torch.Tensor)

一个 Seq2SeqLMOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（SpeechT5Config）和输入。

SpeechT5ForSpeechToText 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

  • loss（形状为 (1,) 的 torch.Tensor，可选，在提供 labels 时返回）— 语言建模损失。

  • logits（形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。

  • past_key_values（EncoderDecoderCache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(torch.Tensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出处的隐藏状态，以及初始嵌入输出。

  • decoder_attentions (tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

  • cross_attentions (tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。

  • encoder_last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选）— 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.Tensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出处的隐藏状态，以及初始嵌入输出。

  • encoder_attentions（tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

>>> from transformers import 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

类 transformers.SpeechT5ForTextToSpeech

< >

( config: SpeechT5Config )

参数

  • config (SpeechT5Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

带有文本编码器和语音解码器的 SpeechT5 模型。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_values: typing.Optional[torch.Tensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonespeaker_embeddings: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Nonestop_labels: typing.Optional[torch.Tensor] = None**kwargs ) → Seq2SeqSpectrogramOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 输入序列中各 token 在词汇表中的索引。

    可以使用 SpeechT5Tokenizer 获取索引。有关详细信息，请参阅 encode() 和 call()。

    什么是输入 ID？

  • attention_mask (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 [0, 1]：1 表示未屏蔽的标记，0 表示被屏蔽的标记。什么是注意力掩码？ [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • decoder_input_values (torch.Tensor 形状为 (batch_size, sequence_length, config.num_mel_bins)) — 输入梅尔频谱的浮点数值。

    SpeechT5 使用全零频谱作为 decoder_input_values 生成的起始 token。如果使用了 past_key_values，则可以选择性地仅输入最后一个 decoder_input_values（参见 past_key_values）。

  • decoder_attention_mask (torch.LongTensor 形状为 (batch_size, target_sequence_length), ，可选) — 默认行为：生成一个张量，用于忽略 decoder_input_values. 中的填充标记。默认情况下还会使用因果掩码。

    如果您想更改填充（padding）行为，请阅读 SpeechT5Decoder._prepare_decoder_attention_mask 并根据需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。

  • encoder_outputs (tuple[tuple[torch.Tensor]]，可选) — 元组由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成 last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • speaker_embeddings (torch.Tensor，形状为 (batch_size, config.speaker_embedding_dim)，可选) — 包含说话人嵌入的张量。
  • labels (torch.Tensor，形状为 (batch_size, sequence_length, config.num_mel_bins)，可选) — 目标梅尔频谱的浮点数值。时间步设置为 -100.0 的值在损失计算中会被忽略（被掩码）。可以使用 SpeechT5Processor 获取频谱。有关详细信息，请参阅 SpeechT5Processor.call()。
  • stop_labels（形状为 (batch_size, sequence_length) 的 torch.Tensor，可选） — 指示序列中停止标记位置的二值张量。

返回值

Seq2SeqSpectrogramOutput 或 tuple(torch.Tensor)

一个 Seq2SeqSpectrogramOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（SpeechT5Config）和输入。

SpeechT5ForTextToSpeech 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

  • loss（形状为 (1,) 的 torch.Tensor，可选，在提供 labels 时返回）— 频谱图生成损失。

  • 频谱图（形状为 (batch_size, sequence_length, num_bins) 的 torch.Tensor）— 预测的频谱图。

  • past_key_values（EncoderDecoderCache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(torch.Tensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出处的隐藏状态，以及初始嵌入输出。

  • decoder_attentions (tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

  • cross_attentions (tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。

  • encoder_last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选）— 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.Tensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出处的隐藏状态，以及初始嵌入输出。

  • encoder_attentions（tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

>>> from transformers import 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

< >

( input_ids: LongTensorattention_mask: typing.Optional[torch.LongTensor] = Nonespeaker_embeddings: typing.Optional[torch.Tensor] = Nonethreshold: float = 0.5minlenratio: float = 0.0maxlenratio: float = 20.0vocoder: typing.Optional[torch.nn.Module] = Noneoutput_cross_attentions: bool = Falsereturn_output_lengths: bool = False**kwargs ) → tuple(torch.Tensor) comprising various elements depending on the inputs

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 输入序列中各 token 在词汇表中的索引。

    可以使用 SpeechT5Tokenizer 获取索引。有关详细信息，请参阅 encode() 和 call()。

    什么是输入 ID？

  • attention_mask (torch.LongTensor，形状为 (batch_size, sequence_length)) — 来自分词器的注意力掩码，在批量推理中必需，用于向模型指示在输入中应忽略哪些填充标记。
  • speaker_embeddings (torch.Tensor，形状为 (batch_size, config.speaker_embedding_dim)，可选) — 包含说话人嵌入的张量。
  • threshold (float，可选，默认值为 0.5) — 当预测的停止 token 概率超过此值时，生成的序列结束。
  • minlenratio (float，可选，默认值为 0.0) — 用于计算输出序列所需的最小长度。
  • maxlenratio (float，可选，默认为 20.0) — 用于计算输出序列允许的最大长度。
  • vocoder (nn.Module, 可选) — 将梅尔频谱转换为语音波形的声码器。如果为 None，则输出为梅尔频谱。
  • output_cross_attentions (bool，可选，默认为 False) — 是否返回解码器交叉注意力层的注意力张量。
  • return_output_lengths (bool，可选，默认为 False) — 是否返回具体的频谱图/波形长度。

返回值

tuple(torch.Tensor)，根据输入的不同包含各种元素

  • 当 return_output_lengths 为 False 时
    • 频谱图（可选，在未提供 vocoder 时返回）形状为 (output_sequence_length, config.num_mel_bins) 的 torch.Tensor — 预测的对数梅尔频谱图。
    • waveform（可选，在提供 vocoder 时返回）形状为 (num_frames,) 的 torch.Tensor — 预测的语音波形。
    • cross_attentions（可选，当 output_cross_attentions 为 True 时返回） 形状为 (config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length) 的 torch.Tensor — 解码器交叉注意力层的输出。
  • 当 return_output_lengths 为 True 时
    • 频谱图（可选，在未提供 vocoder 时返回）形状为 (batch_size, output_sequence_length, config.num_mel_bins) 的 torch.Tensor — 填充至最大长度的预测对数梅尔频谱图。
    • spectrogram_lengths（可选，在未提供 vocoder 时返回）list[Int] — 包含每个频谱图具体长度的列表。
    • 波形（可选，在提供 vocoder 时返回）形状为 (batch_size, num_frames) 的 torch.Tensor — 填充至最大长度的预测语音波形。
    • waveform_lengths（可选，在提供 vocoder 时返回）list[Int] — 包含每个波形具体长度的列表。
    • cross_attentions（可选，当 output_cross_attentions 为 True 时返回） 形状为 (batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length) 的 torch.Tensor — 解码器交叉注意力层的输出。

将输入 token 序列转换为 mel 频谱图序列，随后使用声码器将其转换为语音波形。

SpeechT5ForSpeechToSpeech

class transformers.SpeechT5ForSpeechToSpeech

< >

( config: SpeechT5Config )

参数

  • config (SpeechT5Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

SpeechT5 模型，包含语音编码器和语音解码器。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_values: typing.Optional[torch.Tensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonespeaker_embeddings: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Nonestop_labels: typing.Optional[torch.Tensor] = None**kwargs ) → Seq2SeqSpectrogramOutput or tuple(torch.Tensor)

参数

  • input_values (torch.Tensor，形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。可以通过将 .flac 或 .wav 音频文件加载为 list[float]、numpy.ndarray 或 torch.Tensor 类型的数组来获取这些值，例如 使用 torchcodec 库（pip install torchcodec）或 soundfile 库（pip install soundfile）。要将该数组处理为 input_values，应使用 SpeechT5Processor 进行填充并转换为 torch.Tensor 类型的张量。详情请参见 SpeechT5Processor.call()。
  • attention_mask (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 [0, 1]：1 表示未屏蔽的标记，0 表示被屏蔽的标记。什么是注意力掩码？ [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • decoder_input_values (torch.Tensor 形状为 (batch_size, sequence_length, config.num_mel_bins)) — 输入梅尔频谱的浮点数值。

    SpeechT5 使用全零频谱作为 decoder_input_values 生成的起始 token。如果使用了 past_key_values，则可以选择性地仅输入最后一个 decoder_input_values（参见 past_key_values）。

  • decoder_attention_mask (torch.LongTensor 形状为 (batch_size, target_sequence_length), ，可选) — 默认行为：生成一个张量，用于忽略 decoder_input_values. 中的填充标记。默认情况下还会使用因果掩码。

    如果您想更改填充（padding）行为，请阅读 SpeechT5Decoder._prepare_decoder_attention_mask 并根据需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。

  • encoder_outputs (tuple[tuple[torch.Tensor]]，可选) — 元组由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成 last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • speaker_embeddings (torch.Tensor，形状为 (batch_size, config.speaker_embedding_dim)，可选) — 包含说话人嵌入的张量。
  • labels (torch.Tensor，形状为 (batch_size, sequence_length, config.num_mel_bins)，可选) — 目标梅尔频谱的浮点数值。可以使用 SpeechT5Processor 获取频谱。有关详细信息，请参阅 SpeechT5Processor.call()。
  • stop_labels（形状为 (batch_size, sequence_length) 的 torch.Tensor，可选） — 指示序列中停止标记位置的二值张量。

返回值

Seq2SeqSpectrogramOutput 或 tuple(torch.Tensor)

一个 Seq2SeqSpectrogramOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（SpeechT5Config）和输入。

SpeechT5ForSpeechToSpeech 的 forward 方法会重写 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

  • loss（形状为 (1,) 的 torch.Tensor，可选，在提供 labels 时返回）— 频谱图生成损失。

  • 频谱图（形状为 (batch_size, sequence_length, num_bins) 的 torch.Tensor）— 预测的频谱图。

  • past_key_values（EncoderDecoderCache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(torch.Tensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出处的隐藏状态，以及初始嵌入输出。

  • decoder_attentions (tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

  • cross_attentions (tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。

  • encoder_last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选）— 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.Tensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出处的隐藏状态，以及初始嵌入输出。

  • encoder_attentions（tuple(torch.Tensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

>>> from transformers import 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: Tensorspeaker_embeddings: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonethreshold: float = 0.5minlenratio: float = 0.0maxlenratio: float = 20.0vocoder: typing.Optional[torch.nn.Module] = Noneoutput_cross_attentions: bool = Falsereturn_output_lengths: bool = False ) → tuple(torch.Tensor) comprising various elements depending on the inputs

参数

  • input_values (torch.Tensor 形状为 (batch_size, sequence_length)) — 输入原始语音波形的浮点值。

    可以通过将 .flac 或 .wav 音频文件加载为 list[float]、numpy.ndarray 或 torch.Tensor 类型的数组来获取数值，例如 使用 torchcodec 库（pip install torchcodec）或 soundfile 库（pip install soundfile）。要将该数组准备为 input_values，应使用 SpeechT5Processor 进行填充并将其转换为 torch.Tensor 类型的张量。有关详细信息，请参阅 SpeechT5Processor.call()。

  • speaker_embeddings (torch.Tensor，形状为 (batch_size, config.speaker_embedding_dim)，可选) — 包含说话人嵌入的张量。
  • attention_mask (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 用于避免在填充 token 索引上执行卷积和注意力的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • 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.Tensor)，根据输入的不同包含各种元素

  • 当 return_output_lengths 为 False 时
    • 频谱图（可选，在未提供 vocoder 时返回）形状为 (output_sequence_length, config.num_mel_bins) 的 torch.Tensor — 预测的对数梅尔频谱图。
    • waveform（可选，在提供 vocoder 时返回）形状为 (num_frames,) 的 torch.Tensor — 预测的语音波形。
    • cross_attentions（可选，当 output_cross_attentions 为 True 时返回） 形状为 (config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length) 的 torch.Tensor — 解码器交叉注意力层的输出。
  • 当 return_output_lengths 为 True 时
    • 频谱图（可选，在未提供 vocoder 时返回）形状为 (batch_size, output_sequence_length, config.num_mel_bins) 的 torch.Tensor — 填充至最大长度的预测对数梅尔频谱图。
    • spectrogram_lengths（可选，在未提供 vocoder 时返回）list[Int] — 包含每个频谱图具体长度的列表。
    • 波形（可选，在提供 vocoder 时返回）形状为 (batch_size, num_frames) 的 torch.Tensor — 填充至最大长度的预测语音波形。
    • waveform_lengths（可选，在提供 vocoder 时返回）list[Int] — 包含每个波形具体长度的列表。
    • cross_attentions（可选，当 output_cross_attentions 为 True 时返回） 形状为 (batch_size, config.decoder_layers, config.decoder_attention_heads, output_sequence_length, input_sequence_length) 的 torch.Tensor — 解码器交叉注意力层的输出。

将原始语音波形转换为梅尔频谱图序列，随后使用声码器将其还原为语音波形。

SpeechT5HifiGan

class transformers.SpeechT5HifiGan

< >

( config: SpeechT5HifiGanConfig )

参数

  • config (SpeechT5HifiGanConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

HiFi-GAN 声码器。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( spectrogram: Tensor**kwargs ) → torch.Tensor

参数

  • spectrogram (torch.Tensor) — 包含对数梅尔频谱图的张量。可以是批处理形式，形状为 (batch_size, sequence_length, config.model_in_dim)，也可以是非批处理形式，形状为 (sequence_length, config.model_in_dim)。

返回值

torch.Tensor

包含语音波形的张量。如果输入频谱图是批处理的，其形状为 (batch_size, num_frames,)。如果未进行批处理，其形状为 (num_frames,)。

将 log-mel 频谱图转换为语音波形。传入一批 log-mel 频谱图将返回一批语音波形。传入单个未批处理的 log-mel 频谱图将返回单个未批处理的语音波形。

Update on GitHub

←Speech2Text UniSpeech→