文本到语音与语音处理¶

文本到语音合成逆转了ASR流程，从书面文本生成听起来自然的音频。本文涵盖TTS流程（文本归一化、G2P、声学模型、声码器）、Tacotron、WaveNet、HiFi-GAN、语音克隆、语音转换和语音活动检测（VAD）。

在第01章中，我们构建了信号处理工具包：波形、频谱图、梅尔滤波器组和MFCC。在第02章中，我们将语音转换为文本。现在我们逆转方向：给定文本，合成自然的语音。这就是文本到语音（TTS），这个问题也打开了语音转换、语音克隆和语音活动检测的大门。
可以把TTS想象成一场舞台表演。脚本是文本输入。导演（声学模型）决定每一句台词听起来如何，它的音高、节奏、重音。然后乐团（声码器）演奏乐谱，产生观众听到的实际声波。现代神经TTS用能与人类演讲者相媲美的表演取代了基于规则系统的僵硬、机器人式的输出。

TTS流程：文本被归一化、转换为音素，由声学模型处理生成梅尔频谱图，然后通过声码器产生最终波形

文本到语音流程 标准的TTS流程有四个阶段：(1) 文本归一化，(2) 音素转换，(3) 声学模型，(4) 声码器。一些现代系统将阶段3和4合并为一个端到端模型，但概念上的分解仍然有用。
文本归一化 将原始文本转换为可发音的形式。缩写展开（"Dr." → "Doctor"），数字变成单词（"1984" → "nineteen eighty-four"），货币符号被读出来（"$5" → "five dollars"），以及处理URL或特殊字符。这个阶段通常基于规则，带有特定语言的语法，尽管也存在神经归一化模型。这里的错误会传播到所有下游阶段：如果"St."被读作"saint"而不是"street"，整个话语就错了。
字形到音素（G2P）转换 将归一化文本映射到音素序列。英语出了名的不规则（"though"、"through"、"tough"都使用"ough"但发音不同），因此词典查找（CMU发音词典）处理常用词，而神经序列到序列模型（第06章的编码器-解码器或第07章的Transformer）处理词汇表外的词。拼写较浅的语言（西班牙语、芬兰语）需要更简单的G2P。输出通常是IPA（国际音标）序列或等效的内部音素集。
声学模型 消费音素序列并产生中间声学表示，几乎总是梅尔频谱图（第01章）。梅尔频谱图捕获每个时间帧的频谱包络，编码了声码器重建波形所需的感知相关信息。声学模型必须决定时序（每个音素持续多久）、音高（基频 $F_0$）和能量（响度）。
声码器 接收梅尔频谱图并产生原始音频波形。这是一个病态的反演问题：许多波形可以产生相同的频谱图，因为相位信息被丢弃了。经典的声码器（Griffin-Lim、WORLD）使用迭代或信号模型方法，但现在神经声码器在质量上占主导地位。
声码器：WaveNet（van den Oord 等，2016）是第一个产生几乎与人类录音无法区分的语音的神经声码器。它自回归地建模波形，以所有先前样本为条件预测每个样本 $x_t$：

\[P(x) = \prod_{t=1}^{T} P(x_t \mid x_1, \ldots, x_{t-1}, c)\]

其中 $c$ 是条件信号（梅尔频谱图）。每个样本是16位的，因此对65536个值进行朴素softmax是不切实际的。WaveNet使用mu-law压扩将其减少到256个量化级别，或者后来的变体使用逻辑分布混合。
WaveNet的核心构建模块是膨胀因果卷积。因果意味着滤波器权重只查看过去的样本（无未来泄漏）。膨胀意味着滤波器跳过样本，间隔呈指数增长：膨胀因子 $1, 2, 4, 8, \ldots, 512$。这给出了指数级大的感受野，同时保持参数数量线性增长。
每层的门控激活为：

\[z = \tanh(W_{f} \ast x) \odot \sigma(W_{g} \ast x)\]

其中 $W_f$ 和 $W_g$ 是滤波器和门控卷积权重，$\ast$ 表示膨胀因果卷积，$\odot$ 是逐元素乘法。这种门控机制（来自第06章的LSTM）允许网络控制信息流。
WaveNet产生卓越的质量，但在推理时非常慢：生成1秒的24 kHz音频需要24000次顺序前向传播。这激发了后续所有声码器的研究。
WaveRNN（Kalchbrenner 等，2018）用单层循环网络取代了WaveNet的深度卷积堆栈。它将每个16位样本分为粗略（高8位）和精细（低8位）部分，用GRU（第06章）分别预测。这种双softmax方法显著减少了计算量，同时保持高质量。通过精心优化内核，WaveRNN在移动CPU上足够实时。
WaveGlow（Prenger 等，2019）是一个基于流的声码器，完全避免自回归生成。它使用一系列可逆变换（仿射耦合层，第06章的正则化流）将简单高斯分布映射到波形分布。训练使用变量变化公式最大化精确对数似然：

\[\log P(x) = \log P(z) + \sum_{i} \log \left| \det \frac{\partial f_i}{\partial f_{i-1}} \right|\]

其中 $z = f(x)$ 是通过流传递 $x$ 获得的潜在变量。在推理时，抽取样本 $z \sim \mathcal{N}(0, I)$ 并通过反转的流以单次并行传递。WaveGlow以模型大小（耦合层的大型网络）换取生成速度。
HiFi-GAN（Kong 等，2020）使用生成对抗网络从梅尔频谱图合成波形。生成器通过一系列转置卷积上采样梅尔频谱图，每个后面跟着一个多感受野融合（MRF） 模块。MRF模块并行应用多个具有不同卷积核大小和膨胀率的残差块，然后求和它们的输出。这使得生成器能够同时捕获多个时间尺度的模式。

HiFi-GAN生成器架构：梅尔频谱图输入通过转置卷积上采样层，每个后面跟着多感受野融合块，组合具有不同膨胀模式的并行残差堆栈

