# FastSpeech2Conformer

## 概述

FastSpeech2Conformer 模型由 Pengcheng Guo、Florian Boyer、Xuankai Chang、Tomoki Hayashi、Yosuke Higuchi、Hirofumi Inaguma、Naoyuki Kamo、Chenda Li、Daniel Garcia-Romero、Jiatong Shi、Jing Shi、Shinji Watanabe、Kun Wei、Wangyou Zhang 和 Yuekai Zhang 在论文 [Recent Developments On Espnet Toolkit Boosted By Conformer](https://huggingface.co/papers/2010.13956) 中提出。

原始 FastSpeech2 论文的摘要如下：

*非自回归文本转语音（TTS）模型，例如 FastSpeech（Ren et al., 2019），能够以与先前自回归模型相当的质量，显著更快地合成语音。FastSpeech 模型的训练依赖于一个自回归教师模型来进行时长预测（以提供更多输入信息）和知识蒸馏（以简化输出中的数据分布），这有助于缓解 TTS 中的一对多映射问题（即多种语音变体对应同一段文本）。然而，FastSpeech 存在几个缺点：1）教师-学生蒸馏流程复杂且耗时，2）从教师模型中提取的时长不够准确，且从教师模型蒸馏出的目标梅尔频谱图因数据简化而存在信息损失，这两点都限制了语音质量。在本文中，我们提出了 FastSpeech 2，它通过 1）直接使用真实目标而非教师模型的简化输出来训练模型，以及 2）引入更多语音变化信息（例如音高、能量和更准确的时长）作为条件输入，解决了 FastSpeech 中的问题，并更好地解决了 TTS 中的一对多映射问题。具体而言，我们从语音波形中提取时长、音高和能量，并在训练时直接将其作为条件输入，在推理时使用预测值。我们进一步设计了 FastSpeech 2s，这是首次尝试并行地从文本直接生成语音波形，从而享受完全端到端推理带来的好处。实验结果表明：1）FastSpeech 2 相比 FastSpeech 实现了 3 倍的训练加速，而 FastSpeech 2s 拥有更快的推理速度；2）FastSpeech 2 和 2s 在语音质量上优于 FastSpeech，且 FastSpeech 2 甚至可以超越自回归模型。音频样本可在 https://speechresearch.github.io/fastspeech2/ 获取。*

该模型由 [Connor Henderson](https://huggingface.co/connor-henderson) 贡献。原始代码可在[此处](https://github.com/espnet/espnet/blob/master/espnet2/tts/fastspeech2/fastspeech2.py)找到。

## 🤗 模型架构

实现了 FastSpeech2 的通用结构，其中包含梅尔频谱解码器，并且像 ESPnet 库中那样，将传统的 transformer 块替换为 conformer 块。

### FastSpeech2 模型架构

![FastSpeech2 Model Architecture](https://www.microsoft.com/en-us/research/uploads/prod/2021/04/fastspeech2-1.png)

#### Conformer 块

![Conformer Blocks](https://www.researchgate.net/profile/Hirofumi-Inaguma-2/publication/344911155/figure/fig2/AS:951455406108673@1603856054097/An-overview-of-Conformer-block.png)

#### 卷积模块

![Convolution Module](https://d3i71xaburhd42.cloudfront.net/8809d0732f6147d4ad9218c8f9b20227c837a746/2-Figure1-1.png)

## 🤗 Transformers 用法

您可以使用 🤗 Transformers 库在本地运行 FastSpeech2Conformer。

1. 首先安装 🤗 [Transformers 库](https://github.com/huggingface/transformers) 和 g2p-en：

```bash
pip install --upgrade pip
pip install --upgrade transformers g2p-en
```

2. 使用 Transformers 建模代码，分别通过模型和 hifigan 运行推理

```python
import soundfile as sf

from transformers import FastSpeech2ConformerHifiGan, FastSpeech2ConformerModel, FastSpeech2ConformerTokenizer

tokenizer = FastSpeech2ConformerTokenizer.from_pretrained("espnet/fastspeech2_conformer")
inputs = tokenizer("Hello, my dog is cute.", return_tensors="pt").to(model.device)
input_ids = inputs["input_ids"]

model = FastSpeech2ConformerModel.from_pretrained("espnet/fastspeech2_conformer", device_map="auto")
output_dict = model(input_ids, return_dict=True)
spectrogram = output_dict["spectrogram"]

hifigan = FastSpeech2ConformerHifiGan.from_pretrained("espnet/fastspeech2_conformer_hifigan")
waveform = hifigan(spectrogram)

sf.write("speech.wav", waveform.squeeze().detach().numpy(), samplerate=22050)
```

3. 通过 Transformers 建模代码运行推理，将模型与 hifigan 结合使用

```python
import soundfile as sf

from transformers import FastSpeech2ConformerTokenizer, FastSpeech2ConformerWithHifiGan

tokenizer = FastSpeech2ConformerTokenizer.from_pretrained("espnet/fastspeech2_conformer")
inputs = tokenizer("Hello, my dog is cute.", return_tensors="pt").to(model.device)
input_ids = inputs["input_ids"]

model = FastSpeech2ConformerWithHifiGan.from_pretrained("espnet/fastspeech2_conformer_with_hifigan")
output_dict = model(input_ids, return_dict=True)
waveform = output_dict["waveform"]

sf.write("speech.wav", waveform.squeeze().detach().numpy(), samplerate=22050)
```

4. 使用 pipeline 运行推理并指定要使用的 vocoder

```python
import soundfile as sf

from transformers import FastSpeech2ConformerHifiGan, pipeline

vocoder = FastSpeech2ConformerHifiGan.from_pretrained("espnet/fastspeech2_conformer_hifigan")
synthesiser = pipeline(model="espnet/fastspeech2_conformer", vocoder=vocoder)

speech = synthesiser("Hello, my dog is cooler than you!")

sf.write("speech.wav", speech["audio"].squeeze(), samplerate=speech["sampling_rate"])
```

## FastSpeech2ConformerConfig[[transformers.FastSpeech2ConformerConfig]]

#### transformers.FastSpeech2ConformerConfig[[transformers.FastSpeech2ConformerConfig]]

```python
transformers.FastSpeech2ConformerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, hidden_size: int = 384, vocab_size: int = 78, num_mel_bins: int = 80, encoder_num_attention_heads: int = 2, encoder_layers: int = 4, encoder_linear_units: int = 1536, decoder_layers: int = 4, decoder_num_attention_heads: int = 2, decoder_linear_units: int = 1536, speech_decoder_postnet_layers: int = 5, speech_decoder_postnet_units: int = 256, speech_decoder_postnet_kernel: int = 5, positionwise_conv_kernel_size: int = 3, encoder_normalize_before: bool = False, decoder_normalize_before: bool = False, encoder_concat_after: bool = False, decoder_concat_after: bool = False, reduction_factor: int = 1, speaking_speed: float = 1.0, use_macaron_style_in_conformer: bool = True, use_cnn_in_conformer: bool = True, encoder_kernel_size: int = 7, decoder_kernel_size: int = 31, duration_predictor_layers: int = 2, duration_predictor_channels: int = 256, duration_predictor_kernel_size: int = 3, energy_predictor_layers: int = 2, energy_predictor_channels: int = 256, energy_predictor_kernel_size: int = 3, energy_predictor_dropout: float | int = 0.5, energy_embed_kernel_size: int = 1, energy_embed_dropout: float | int = 0.0, stop_gradient_from_energy_predictor: bool = False, pitch_predictor_layers: int = 5, pitch_predictor_channels: int = 256, pitch_predictor_kernel_size: int = 5, pitch_predictor_dropout: float | int = 0.5, pitch_embed_kernel_size: int = 1, pitch_embed_dropout: float | int = 0.0, stop_gradient_from_pitch_predictor: bool = True, encoder_dropout_rate: float | int = 0.2, encoder_positional_dropout_rate: float | int = 0.2, encoder_attention_dropout_rate: float | int = 0.2, decoder_dropout_rate: float | int = 0.2, decoder_positional_dropout_rate: float | int = 0.2, decoder_attention_dropout_rate: float | int = 0.2, duration_predictor_dropout_rate: float | int = 0.2, speech_decoder_postnet_dropout: float | int = 0.5, max_source_positions: int = 5000, use_masking: bool = True, use_weighted_masking: bool = False, num_speakers: int | None = None, num_languages: int | None = None, speaker_embed_dim: int | None = None, convolution_bias: bool = True)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/configuration_fastspeech2_conformer.py#L27)

**参数：**

is_encoder_decoder (`bool`，*可选*，默认为 `True`)：模型是否用作编码器/解码器。

hidden_size (`int`，*可选*，默认为 `384`)：隐藏表示的维度。

vocab_size (`int`，*可选*，默认为 `78`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。

num_mel_bins (`int`，*可选*，默认为 `80`)：每个输入帧使用的 mel 特征数量。应与 `AutoFeatureExtractor` 类中使用的值相对应。

encoder_num_attention_heads (`int`，*可选*，默认为 2)：编码器中的注意力头数量。

encoder_layers (`int`，*可选*，默认为 `4`)：Transformer 编码器中的隐藏层数。如果未设置，将使用与 `num_layers` 相同的值。

encoder_linear_units (`int`，*可选*，默认为 1536)：编码器线性层中的单元数量。

decoder_layers (`int`，*可选*，默认为 `4`)：Transformer 解码器中的隐藏层数。如果未设置，将使用与 `num_layers` 相同的值。

decoder_num_attention_heads (`int`，*可选*，默认为 `2`)：Transformer 解码器中每个注意力层的注意力头数量。

decoder_linear_units (`int`，*可选*，默认为 1536)：解码器线性层中的单元数量。

speech_decoder_postnet_layers (`int`，*可选*，默认为 5)：语音解码器后网络中的层数。

speech_decoder_postnet_units (`int`，*可选*，默认为 256)：语音解码器后网络层中的单元数量。

speech_decoder_postnet_kernel (`int`，*可选*，默认为 5)：语音解码器后网络中的核大小。

positionwise_conv_kernel_size (`int`，*可选*，默认为 3)：位置层中使用的卷积核大小。

encoder_normalize_before (`bool`，*可选*，默认为 `False`)：指定是否在编码器层之前进行归一化。

decoder_normalize_before (`bool`，*可选*，默认为 `False`)：指定是否在解码器层之前进行归一化。

encoder_concat_after (`bool`，*可选*，默认为 `False`)：指定是否在编码器层之后进行拼接。

decoder_concat_after (`bool`，*可选*，默认为 `False`)：指定是否在解码器层之后进行拼接。

reduction_factor (`int`，*可选*，默认为 1)：语音帧率降低的倍数。

speaking_speed (`float`, *可选*, 默认为 1.0) : 生成语音的速度。

use_macaron_style_in_conformer (`bool`, *可选*, 默认为 `True`) : 指定是否在 conformer 中使用 macaron 风格。

use_cnn_in_conformer (`bool`, *可选*, 默认为 `True`) : 指定是否在 conformer 中使用卷积神经网络。

encoder_kernel_size (`int`，*可选*，默认为 7)：编码器中使用的卷积核大小。

decoder_kernel_size (`int`, *可选*，默认为 31)：解码器中使用的核大小。

duration_predictor_layers (`int`，*可选*，默认为 2)：时长预测器中的层数。

duration_predictor_channels (`int`，*可选*，默认为 256)：时长预测器中的通道数。

duration_predictor_kernel_size (`int`, *可选*，默认为 3)：时长预测器中使用的核大小。

energy_predictor_layers (`int`, *可选*, 默认为 2) : 能量预测器中的层数。

energy_predictor_channels (`int`，*可选*，默认为 256)：能量预测器中的通道数。

energy_predictor_kernel_size (`int`，*可选*，默认为 3)：能量预测器中使用的核大小。

energy_predictor_dropout (`float`, *可选*，默认为 0.5)：能量预测器中的 dropout 率。

energy_embed_kernel_size (`int`，*可选*，默认为 1)：能量嵌入层中使用的核大小。

energy_embed_dropout (`float`, *可选*，默认为 0.0)：能量嵌入层中的 dropout 率。

stop_gradient_from_energy_predictor (`bool`, *可选*, 默认为 `False`) : 指定是否停止来自能量预测器的梯度。

pitch_predictor_layers (`int`，*可选*，默认为 5)：音高预测器中的层数。

pitch_predictor_channels (`int`，*可选*，默认为 256)：音高预测器中的通道数。

pitch_predictor_kernel_size (`int`, *可选*，默认为 5)：音高预测器中使用的核大小。

pitch_predictor_dropout (`float`, *可选*，默认为 0.5)：音高预测器中的 dropout 率。

pitch_embed_kernel_size (`int`，*可选*，默认为 1)：音高嵌入层中使用的核大小。

pitch_embed_dropout (`float`, *可选*，默认为 0.0)：音高嵌入层中的 dropout 率。

stop_gradient_from_pitch_predictor (`bool`, *可选*, 默认为 `True`) : 指定是否停止来自音高预测器的梯度。

encoder_dropout_rate (`float`, *可选*，默认为 0.2)：编码器中的 dropout 率。

encoder_positional_dropout_rate (`float`, *可选*，默认为 0.2)：编码器中的位置 dropout 率。

encoder_attention_dropout_rate (`float`, *可选*，默认为 0.2)：编码器中的注意力 dropout 率。

decoder_dropout_rate (`float`, *可选*，默认为 0.2)：解码器中的 dropout 率。

decoder_positional_dropout_rate (`float`, *可选*，默认为 0.2) : 解码器中的位置 dropout 率。

decoder_attention_dropout_rate (`float`, *可选*，默认为 0.2)：解码器中的注意力 dropout 率。

duration_predictor_dropout_rate (`float`, *可选*，默认为 0.2)：时长预测器中的 dropout 率。

speech_decoder_postnet_dropout (`float`, *可选*，默认为 0.5)：语音解码器后处理网络中的 dropout 率。

max_source_positions (`int`，*可选*，默认为 5000)：如果使用 `"relative"` 位置嵌入，则定义源输入的最大位置。

use_masking (`bool`，*可选*，默认为 `True`)：指定是否在模型中使用掩码。

use_weighted_masking (`bool`，*可选*，默认为 `False`)：指定是否在模型中使用加权掩码。

num_speakers (`int`, *可选*) : 说话人数量。如果设置为 > 1，则假定说话人 ID 将作为输入提供，并使用说话人 ID 嵌入层。

num_languages (`int`, *可选*) : 语言数量。如果设置为 > 1，则假定语言 ID 将作为输入提供，并使用语言 ID 嵌入层。

speaker_embed_dim (`int`, *可选*) : 说话人嵌入维度。如果设置为 > 0，则假定将提供 speaker_embedding 作为输入。

convolution_bias (`bool`，*可选*，默认为 `True`)：指定是否在 Conformer 的卷积模块中使用偏置。

这是用于存储 FastSpeech2ConformerModel 配置的类。它根据指定的参数实例化 Fastspeech2 Conformer 模型，并定义模型架构。使用默认值实例化配置将得到与 [espnet/fastspeech2_conformer](https://huggingface.co/espnet/fastspeech2_conformer) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import FastSpeech2ConformerModel, FastSpeech2ConformerConfig

>>> # Initializing a FastSpeech2Conformer style configuration
>>> configuration = FastSpeech2ConformerConfig()

>>> # Initializing a model from the FastSpeech2Conformer style configuration
>>> model = FastSpeech2ConformerModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## FastSpeech2ConformerHifiGanConfig[[transformers.FastSpeech2ConformerHifiGanConfig]]

#### transformers.FastSpeech2ConformerHifiGanConfig[[transformers.FastSpeech2ConformerHifiGanConfig]]

```python
transformers.FastSpeech2ConformerHifiGanConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, model_in_dim: int = 80, upsample_initial_channel: int = 512, upsample_rates: list[int] | tuple[int, ...] = (8, 8, 2, 2), upsample_kernel_sizes: list[int] | tuple[int, ...] = (16, 16, 4, 4), resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: list | tuple | None = None, initializer_range: float = 0.01, leaky_relu_slope: float = 0.1, normalize_before: bool = True)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/configuration_fastspeech2_conformer.py#L267)

**参数：**

model_in_dim (`int`, *可选*，默认为 80)：输入对数梅尔频谱图中的频率分箱数量。

upsample_initial_channel (`int`，*可选*，默认值为 512)：上采样网络的输入通道数。

upsample_rates (`tuple[int]` 或 `list[int]`，*可选*，默认为 `[8, 8, 2, 2]`) : 一个整数元组，用于定义上采样网络中每个一维卷积层的步幅。*upsample_rates* 的长度定义了卷积层的数量，并且必须与 *upsample_kernel_sizes* 的长度相匹配。

upsample_kernel_sizes (`tuple[int]` 或 `list[int]`，*可选*，默认为 `[16, 16, 4, 4]`) : 一个整数元组，用于定义上采样网络中每个一维卷积层的核大小。*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`) : 是否在使用声码器进行声码化之前，利用声码器学习到的均值和方差对频谱图进行归一化。

这是用于存储 FastSpeech2ConformerModel 配置的类。它根据指定的参数实例化 Fastspeech2 Conformer 模型，并定义模型架构。使用默认值实例化配置将得到与 [espnet/fastspeech2_conformer_with_hifigan](https://huggingface.co/espnet/fastspeech2_conformer_with_hifigan) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import FastSpeech2ConformerHifiGan, FastSpeech2ConformerHifiGanConfig

>>> # Initializing a FastSpeech2ConformerHifiGan configuration
>>> configuration = FastSpeech2ConformerHifiGanConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = FastSpeech2ConformerHifiGan(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## FastSpeech2ConformerWithHifiGanConfig[[transformers.FastSpeech2ConformerWithHifiGanConfig]]

#### transformers.FastSpeech2ConformerWithHifiGanConfig[[transformers.FastSpeech2ConformerWithHifiGanConfig]]

```python
transformers.FastSpeech2ConformerWithHifiGanConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vocoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/configuration_fastspeech2_conformer.py#L328)

**参数：**

model_config (`FastSpeech2ConformerConfig | dict`，*可选*)：文本转语音模型的配置。

vocoder_config (`FastSpeech2ConformerHiFiGanConfig | dict`, *可选*) : 声码器模型的配置。

这是用于存储 FastSpeech2ConformerModel 配置的类。它根据指定的参数实例化 Fastspeech2 Conformer 模型，并定义模型架构。使用默认值实例化配置将得到与 [espnet/fastspeech2_conformer_with_hifigan](https://huggingface.co/espnet/fastspeech2_conformer_with_hifigan) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

示例：

```python
>>> from transformers import (
...     FastSpeech2ConformerConfig,
...     FastSpeech2ConformerHifiGanConfig,
...     FastSpeech2ConformerWithHifiGanConfig,
...     FastSpeech2ConformerWithHifiGan,
... )

>>> # Initializing FastSpeech2ConformerWithHifiGan sub-modules configurations.
>>> model_config = FastSpeech2ConformerConfig()
>>> vocoder_config = FastSpeech2ConformerHifiGanConfig()

>>> # Initializing a FastSpeech2ConformerWithHifiGan module style configuration
>>> configuration = FastSpeech2ConformerWithHifiGanConfig(model_config.to_dict(), vocoder_config.to_dict())

>>> # Initializing a model (with random weights)
>>> model = FastSpeech2ConformerWithHifiGan(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## FastSpeech2ConformerTokenizer[[transformers.FastSpeech2ConformerTokenizer]]

#### transformers.FastSpeech2ConformerTokenizer[[transformers.FastSpeech2ConformerTokenizer]]

```python
transformers.FastSpeech2ConformerTokenizer(vocab_file, bos_token = '<sos/eos>', eos_token = '<sos/eos>', pad_token = '<blank>', unk_token = '<unk>', should_strip_spaces = False, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/tokenization_fastspeech2_conformer.py#L30)

**参数：**

vocab_file (`str`) : 词汇表文件的路径。

bos_token (`str`，*可选*，默认为 `"<sos/eos>"`)：序列开始标记。请注意，对于 FastSpeech2，它与 `eos_token` 相同。

eos_token (`str`，*可选*，默认为 `"<sos/eos>"`)：序列结束标记。请注意，对于 FastSpeech2，它与 `bos_token` 相同。

pad_token (`str`，*可选*，默认为 `"<blank>"`)：用于填充的标记，例如在对长度不同的序列进行批处理时。

unk_token (`str`，*可选*，默认为 `"<unk>"`)：未知标记。不在词汇表中的标记无法转换为 ID，因此会被设置为该标记。

should_strip_spaces (`bool`，*可选*，默认为 `False`)：是否从 token 列表中去除空格。

构建一个 FastSpeech2Conformer 分词器。

#### __调用__[[transformers.FastSpeech2ConformerTokenizer.__call__]]

```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2448)

**参数：**

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](/docs/transformers/main/zh/internal/file_utils#transformers.utils.PaddingStrategy)，*可选*，默认为 `False`)：启用并控制填充。接受以下值： - `True` 或 `'longest'`：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。 - `'max_length'`：填充至由参数 `max_length` 指定的最大长度，或者如果未提供该参数，则填充至模型可接受的最大输入长度。 - `False` 或 `'do_not_pad'`（默认值）：不进行填充（即，可以输出包含不同长度序列的批次）。

truncation (`bool`、`str` 或 [TruncationStrategy](/docs/transformers/main/zh/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)，*optional*，默认为 `False`)：启用并控制截断。接受以下值： - `True` 或 `'longest_first'`：截断至参数 `max_length` 指定的最大长度，若未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这将逐个 token 进行截断，从该对中最长的序列中移除一个 token。 - `'only_first'`：截断至参数 `max_length` 指定的最大长度，若未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这将仅截断该对中的第一个序列。 - `'only_second'`：截断至参数 `max_length` 指定的最大长度，若未提供该参数，则截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），这将仅截断该对中的第二个序列。 - `False` 或 `'do_not_truncate'`（默认）：不截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。

max_length (`int`, *可选*) : 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 `None`，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。

stride (`int`，*可选*，默认为 0)：如果与 `max_length` 一起设置为某个数值，则当 `return_overflowing_tokens=True` 时，返回的溢出 token 将包含来自截断序列末尾的若干 token，以在截断序列和溢出序列之间提供一定的重叠。该参数的值定义了重叠 token 的数量。

is_split_into_words (`bool`，*可选*，默认为 `False`)：输入是否已经预先分词（例如，已拆分为单词）。如果设置为 `True`，分词器将假设输入已经拆分为单词（例如，通过按空白字符拆分），然后对其进行分词。这对于 NER 或 token 分类很有用。

pad_to_multiple_of (`int`，*可选*)：如果设置，则将序列填充为所提供值的倍数。需要启用 `padding`。这对于在计算能力 `>= 7.5`（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。

padding_side (`str`, *可选*) : 模型应应用填充的一侧。应在 ['right', 'left'] 中进行选择。默认值取自同名的类属性。

return_tensors (`str` 或 [TensorType](/docs/transformers/main/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回张量而不是 Python 整数列表。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 Numpy `np.ndarray` 对象。

return_token_type_ids (`bool`，*可选*)：是否返回 token type ID。如果保持默认值，则根据特定 tokenizer 的默认设置返回 token type ID，该设置由 `return_outputs` 属性定义。[什么是 token type ID？](../glossary#token-type-ids)

return_attention_mask (`bool`，*可选*)：是否返回注意力掩码。如果保持默认值，将根据特定分词器的默认设置返回注意力掩码，该设置由 `return_outputs` 属性定义。[什么是注意力掩码？](../glossary#attention-mask)

return_overflowing_tokens (`bool`，*可选*，默认为 `False`)：是否返回溢出的 token 序列。如果提供了输入 id 的序列对（或序列对的批次），并且 `truncation_strategy = longest_first` 或 `True`，则会引发错误，而不是返回溢出的 token。

return_special_tokens_mask (`bool`，*可选*，默认为 `False`)：是否返回特殊标记掩码信息。

return_offsets_mapping (`bool`，*可选*，默认为 `False`)：是否返回每个 token 的 `(char_start, char_end)`。此功能仅适用于继承自 [PreTrainedTokenizerFast](/docs/transformers/main/zh/main_classes/tokenizer#transformers.TokenizersBackend) 的快速分词器；如果使用 Python 分词器，此方法将抛出 `NotImplementedError`。

return_length (`bool`，*可选*，默认为 `False`)：是否返回编码后输入的长度。

verbose (`bool`，*可选*，默认为 `True`)：是否打印更多信息和警告。

- ****kwargs** : 传递给 `self.tokenize()` 方法

**返回：** [BatchEncoding](/docs/transformers/main/zh/main_classes/tokenizer#transformers.BatchEncoding)

一个包含以下字段的 [BatchEncoding](/docs/transformers/main/zh/main_classes/tokenizer#transformers.BatchEncoding)：

- **input_ids** -- 输入模型的 token id 列表。

  [什么是输入 ID？](../glossary#input-ids)

- **token_type_ids** -- 要输入模型的 token 类型 ID 列表（当 `return_token_type_ids=True` 或 `self.model_input_names` 中包含 *"token_type_ids"* 时）。

  [什么是 token type ID？](../glossary#token-type-ids)

- **attention_mask** -- 指定模型应关注哪些 token 的索引列表（当 `return_attention_mask=True` 或 *"attention_mask"* 位于 `self.model_input_names` 中时）。

  [什么是注意力掩码？](../glossary#attention-mask)

- **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[[transformers.FastSpeech2ConformerTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/tokenization_fastspeech2_conformer.py#L145)

**参数：**

save_directory (`str`) : 用于保存词汇表的目录。

**返回：** `Tuple(str)`

已保存文件的路径。

将词汇表和特殊标记文件保存到目录中。

#### decode[[transformers.FastSpeech2ConformerTokenizer.decode]]

```python
decode(token_ids, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/tokenization_fastspeech2_conformer.py#L132)

#### batch_decode[[transformers.FastSpeech2ConformerTokenizer.batch_decode]]

```python
batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2932)

**参数：**

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`。

## FastSpeech2ConformerModel[[transformers.FastSpeech2ConformerModel]]

#### transformers.FastSpeech2ConformerModel[[transformers.FastSpeech2ConformerModel]]

```python
transformers.FastSpeech2ConformerModel(config: FastSpeech2ConformerConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1021)

**参数：**

config ([FastSpeech2ConformerConfig](/docs/transformers/main/zh/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

FastSpeech2Conformer 模型。

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.FastSpeech2ConformerModel.forward]]

```python
forward(input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, spectrogram_labels: typing.Optional[torch.Tensor] = None, duration_labels: typing.Optional[torch.LongTensor] = None, pitch_labels: typing.Optional[torch.Tensor] = None, energy_labels: typing.Optional[torch.Tensor] = None, speaker_ids: typing.Optional[torch.LongTensor] = None, lang_ids: typing.Optional[torch.LongTensor] = None, speaker_embedding: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1098)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`)：输入文本向量序列。

attention_mask (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值选自 `[0, 1]`： - 对于**未掩码**的标记，值为 1； - 对于**已掩码**的标记，值为 0。 [什么是注意力掩码？](../glossary#attention-mask)

spectrogram_labels (`torch.Tensor`，形状为 `(batch_size, max_spectrogram_length, num_mel_bins)`，*可选*，默认为 `None`)：填充后的目标特征批次。

duration_labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length + 1)`，*可选*，默认为 `None`)：填充后的时长批次。

pitch_labels (`torch.Tensor`，形状为 `(batch_size, sequence_length + 1, 1)`，*可选*，默认为 `None`)：一批填充后的 token 平均音高。

energy_labels (`torch.Tensor`，形状为 `(batch_size, sequence_length + 1, 1)`，*可选*，默认为 `None`)：一批填充后的 token 平均能量。

speaker_ids (`torch.LongTensor`，形状为 `(batch_size, 1)`，*可选*，默认为 `None`)：用于对模型输出的语音特征进行条件约束的说话人 ID。

lang_ids (`torch.LongTensor`，形状为 `(batch_size, 1)`，*可选*，默认为 `None`)：用于根据模型条件化语音输出特征的语言 ID。

speaker_embedding (`torch.Tensor`，形状为 `(batch_size, embedding_dim)`，*可选*，默认为 `None`)：包含语音特征条件信号的嵌入。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

**返回：** `FastSpeech2ConformerModelOutput` 或 `tuple(torch.Tensor)`

`FastSpeech2ConformerModelOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[FastSpeech2ConformerConfig](/docs/transformers/main/zh/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)）和输入。

[FastSpeech2ConformerModel](/docs/transformers/main/zh/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerModel) 的 forward 方法会重写 `__call__` 特殊方法。

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

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回) -- 频谱图生成损失。
- **频谱图**（形状为 `(batch_size, sequence_length, num_bins)` 的 `torch.Tensor`，*可选*）-- 预测的频谱图。
- **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 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **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 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **duration_outputs**（形状为 `(batch_size, max_text_length + 1)` 的 `torch.LongTensor`，*可选*）-- 时长预测器的输出。
- **pitch_outputs**（形状为 `(batch_size, max_text_length + 1, 1)` 的 `torch.Tensor`，*可选*）-- 音高预测器的输出。
- **energy_outputs**（形状为 `(batch_size, max_text_length + 1, 1)` 的 `torch.Tensor`，*可选*）-- 能量预测器的输出。

示例：

```python
>>> from transformers import (
...     FastSpeech2ConformerTokenizer,
...     FastSpeech2ConformerModel,
...     FastSpeech2ConformerHifiGan,
... )

>>> tokenizer = FastSpeech2ConformerTokenizer.from_pretrained("espnet/fastspeech2_conformer")
>>> inputs = tokenizer("some text to convert to speech", return_tensors="pt")
>>> input_ids = inputs["input_ids"]

>>> model = FastSpeech2ConformerModel.from_pretrained("espnet/fastspeech2_conformer")
>>> output_dict = model(input_ids, return_dict=True)
>>> spectrogram = output_dict["spectrogram"]

>>> vocoder = FastSpeech2ConformerHifiGan.from_pretrained("espnet/fastspeech2_conformer_hifigan")
>>> waveform = vocoder(spectrogram)
>>> print(waveform.shape)
torch.Size([1, 49664])
```

## FastSpeech2ConformerHifiGan[[transformers.FastSpeech2ConformerHifiGan]]

#### transformers.FastSpeech2ConformerHifiGan[[transformers.FastSpeech2ConformerHifiGan]]

```python
transformers.FastSpeech2ConformerHifiGan(config: FastSpeech2ConformerHifiGanConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1360)

**参数：**

config ([FastSpeech2ConformerHifiGanConfig](/docs/transformers/main/zh/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerHifiGanConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

HiFi-GAN 声码器。

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.FastSpeech2ConformerHifiGan.forward]]

```python
forward(spectrogram: Tensor, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1428)

**参数：**

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 频谱图将返回单个未批处理的语音波形。

## FastSpeech2ConformerWithHifiGan[[transformers.FastSpeech2ConformerWithHifiGan]]

#### transformers.FastSpeech2ConformerWithHifiGan[[transformers.FastSpeech2ConformerWithHifiGan]]

```python
transformers.FastSpeech2ConformerWithHifiGan(config: FastSpeech2ConformerWithHifiGanConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1483)

**参数：**

config ([FastSpeech2ConformerWithHifiGanConfig](/docs/transformers/main/zh/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerWithHifiGanConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

配备 FastSpeech2ConformerHifiGan 声码器头的 FastSpeech2ConformerModel，用于执行文本转语音（波形）。

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

#### forward[[transformers.FastSpeech2ConformerWithHifiGan.forward]]

```python
forward(input_ids: LongTensor, attention_mask: typing.Optional[torch.LongTensor] = None, spectrogram_labels: typing.Optional[torch.Tensor] = None, duration_labels: typing.Optional[torch.LongTensor] = None, pitch_labels: typing.Optional[torch.Tensor] = None, energy_labels: typing.Optional[torch.Tensor] = None, speaker_ids: typing.Optional[torch.LongTensor] = None, lang_ids: typing.Optional[torch.LongTensor] = None, speaker_embedding: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/fastspeech2_conformer/modeling_fastspeech2_conformer.py#L1496)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`)：输入文本向量序列。

attention_mask (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值选自 `[0, 1]`： - 对于**未掩码**的标记，值为 1； - 对于**已掩码**的标记，值为 0。 [什么是注意力掩码？](../glossary#attention-mask)

spectrogram_labels (`torch.Tensor`，形状为 `(batch_size, max_spectrogram_length, num_mel_bins)`，*可选*，默认为 `None`)：填充后的目标特征批次。

duration_labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length + 1)`，*可选*，默认为 `None`)：填充后的时长批次。

pitch_labels (`torch.Tensor`，形状为 `(batch_size, sequence_length + 1, 1)`，*可选*，默认为 `None`)：一批填充后的 token 平均音高。

energy_labels (`torch.Tensor`，形状为 `(batch_size, sequence_length + 1, 1)`，*可选*，默认为 `None`)：一批填充后的 token 平均能量。

speaker_ids (`torch.LongTensor`，形状为 `(batch_size, 1)`，*可选*，默认为 `None`)：用于对模型输出的语音特征进行条件约束的说话人 ID。

lang_ids (`torch.LongTensor`，形状为 `(batch_size, 1)`，*可选*，默认为 `None`)：用于根据模型条件化语音输出特征的语言 ID。

speaker_embedding (`torch.Tensor`，形状为 `(batch_size, embedding_dim)`，*可选*，默认为 `None`)：包含语音特征条件信号的嵌入。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

**返回：** `FastSpeech2ConformerModelOutput` 或 `tuple(torch.Tensor)`

`FastSpeech2ConformerModelOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[FastSpeech2ConformerConfig](/docs/transformers/main/zh/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerConfig)）和输入。

[FastSpeech2ConformerWithHifiGan](/docs/transformers/main/zh/model_doc/fastspeech2_conformer#transformers.FastSpeech2ConformerWithHifiGan) 的 forward 方法重写了 `__call__` 特殊方法。

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

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回) -- 频谱图生成损失。
- **频谱图**（形状为 `(batch_size, sequence_length, num_bins)` 的 `torch.Tensor`，*可选*）-- 预测的频谱图。
- **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 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **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 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **duration_outputs**（形状为 `(batch_size, max_text_length + 1)` 的 `torch.LongTensor`，*可选*）-- 时长预测器的输出。
- **pitch_outputs**（形状为 `(batch_size, max_text_length + 1, 1)` 的 `torch.Tensor`，*可选*）-- 音高预测器的输出。
- **energy_outputs**（形状为 `(batch_size, max_text_length + 1, 1)` 的 `torch.Tensor`，*可选*）-- 能量预测器的输出。

示例：

```python
>>> from transformers import (
...     FastSpeech2ConformerTokenizer,
...     FastSpeech2ConformerWithHifiGan,
... )

>>> tokenizer = FastSpeech2ConformerTokenizer.from_pretrained("espnet/fastspeech2_conformer")
>>> inputs = tokenizer("some text to convert to speech", return_tensors="pt")
>>> input_ids = inputs["input_ids"]

>>> model = FastSpeech2ConformerWithHifiGan.from_pretrained("espnet/fastspeech2_conformer_with_hifigan")
>>> output_dict = model(input_ids, return_dict=True)
>>> waveform = output_dict["waveform"]
>>> print(waveform.shape)
torch.Size([1, 49664])
```