HiFi-GAN使用两种判别器类型。多周期判别器（MPD） 通过在不同周期（2, 3, 5, 7, 11）折叠1D波形将其重塑为2D，然后应用2D卷积。这捕获了不同基频下的周期性结构。多尺度判别器（MSD） 操作于原始波形、2倍下采样和4倍下采样版本，捕获不同时间分辨率下的模式。
训练目标结合了对抗损失、梅尔频谱图重建损失（合成音频和真实音频的梅尔频谱图之间的L1距离）和特征匹配损失（中间判别器特征之间的L1距离）：

\[\mathcal{L}_G = \mathcal{L}_{\text{adv}}(G) + \lambda_{\text{mel}} \mathcal{L}_{\text{mel}}(G) + \lambda_{\text{fm}} \mathcal{L}_{\text{fm}}(G)\]

HiFi-GAN实现了与WaveNet相当的质量，同时速度快了1000倍以上，使得在单个GPU上实时生成成为可能。
神经源-滤波器（NSF）模型 将传统信号处理与神经网络相结合。在经典的源-滤波器模型中，浊音由源激励（基频 $F_0$ 处的周期脉冲序列）通过声道滤波器（频谱包络）产生。NSF模型用神经网络替换手工设计的滤波器，同时保持显式的源信号。输入的 $F_0$ 轮廓提供了纯数据驱动声码器有时难以处理的精细音高控制。
声学模型：Tacotron（Wang 等，2017）是第一个直接将字符序列转换为梅尔频谱图的端到端神经TTS系统。它使用带有注意力机制的编码器-解码器架构（第07章）。编码器使用卷积库、高速网络和双向GRU处理字符/音素序列。解码器是一个自回归GRU，逐帧预测梅尔帧，使用前一帧和注意力上下文作为输入。
Tacotron 2（Shen 等，2018）显著改进了架构。编码器是一个3层一维卷积堆栈，后跟双向LSTM（第06章）。解码器是一个2层LSTM，带有位置敏感注意力，其注意力机制不仅基于编码器输出和解码器状态，还基于之前步骤的累积注意力权重。这防止了注意力跳过或重复单词的常见失败模式。

Tacotron 2架构：带卷积层和BiLSTM的字符/音素编码器，对齐到梅尔频谱图帧的位置敏感注意力，带停止词元预测的自回归解码器

在解码器步骤 $i$ 中，对编码器位置 $j$ 的位置敏感注意力能量为：

\[e_{i,j} = w^T \tanh(W_s s_{i-1} + W_h h_j + W_f f_{i,j} + b)\]

其中 $s_{i-1}$ 是前一个解码器状态，$h_j$ 是位置 $j$ 的编码器输出，$f_{i,j}$ 是通过将累积注意力权重 $\sum_{k<i} \alpha_{k,j}$ 与一维卷积滤波器卷积获得的位置特征。注意力权重为 $\alpha_{i,j} = \text{softmax}(e_{i,j})$。
Tacotron 2的解码器还在每一步预测一个停止词元概率，指示梅尔频谱图何时完成。输出的梅尔频谱图随后被传递给声码器（最初是WaveNet，后来被HiFi-GAN或类似模型取代）。
Tacotron 2的自回归特性意味着合成速度受限于梅尔帧的数量。对于典型的每秒80帧的梅尔频谱图，一个5秒的话语需要400个顺序解码器步骤。
FastSpeech（Ren 等，2019）使用非自回归声学模型解决了速度问题。FastSpeech不是顺序生成梅尔帧，而是并行生成所有帧。关键的挑战是确定每个音素应该产生多少个梅尔帧，FastSpeech通过时长预测器处理这一点。
时长预测器是一个小型卷积网络，预测每个音素的整数时长（梅尔帧数）。在训练期间，使用预训练的自回归教师模型（Tacotron 2）的注意力对齐提取真实时长。在推理期间，预测的时长用于通过长度调节器将音素级隐藏序列扩展到帧级，长度调节器简单地将每个音素的隐藏表示重复预测的帧数。
FastSpeech 2（Ren 等，2021）通过移除教师-学生蒸馏改进了FastSpeech。它直接使用强制对齐（来自第02章的声学模型框架）提取真实时长，并添加了针对音高（$F_0$）和能量的显式方差适配器，除了时长之外。每个适配器是一个小型卷积预测器，其输出调节解码器：

\[ \begin{aligned} \hat{d}_i &= \text{DurationPredictor}(h_i) \\ \hat{p}_i &= \text{PitchPredictor}(h_i) \\ \hat{e}_i &= \text{EnergyPredictor}(h_i) \end{aligned} \]

其中 $h_i$ 是音素 $i$ 的编码器隐藏状态。在训练时使用真实值；在推理时，预测值提供了对韵律的显式控制。这种可控性是FastSpeech 2的主要优势：调整音高、速度或能量就像缩放预测器输出一样简单。
FastSpeech 2在推理时通常比Tacotron 2快10-20倍，并避免了常见的自回归失败模式，如跳词、重复和注意力坍塌。
VITS（Kim 等，2021）是一个端到端TTS模型，直接从文本生成波形，消除了单独的声码器阶段。VITS结合了条件变分自编码器（第06章）、正则化流和对抗训练。后验编码器将真实梅尔频谱图映射到潜在空间，先验编码器将音素（通过基于Transformer的文本编码器和时长预测器）映射到相同的潜在空间，解码器（基于HiFi-GAN）从潜在样本生成波形。
VITS的训练目标结合了：
- 重建损失：VAE强制潜在分布编码声学信息
- KL散度：将文本条件的先验与音频条件的后验对齐
- 对抗损失：判别器确保波形质量
- 时长损失：训练随机时长预测器
VITS产生的质量高于两阶段系统（FastSpeech 2 + HiFi-GAN），因为声学模型和声码器被联合优化，避免了预测梅尔频谱图与真实梅尔频谱图之间的不匹配，这种不匹配会降低两阶段系统的性能。
VALL-E（Wang 等，2023）从根本上将TTS重新定义为对离散音频词元的语言建模问题。它使用神经音频编解码器（EnCodec）将语音表示为来自多个码本级别的离散码序列。给定文本提示和3秒的注册话语（也编码为离散词元），VALL-E使用Transformer语言模型自回归地预测音频词元。
VALL-E使用两个模型：一个自回归（AR）模型逐词元生成第一个码本级别，以及一个非自回归（NAR）模型以第一个级别和彼此为条件并行预测剩余的码本级别。这种编解码器语言模型方法实现了惊人的零样本语音克隆：一个3秒的样本足以再现说话者的声音、音色，甚至情感语调。
StyleTTS（Li 等，2022）和StyleTTS 2将语音解耦为内容和风格成分。风格编码器从参考音频中提取风格向量，捕获说话者身份、韵律和录音条件。在推理时，风格可以从学习到的先验分布中采样或从参考话语中转移。StyleTTS 2使用扩散模型（第08章）作为风格先验，生成多样且自然的韵律。
Kokoro（2024）是一个轻量级、高质量的开源TTS模型，以其小巧的尺寸（~82M参数）和令人印象深刻的自然度而著称。它使用受StyleTTS 2启发的架构，带有基于扩散的风格先验和微调的ISTFTNet声码器，该声码器直接预测STFT系数（来自第01章）而不是原始波形样本。尽管尺寸仅为VALL-E等模型的零头，但Kokoro在英语、日语、法语、韩语和中文上达到了接近人类的自然度，证明了精心策划的训练数据和高效的架构设计可以与蛮力规模竞争。Kokoro的小体积使其适用于本地和边缘部署。
Orpheus（Canopy Labs，2025）是一个开源TTS模型家族（1B和3B参数），建立在VALL-E开创的编解码器语言模型范式之上。Orpheus进一步推进了这个想法，使用一个LLM骨干网络（微调的Llama 3）直接生成SNAC音频编解码器词元。其突出特点是类人的情感表现力：它能以惊人的自然度处理笑声、叹息、犹豫和情感韵律。Orpheus可以通过输入文本中的标签（如 [laugh] 或 [sigh]）进行提示，从而对副语言表达进行精细控制。
Dia（Nari Labs，2025）是一个开源的对话TTS模型，能够从单一文本转录生成逼真的多说话者对话。Dia基于1.6B参数的编码器-解码器Transformer，处理对话中的话轮转换、说话者特定声音和非语言提示（笑声、停顿）。它还支持从短音频提示进行语音克隆，实现对话上下文中的零样本说话者生成。
Sesame CSM（对话语音模型，2025）专注于自然的多人对话语音。Sesame不是为朗读式TTS进行优化，而是模拟真实对话的动态：反馈信号（“嗯哼”）、打断、说话者之间的节奏变化以及情感响应。该模型使用以对话上下文（文本和音频历史）为条件的Transformer骨干网络，产生适应对话流程风格的语音。
Fish Speech（Fish Audio，2024）是一个开源的TTS系统，使用双自回归架构：一个大型语言模型从文本生成语义词元，一个较小的模型将这些词元转换为VQGAN声学词元，然后由声码器解码为波形。Fish Speech支持从10-15秒参考音频进行零样本语音克隆，并实现适合实时应用的低延迟。其模块化设计允许独立更换组件（例如，不同的声码器）。
ChatTTS（2024）是一个开源的对话式TTS模型，专为聊天机器人和虚拟助手等对话应用设计。它通过在文本输入中嵌入特殊词元，生成自然的、对话式的语音，并对韵律特征（笑声、停顿、填充词）进行精细控制。ChatTTS支持中英文混合合成和多说话人生成。
Bark（Suno，2023）是一个基于Transformer的开源模型，根据文本提示生成语音、音乐和音效。它使用三个阶段的Transformer模型流程（文本 → 语义词元 → 粗声学词元 → 细声学词元），并支持语音克隆、多语言合成以及音乐和环境声音等非语音音频。Bark的通用性以可控性为代价——它不如专用TTS系统精确，但更灵活。
Parler-TTS（Hugging Face，2024）采用自然语言描述的方式进行语音控制：用户不需要提供参考音频片段，而是提供文本描述，如“一个在安静房间里的、声音温暖的、富有表现力的女性说话者”。Parler-TTS在带注释的语音数据上训练，每个话语都配有一个自然语言描述的说话风格，从而实现无需任何参考音频的直观控制。
Neuphonic 是一个基于API的TTS平台，针对超低延迟语音合成进行了优化，面向实时语音代理和对话式AI应用。它通过流式架构实现了小于100毫秒的首字节音频时间，该架构在完整输入文本可用之前就开始生成音频。Neuphonic专注于部署和延迟优化层，而非新颖的模型架构，为现代神经TTS提供生产级基础设施。
KittenTTS 是一个紧凑、快速的TTS模型，专为效率低下资源部署设计。它优先考虑最小化延迟和小模型尺寸，用于边缘和嵌入式应用，以一定的自然度为代价换取在CPU和移动设备上的实时性能。
现代TTS领域正在分化为两种范式：(1) 编解码器语言模型（VALL-E、Orpheus、Fish Speech）将语音生成视为离散音频码上的下一个词元预测，利用LLM的扩展法则；(2) 基于流/扩散的模型（VITS、StyleTTS 2、Kokoro）通过迭代细化生成连续的梅尔频谱图或波形。编解码器语言模型在零样本克隆和表现力方面表现出色；流/扩散模型往往更小、更快。两者都迅速向人类水平的自然度收敛。
韵律建模 控制着语音的“音乐”：音高、时长、能量、节奏和语调。没有良好的韵律，合成的语音即使单个音素清晰也会听起来平淡和机器人化。把韵律想象成单调的GPS语音和富有表现力的有声读物讲述者之间的区别。
音高（基频 $F_0$）是语音感知的高低。它在问句末尾上升，在陈述句末尾下降，在情感语音中连续变化。$F_0$ 使用CREPE（神经音高跟踪器）或YIN（基于自相关，第01章）等算法从音频中提取。在TTS中，音高要么由声学模型预测（FastSpeech 2的音高预测器），要么隐式学习（Tacotron 2）。
时长决定语速和节奏。重读音节更长，功能词缩短，停顿标记短语边界。时长建模在非自回归模型（FastSpeech）中是显式的，在自回归模型（Tacotron的注意力对齐决定时长）中是隐式的。
能量（响度）携带重音。“我没说HE偷了它”与“我没说他STOLE它”具有完全不同的含义，仅通过能量模式传达。
风格嵌入 捕获更高层次的韵律模式。全局风格词元（GST） 框架（Wang 等，2018）学习一组风格词元（对学习到的嵌入集的软注意力），这些词元捕获说话风格，如“兴奋”、“悲伤”或“耳语”。风格嵌入从参考话语中提取并加到编码器输出中，允许在推理时进行风格转移。
语音转换（VC） 改变话语的说话者身份，同时保留语言内容。想象一下录制自己的声音，但输出听起来像一个特定目标说话者。VC需要将说话者身份与内容解耦。

语音转换流程：源语音被分解为内容表示和说话者嵌入，目标说话者嵌入替换源，解码器用目标声音重建语音

说话者嵌入（在第04章中进一步详述）将说话者身份编码为固定维度的向量。这些可以来自预训练的说话者验证模型（x-vectors、ECAPA-TDNN）。在VC中，源语音被编码为与说话者无关的内容表示，然后用目标说话者嵌入解码。
解耦表示 将语音分解为独立因素：内容（音素）、说话者身份、音高和节奏。方法包括：
- 信息瓶颈：压缩内容表示使其失去说话者信息（AutoVC）
- 对抗训练：在内容表示上训练说话者分类器，并使用梯度反转去除说话者信息
- 向量量化：VQ-VAE强制内容通过离散瓶颈，自然剥离说话者身份（因为码本条目代表音素类别，而非说话者特征）
语音克隆 用目标说话者的声音合成语音。多说话者TTS 在许多说话者的数据上训练，以说话者嵌入为条件。在推理时，从注册音频中提取新说话者的嵌入，并用于条件生成。
少样本语音克隆 使用少量数据（几分钟）适应新说话者。说话者编码器从注册音频中提取嵌入，TTS模型以该嵌入为条件生成语音。这是SV2TTS（Jia 等，2018）中使用的方法：一个单独训练的说话者编码器，一个以说话者嵌入为条件的Tacotron 2合成器，以及一个WaveRNN声码器。
零样本语音克隆 根本不需要适应：一个短的发音（3-30秒）就足够了。VALL-E通过将注册音频视为语言模型的提示来实现这一点。模型学会以相同的声音继续生成，因为它是在大规模多说话者数据上训练的，其中话语内声音一致性是统计常态。
语音活动检测（VAD） 在每个时间帧回答一个简单的二元问题：是否有人在说话？尽管简单，但VAD是ASR（第02章）、说话者日志（第04章）和降噪（第05章）的关键预处理步骤。一个好的VAD通过跳过静音减少计算量，并通过防止噪声被当作语音处理来提高准确性。
经典VAD使用能量阈值（语音比静音响）、过零率（语音具有特征性的过零模式）和频谱特征。这些方法在信噪比低的噪声环境中失效。
神经VAD 模型将问题视为帧级二元分类。一个小型RNN或CNN接收声学特征（来自第01章的对数梅尔能量）并预测语音/非语音概率。
WebRTC VAD（Google）是一个经典的轻量级VAD，在简单频谱特征上使用基于GMM的分类器。它有四个攻击性级别（0-3），速度极快，但在处理音乐、非语音发声和低SNR环境时表现不佳。由于其零依赖的简单性，它仍被广泛用作基线。
Silero VAD（Silero Team，2021）是生产环境中事实上的标准神经VAD。其架构是一小组深度可分离的一维卷积（第08章MobileNet思想应用于音频），后跟一个用于时间上下文的单层LSTM，最后是一个线性头，输出每帧的语音概率。整个模型小于2MB（~1M参数），以30-100毫秒的块处理音频。
- 输入：原始的16 kHz音频（无需手动特征提取——卷积前端直接从波形学习自己的特征）。
- 带状态的分块推理：LSTM隐藏状态在块之间传递，因此模型可以处理流式音频而无需重新处理完整历史。每次调用处理一个30、60或100毫秒的块，并返回 $[0, 1]$ 中的语音概率。
- 自适应阈值：Silero VAD不使用单一的固定阈值，而是使用独立的开始和结束阈值，并设定最短语音/静音持续时间，防止在嘈杂边界上快速切换。一个语音段必须超过开始阈值达到最短持续时间才能被确认，并且静音必须持续低于结束阈值才能关闭该段。
- 性能：Silero VAD在CPU上的实时因子为1-2%（处理1秒音频大约需要10-20毫秒），使其适用于边缘设备、手机和实时管道。在嘈杂和音乐为主的音频上，它显著优于WebRTC VAD，同时仍然足够小巧，可以部署在设备上。
- Silero VAD常被用作Whisper（第02章）的前端，在转录前将长音频分割成话语级块，也用于说话者日志管道（第04章），在提取说话者嵌入之前识别语音区域。
声学活动检测（AAD） 将VAD推广到检测任何声学活动，而不仅仅是语音。这在智能家居设备、安全系统和野生动物监测中很有用。AAD模型检测诸如玻璃破碎、狗叫或警报等事件，通常使用第04章中描述的音频分类框架。
TTS评估指标 衡量客观质量和主观自然度：
- 平均意见分（MOS）：人类听众对自然度按1-5分评分。黄金标准，但昂贵且缓慢。
- 梅尔倒谱失真（MCD）：衡量合成和参考梅尔倒谱之间的距离。越低越好，但并不总是与感知相关。
- PESQ / POLQA：最初为电话设计的标准化感知评估指标。
- 说话者相似度：合成音频和参考音频的说话者嵌入之间的余弦相似度（与语音克隆相关）。
- 可懂度：通过将合成音频输入ASR系统（第02章）并计算WER来测量。

编程任务（使用CoLab或notebook）¶

任务1：从梅尔频谱图的Griffin-Lim声码器。 实现Griffin-Lim迭代相位重建算法，将梅尔频谱图转换回波形。这演示了声码器问题以及为什么需要神经声码器。

import jax
import jax.numpy as jnp
import matplotlib.pyplot as plt

# 生成合成波形（模拟元音的谐波和）
sr = 16000
duration = 1.0
t = jnp.linspace(0, duration, int(sr * duration))
f0 = 220.0  # 基频
waveform = (
    0.6 * jnp.sin(2 * jnp.pi * f0 * t) +
    0.3 * jnp.sin(2 * jnp.pi * 2 * f0 * t) +
    0.1 * jnp.sin(2 * jnp.pi * 3 * f0 * t)
)

# 计算STFT
n_fft = 1024
hop_length = 256
window = jnp.hanning(n_fft)

def stft(signal, n_fft, hop_length, window):
    """计算短时傅里叶变换。"""
    n_frames = 1 + (len(signal) - n_fft) // hop_length
    frames = jnp.stack([
        signal[i * hop_length : i * hop_length + n_fft] * window
        for i in range(n_frames)
    ])
    return jnp.fft.rfft(frames, n=n_fft)

def istft(stft_matrix, hop_length, window, length):
    """使用重叠相加计算逆STFT。"""
    n_fft = (stft_matrix.shape[1] - 1) * 2
    n_frames = stft_matrix.shape[0]
    frames = jnp.fft.irfft(stft_matrix, n=n_fft)
    frames = frames * window[None, :]
    output = jnp.zeros(length)
    for i in range(n_frames):
        start = i * hop_length
        end = start + n_fft
        if end <= length:
            output = output.at[start:end].add(frames[i])
    return output

# 前向STFT
S = stft(waveform, n_fft, hop_length, window)
magnitude = jnp.abs(S)

# 梅尔滤波器组
n_mels = 80
mel_low = 0.0
mel_high = 2595 * jnp.log10(1 + (sr / 2) / 700)
mel_points = jnp.linspace(mel_low, mel_high, n_mels + 2)
hz_points = 700 * (10 ** (mel_points / 2595) - 1)
freq_bins = jnp.floor((n_fft + 1) * hz_points / sr).astype(int)

mel_filterbank = jnp.zeros((n_mels, n_fft // 2 + 1))
for m in range(n_mels):
    f_left = freq_bins[m]
    f_center = freq_bins[m + 1]
    f_right = freq_bins[m + 2]
    for k in range(f_left, f_center):
        mel_filterbank = mel_filterbank.at[m, k].set(
            (k - f_left) / max(f_center - f_left, 1)
        )
    for k in range(f_center, f_right):
        mel_filterbank = mel_filterbank.at[m, k].set(
            (f_right - k) / max(f_right - f_center, 1)
        )

# 转到梅尔再返回（伪逆）
mel_spec = magnitude @ mel_filterbank.T
magnitude_reconstructed = mel_spec @ jnp.linalg.pinv(mel_filterbank.T)
magnitude_reconstructed = jnp.maximum(magnitude_reconstructed, 1e-7)

# Griffin-Lim算法
def griffin_lim(magnitude, n_iter, hop_length, window, signal_length):
    """迭代相位重建。"""
    n_fft = (magnitude.shape[1] - 1) * 2
    key = jax.random.PRNGKey(42)
    phase = jax.random.uniform(key, magnitude.shape, minval=-jnp.pi, maxval=jnp.pi)

    for _ in range(n_iter):
        complex_spec = magnitude * jnp.exp(1j * phase)
        signal = istft(complex_spec, hop_length, window, signal_length)
        reanalysis = stft(signal, n_fft, hop_length, window)
        phase = jnp.angle(reanalysis)

    complex_spec = magnitude * jnp.exp(1j * phase)
    return istft(complex_spec, hop_length, window, signal_length)

reconstructed = griffin_lim(magnitude_reconstructed, n_iter=60, hop_length=hop_length,
                            window=window, signal_length=len(waveform))

# 绘制比较
fig, axes = plt.subplots(3, 1, figsize=(12, 8))

axes[0].plot(t[:1000], waveform[:1000], color='#3498db', linewidth=0.8)
axes[0].set_title('原始波形')
axes[0].set_ylabel('幅度')

axes[1].imshow(jnp.log1p(mel_spec.T), aspect='auto', origin='lower', cmap='magma')
axes[1].set_title('梅尔频谱图（中间表示）')
axes[1].set_ylabel('梅尔频带')

axes[2].plot(t[:1000], reconstructed[:1000], color='#e74c3c', linewidth=0.8)
axes[2].set_title('Griffin-Lim重建波形（60次迭代）')
axes[2].set_xlabel('时间 (s)')
axes[2].set_ylabel('幅度')

plt.tight_layout()
plt.show()

# 测量重建误差
mse = jnp.mean((waveform[:len(reconstructed)] - reconstructed[:len(waveform)]) ** 2)
print(f"原始与重建之间的MSE: {mse:.6f}")
print("注意：通过梅尔反变换造成的相位信息丢失会导致伪影。")

任务2：时长预测器（FastSpeech风格）。 训练一个小型卷积时长预测器，将音素嵌入映射到时长。这是实现非自回归TTS的核心组件。

import jax
import jax.numpy as jnp
import jax.random as jr
import matplotlib.pyplot as plt

# 模拟带有真实时长的音素序列
# 在实际TTS中，时长来自强制对齐或教师注意力
def generate_synthetic_data(key, n_samples=200, max_phonemes=30, embed_dim=64):
    """生成合成音素嵌入和时长。"""
    keys = jr.split(key, 4)
    lengths = jr.randint(keys[0], (n_samples,), 5, max_phonemes)

    all_embeddings = []
    all_durations = []
    all_masks = []

    for i in range(n_samples):
        L = int(lengths[i])
        emb = jr.normal(keys[1], (max_phonemes, embed_dim))
        # 时长：元音（偶数索引）更长，辅音更短
        base_dur = jnp.where(jnp.arange(max_phonemes) % 2 == 0, 8.0, 4.0)
        noise = jr.normal(jr.fold_in(keys[2], i), (max_phonemes,)) * 1.5
        dur = jnp.clip(base_dur + noise, 1.0, 20.0).astype(jnp.float32)
        mask = (jnp.arange(max_phonemes) < L).astype(jnp.float32)

        all_embeddings.append(emb)
        all_durations.append(dur * mask)
        all_masks.append(mask)

    return (jnp.stack(all_embeddings), jnp.stack(all_durations),
            jnp.stack(all_masks))

key = jr.PRNGKey(42)
embeddings, durations, masks = generate_synthetic_data(key)

# 时长预测器：2层一维卷积 + 线性投影
def init_duration_predictor(key, embed_dim=64, hidden_dim=128, kernel_size=3):
    """初始化时长预测器权重。"""
    keys = jr.split(key, 4)
    scale1 = jnp.sqrt(2.0 / (embed_dim * kernel_size))
    scale2 = jnp.sqrt(2.0 / (hidden_dim * kernel_size))
    params = {
        'conv1_w': jr.normal(keys[0], (kernel_size, embed_dim, hidden_dim)) * scale1,
        'conv1_b': jnp.zeros(hidden_dim),
        'conv2_w': jr.normal(keys[1], (kernel_size, hidden_dim, hidden_dim)) * scale2,
        'conv2_b': jnp.zeros(hidden_dim),
        'linear_w': jr.normal(keys[2], (hidden_dim, 1)) * jnp.sqrt(2.0 / hidden_dim),
        'linear_b': jnp.zeros(1),
    }
    return params

def duration_predictor(params, x):
    """从音素嵌入预测对数时长。x: (batch, seq, embed)。"""
    # 卷积层1 + ReLU
    h = jax.lax.conv_general_dilated(
        x.transpose(0, 2, 1),  # (batch, embed, seq)
        params['conv1_w'].transpose(2, 1, 0),  # (out, in, kernel)
        window_strides=(1,), padding='SAME'
    ).transpose(0, 2, 1) + params['conv1_b']  # 回到 (batch, seq, hidden)
    h = jax.nn.relu(h)

    # 卷积层2 + ReLU
    h = jax.lax.conv_general_dilated(
        h.transpose(0, 2, 1),
        params['conv2_w'].transpose(2, 1, 0),
        window_strides=(1,), padding='SAME'
    ).transpose(0, 2, 1) + params['conv2_b']
    h = jax.nn.relu(h)

    # 线性投影到标量
    log_dur = (h @ params['linear_w'] + params['linear_b']).squeeze(-1)
    return log_dur

# 损失：对数时长的MSE（FastSpeech中的标准）
def loss_fn(params, embeddings, durations, masks):
    log_dur_pred = duration_predictor(params, embeddings)
    log_dur_true = jnp.log(jnp.clip(durations, 1.0, None))
    sq_err = (log_dur_pred - log_dur_true) ** 2 * masks
    return jnp.sum(sq_err) / jnp.sum(masks)

grad_fn = jax.jit(jax.value_and_grad(loss_fn))

# 训练循环
params = init_duration_predictor(jr.PRNGKey(0))
lr = 1e-3
losses = []

for epoch in range(300):
    loss_val, grads = grad_fn(params, embeddings, durations, masks)
    params = jax.tree.map(lambda p, g: p - lr * g, params, grads)
    losses.append(float(loss_val))

# 评估样本
log_dur_pred = duration_predictor(params, embeddings[:1])
dur_pred = jnp.exp(log_dur_pred[0])
dur_true = durations[0]
mask = masks[0]
valid_len = int(jnp.sum(mask))

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

axes[0].plot(losses, color='#3498db', linewidth=1.5)
axes[0].set_xlabel('Epoch')
axes[0].set_ylabel('MSE损失（对数时长）')
axes[0].set_title('时长预测器训练')
axes[0].set_yscale('log')

x_pos = jnp.arange(valid_len)
width = 0.35
axes[1].bar(x_pos - width/2, dur_true[:valid_len], width, color='#27ae60',
            label='真实值', alpha=0.8)
axes[1].bar(x_pos + width/2, dur_pred[:valid_len], width, color='#e74c3c',
            label='预测值', alpha=0.8)
axes[1].set_xlabel('音素索引')
axes[1].set_ylabel('时长（帧）')
axes[1].set_title('时长预测 vs 真实值')
axes[1].legend()

plt.tight_layout()
plt.show()

任务3：使用上采样卷积的简单神经声码器。 构建一个最小化的HiFi-GAN风格生成器，使用转置卷积和残差块将梅尔频谱图上采样为波形。

import jax
import jax.numpy as jnp
import jax.random as jr
import matplotlib.pyplot as plt

def init_residual_block(key, channels, kernel_size, dilation):
    """初始化一个膨胀残差卷积块。"""
    k1, k2 = jr.split(key)
    scale = jnp.sqrt(2.0 / (channels * kernel_size))
    return {
        'conv1_w': jr.normal(k1, (kernel_size, channels, channels)) * scale,
        'conv1_b': jnp.zeros(channels),
        'conv2_w': jr.normal(k2, (kernel_size, channels, channels)) * scale,
        'conv2_b': jnp.zeros(channels),
        'dilation': dilation
    }

def residual_block(params, x):
    """x: (batch, time, channels)。带LeakyReLU的膨胀卷积残差块。"""
    h = jax.nn.leaky_relu(x, negative_slope=0.1)
    # 简化：使用标准卷积（膨胀在概念上处理）
    h = jax.lax.conv_general_dilated(
        h.transpose(0, 2, 1),
        params['conv1_w'].transpose(2, 1, 0),
        window_strides=(1,),
        padding='SAME',
        rhs_dilation=(params['dilation'],)
    ).transpose(0, 2, 1) + params['conv1_b']
    h = jax.nn.leaky_relu(h, negative_slope=0.1)
    h = jax.lax.conv_general_dilated(
        h.transpose(0, 2, 1),
        params['conv2_w'].transpose(2, 1, 0),
        window_strides=(1,),
        padding='SAME'
    ).transpose(0, 2, 1) + params['conv2_b']
    return x + h

def init_generator(key, n_mels=80, upsample_rates=(8, 8, 4),
                   channels=128):
    """初始化最小化的HiFi-GAN风格生成器。"""
    keys = jr.split(key, 10)
    params = {}

    # 输入投影：梅尔频带 -> 通道
    params['input_w'] = jr.normal(keys[0], (7, n_mels, channels)) * 0.02
    params['input_b'] = jnp.zeros(channels)

    # 上采样块（转置卷积）
    in_ch = channels
    for i, rate in enumerate(upsample_rates):
        k_size = rate * 2
        scale = jnp.sqrt(2.0 / (in_ch * k_size))
        out_ch = in_ch // 2
        params[f'up{i}_w'] = jr.normal(keys[i+1], (k_size, in_ch, out_ch)) * scale
        params[f'up{i}_b'] = jnp.zeros(out_ch)
        # 每个尺度的残差块
        params[f'res{i}_0'] = init_residual_block(jr.fold_in(keys[i+4], 0),
                                                    out_ch, 3, 1)
        params[f'res{i}_1'] = init_residual_block(jr.fold_in(keys[i+4], 1),
                                                    out_ch, 3, 3)
        in_ch = out_ch

    # 输出投影到单声道波形
    params['output_w'] = jr.normal(keys[8], (7, in_ch, 1)) * 0.02
    params['output_b'] = jnp.zeros(1)
    params['upsample_rates'] = upsample_rates

    return params

def generator_forward(params, mel):
    """mel: (batch, time, n_mels) -> 波形: (batch, time * prod(rates), 1)。"""
    # 输入投影
    h = jax.lax.conv_general_dilated(
        mel.transpose(0, 2, 1),
        params['input_w'].transpose(2, 1, 0),
        window_strides=(1,), padding='SAME'
    ).transpose(0, 2, 1) + params['input_b']

    for i, rate in enumerate(params['upsample_rates']):
        h = jax.nn.leaky_relu(h, negative_slope=0.1)
        # 通过转置卷积上采样
        k_size = rate * 2
        h = jax.lax.conv_transpose(
            h.transpose(0, 2, 1),
            params[f'up{i}_w'].transpose(2, 1, 0),
            strides=(rate,),
            padding='SAME'
        ).transpose(0, 2, 1) + params[f'up{i}_b']
        # 残差块
        h = residual_block(params[f'res{i}_0'], h)
        h = residual_block(params[f'res{i}_1'], h)

    h = jax.nn.leaky_relu(h, negative_slope=0.1)
    out = jax.lax.conv_general_dilated(
        h.transpose(0, 2, 1),
        params['output_w'].transpose(2, 1, 0),
        window_strides=(1,), padding='SAME'
    ).transpose(0, 2, 1) + params['output_b']

    return jnp.tanh(out)

# 创建合成梅尔频谱图（模拟元音）
n_mels = 80
n_frames = 50
mel = jnp.zeros((1, n_frames, n_mels))
# 在低频梅尔频带添加能量（模拟共振峰）
mel = mel.at[:, :, 5:15].set(1.0)
mel = mel.at[:, :, 20:25].set(0.6)

# 初始化和运行生成器
key = jr.PRNGKey(42)
params = init_generator(key, n_mels=n_mels, upsample_rates=(8, 8, 4),
                         channels=128)
waveform = generator_forward(params, mel)

print(f"输入梅尔形状:  {mel.shape}")
print(f"输出波形形状: {waveform.shape}")
print(f"上采样因子: {8 * 8 * 4} = {8*8*4}x")

fig, axes = plt.subplots(2, 1, figsize=(12, 6))

axes[0].imshow(mel[0].T, aspect='auto', origin='lower', cmap='magma')
axes[0].set_title('输入梅尔频谱图')
axes[0].set_ylabel('梅尔频带')
axes[0].set_xlabel('帧')

waveform_np = waveform[0, :, 0]
axes[1].plot(waveform_np[:2000], color='#9b59b6', linewidth=0.5)
axes[1].set_title('生成器输出波形（未训练 - 随机噪声）')
axes[1].set_ylabel('幅度')
axes[1].set_xlabel('样本')

plt.tight_layout()
plt.show()
print("注意：输出是噪声，因为生成器未训练。")
print("在实践中，对抗+梅尔损失训练会将其塑造成语音。")

任务4：使用简单RNN的语音活动检测。 在合成音频特征上训练一个基于GRU的小型VAD模型，将帧分类为语音或静音。

import jax
import jax.numpy as jnp
import jax.random as jr
import matplotlib.pyplot as plt

# 生成带有语音/静音标签的合成对数梅尔能量特征
def generate_vad_data(key, n_sequences=100, n_frames=200, n_features=40):
    """模拟对数梅尔特征：语音区域能量更高且有结构。"""
    keys = jr.split(key, 5)
    all_features = []
    all_labels = []

    for i in range(n_sequences):
        k = jr.fold_in(keys[0], i)
        k1, k2, k3 = jr.split(k, 3)

        # 随机的语音/静音模式
        label = jnp.zeros(n_frames)
        n_segments = jr.randint(k1, (), 2, 6)
        for seg in range(int(n_segments)):
            start = jr.randint(jr.fold_in(k2, seg), (), 0, n_frames - 20)
            length = jr.randint(jr.fold_in(k3, seg), (), 10, 50)
            end = jnp.minimum(start + length, n_frames)
            label = label.at[int(start):int(end)].set(1.0)

        # 特征：语音帧具有更高的能量+频谱结构
        noise = jr.normal(jr.fold_in(keys[1], i), (n_frames, n_features)) * 0.3
        speech_pattern = jnp.outer(label, jnp.exp(-jnp.arange(n_features) / 15.0))
        features = speech_pattern * 2.0 + noise + 0.1

        all_features.append(features)
        all_labels.append(label)

    return jnp.stack(all_features), jnp.stack(all_labels)

key = jr.PRNGKey(123)
features, labels = generate_vad_data(key)
train_features, train_labels = features[:80], labels[:80]
test_features, test_labels = features[80:], labels[80:]

# 基于GRU的简单VAD模型
def init_vad_model(key, input_dim=40, hidden_dim=64):
    keys = jr.split(key, 6)
    scale_ih = jnp.sqrt(2.0 / input_dim)
    scale_hh = jnp.sqrt(2.0 / hidden_dim)
    return {
        'W_z': jr.normal(keys[0], (input_dim, hidden_dim)) * scale_ih,
        'U_z': jr.normal(keys[1], (hidden_dim, hidden_dim)) * scale_hh,
        'b_z': jnp.zeros(hidden_dim),
        'W_r': jr.normal(keys[2], (input_dim, hidden_dim)) * scale_ih,
        'U_r': jr.normal(keys[3], (hidden_dim, hidden_dim)) * scale_hh,
        'b_r': jnp.zeros(hidden_dim),
        'W_h': jr.normal(keys[4], (input_dim, hidden_dim)) * scale_ih,
        'U_h': jr.normal(keys[5], (hidden_dim, hidden_dim)) * scale_hh,
        'b_h': jnp.zeros(hidden_dim),
        'W_out': jr.normal(jr.fold_in(keys[0], 99), (hidden_dim, 1)) * 0.1,
        'b_out': jnp.zeros(1),
    }

def gru_step(params, h, x):
    """单步GRU。"""
    z = jax.nn.sigmoid(x @ params['W_z'] + h @ params['U_z'] + params['b_z'])
    r = jax.nn.sigmoid(x @ params['W_r'] + h @ params['U_r'] + params['b_r'])
    h_tilde = jnp.tanh(x @ params['W_h'] + (r * h) @ params['U_h'] + params['b_h'])
    h_new = (1 - z) * h + z * h_tilde
    return h_new

def vad_forward(params, x):
    """x: (batch, time, features) -> logits: (batch, time)。"""
    batch_size, n_frames, _ = x.shape
    hidden_dim = params['W_z'].shape[1]
    h = jnp.zeros((batch_size, hidden_dim))

    outputs = []
    for t in range(n_frames):
        h = gru_step(params, h, x[:, t, :])
        logit = (h @ params['W_out'] + params['b_out']).squeeze(-1)
        outputs.append(logit)

    return jnp.stack(outputs, axis=1)

def bce_loss(params, features, labels):
    """VAD的二元交叉熵损失。"""
    logits = vad_forward(params, features)
    probs = jax.nn.sigmoid(logits)
    probs = jnp.clip(probs, 1e-7, 1 - 1e-7)
    loss = -(labels * jnp.log(probs) + (1 - labels) * jnp.log(1 - probs))
    return jnp.mean(loss)

grad_fn = jax.jit(jax.value_and_grad(bce_loss))

# 训练
params = init_vad_model(jr.PRNGKey(0))
lr = 5e-3
losses = []

for epoch in range(200):
    loss_val, grads = grad_fn(params, train_features, train_labels)
    params = jax.tree.map(lambda p, g: p - lr * g, params, grads)
    losses.append(float(loss_val))
    if epoch % 50 == 0:
        print(f"Epoch {epoch}: loss = {loss_val:.4f}")

# 在测试集上评估
test_logits = vad_forward(params, test_features)
test_preds = (jax.nn.sigmoid(test_logits) > 0.5).astype(jnp.float32)
accuracy = jnp.mean(test_preds == test_labels)
print(f"\n测试准确率: {accuracy:.4f}")

# 可视化一个测试样本
idx = 0
fig, axes = plt.subplots(3, 1, figsize=(14, 7))

axes[0].imshow(test_features[idx].T, aspect='auto', origin='lower', cmap='magma')
axes[0].set_title('对数梅尔能量特征')
axes[0].set_ylabel('梅尔频带')

axes[1].fill_between(range(200), test_labels[idx], alpha=0.4, color='#27ae60',
                     label='真实值')
axes[1].plot(jax.nn.sigmoid(test_logits[idx]), color='#e74c3c',
             linewidth=1.5, label='预测概率')
axes[1].axhline(0.5, color='gray', linestyle='--', linewidth=0.8)
axes[1].set_ylabel('语音概率')
axes[1].legend()
axes[1].set_title('VAD预测')

axes[2].fill_between(range(200), test_labels[idx], alpha=0.4, color='#27ae60',
                     label='真实值')
axes[2].fill_between(range(200), test_preds[idx], alpha=0.4, color='#f39c12',
                     label='预测值（阈值=0.5）')
axes[2].set_ylabel('语音 / 静音')
axes[2].set_xlabel('帧')
axes[2].legend()
axes[2].set_title('VAD二元决策')

plt.tight_layout()
plt.show()