CLARINET: PARALLEL WAVE GENERATION IN END-TO-END TEXT-TO-SPEECH
Year: 2019

Abstract:
In this work, we propose a new solution for parallel wave generation by WaveNet. In contrast to parallel WaveNet (van den Oord et al., 2018), we distill a Gaussian inverse autoregressive flow from the autoregressive WaveNet by minimizing a regularized KL divergence between their highly-peaked output distributions. Our method computes the KL divergence in closed-form, which simplifies the training algorithm and provides very efficient distillation. In addition, we introduce the first text-to-wave neural architecture for speech synthesis, which is fully convolutional and enables fast end-to-end training from scratch. It significantly outperforms the previous pipeline that connects a text-to-spectrogram model to a separately trained WaveNet (Ping et al., 2018). We also successfully distill a parallel waveform synthesizer conditioned on the hidden representation in this end-to-end model. 1

heading: 1 INTRODUCTION
text: Speech synthesis, also called text-to-speech (TTS), is traditionally done with complex multi-stage hand-engineered pipelines (Taylor, 2009). Recent successes of deep learning methods for TTS lead to high-fidelity speech synthesis (van den Oord et al., 2016a), much simpler “end-to-end” pipelines (Sotelo et al., 2017; Wang et al., 2017; Ping et al., 2018), and a single TTS model that reproduces thousands of different voices (Ping et al., 2018).
WaveNet (van den Oord et al., 2016a) is an autoregressive generative model for waveform synthesis. It operates at a very high temporal resolution of raw audios (e.g., 24,000 samples per second). Its convolutional structure enables parallel processing at training by teacher-forcing the complete sequence of audio samples. However, the autoregressive nature of WaveNet makes it prohibitively slow at inference, because each sample must be drawn from the output distribution before it can be passed in as input at the next time-step. In order to generate high-fidelity speech in real time, one has to develop highly engineered inference kernels (e.g., Arık et al., 2017a).
Most recently, van den Oord et al. (2018) proposed a teacher-student framework to distill a parallel feed-forward network from an autoregressive teacher WaveNet. The non-autoregressive student model can generate high-fidelity speech at 20 times faster than real-time. To backpropagate through random samples during distillation, parallel WaveNet employs the mixture of logistics (MoL) distribution (Salimans et al., 2017) as the output distribution for teacher WaveNet, and a logistic distribution based inverse autoregressive flow (IAF) (Kingma et al., 2016) as the student model. It minimizes a set of losses including the KL divergence between the output distributions of the student and teacher networks. However, one has to apply Monte Carlo method to approximate the intractable KL divergence between the logistic and MoL distributions, which may introduce large variances in gradients for highly peaked distributions, and lead to an unstable training in practice.
In this work, we propose a novel parallel wave generation method based on the Gaussian IAF. Specifically, we make the following contributions:
∗These authors contributed equally to this work. Our method is named after the musical instrument clarinet, whose sound resembles human voice.
1Audio samples are in https://clarinet-demo.github.io/
1. We demonstrate that a single variance-bounded Gaussian is sufficient for modeling the raw waveform in WaveNet without degradation of audio quality. In contrast to the quantized surrogate loss (Salimans et al., 2017) in parallel WaveNet, our Gaussian autoregressive WaveNet is simply trained with maximum likelihood estimation (MLE).
2. We distill a Gaussian IAF from the autoregressive WaveNet by minimizing a regularized KL divergence between their peaked output distributions. Our method provides closed-form estimation of KL divergence, which largely simplifies the distillation algorithm and stabilizes the training process.
3. In previous studies, “end-to-end" speech synthesis actually refers to the text-to-spectrogram models with a separate waveform synthesizer (i.e., vocoder) (Sotelo et al., 2017; Wang et al., 2017). We introduce the first text-to-wave neural architecture for TTS, which is fully convolutional and enables fast end-to-end training from scratch. In our architecture, the WaveNet module is conditioned on the hidden states instead of mel-spectrograms (Ping et al., 2018; Shen et al., 2018), which is crucial to the success of training from scratch. Our text-to-wave model significantly outperforms the separately trained pipeline (Ping et al., 2018) in naturalness.
4. We also successfully distill a parallel neural vocoder conditioned on the learned hidden representation within the end-to-end architecture. The text-to-wave model with the parallel vocoder obtains competitive results as the model with an autoregressive vocoder.
We organize the rest of this paper as follows. Section 2 discusses related work. We propose the parallel wave generation method in Section 3, and present the text-to-wave architecture in Section 4. We report experimental results in Section 5 and conclude the paper in Section 6.

heading: 2 RELATED WORK
text: Neural speech synthesis has obtained the state-of-the-art results and gained a lot of attention recently. Several neural TTS systems were proposed, including Deep Voice 1 (Arık et al., 2017a), Deep Voice 2 (Arık et al., 2017b), Deep Voice 3 (Ping et al., 2018), Tacotron (Wang et al., 2017), Tacotron 2 (Shen et al., 2018), Char2Wav (Sotelo et al., 2017), and VoiceLoop (Taigman et al., 2018). Deep Voice 1 & 2 retain the traditional TTS pipeline, which has separate grapheme-to-phoneme, phoneme duration, fundamental frequency, and waveform synthesis models. In contrast, Deep Voice 3, Tacotron, and Char2Wav employ the attention based sequence-to-sequence models (Bahdanau et al., 2015), yielding more compact architectures. In the literature, these models are usually referred to as “end-to-end” speech synthesis. However, they actually depend on a traditional vocoder (Morise et al., 2016), the Griffin-Lim algorithm (Griffin and Lim, 1984), or a separately trained neural vocoder (Ping et al., 2018; Shen et al., 2018) to convert the predicted spectrogram to raw audio. In this work, we propose the first text-to-wave neural architecture for TTS based on Deep Voice 3 (Ping et al., 2018).
The neural network based vocoders, such as WaveNet (van den Oord et al., 2016a) and SampleRNN (Mehri et al., 2017), play a very important role in recent advances of speech synthesis. In a TTS system, WaveNet can be conditioned on linguistic features, fundamental frequency (F0), phoneme durations (van den Oord et al., 2016a; Arık et al., 2017a), or the predicted mel-spectrograms from a text-to-spectrogram model (Ping et al., 2018). We test our parallel waveform synthesis method by conditioning it on mel-spectrograms and hidden representation within the end-to-end model.
Normalizing flows (Rezende and Mohamed, 2015; Dinh et al., 2014) are a family of stochastic generative models, in which a simple initial distribution is transformed into a more complex one by applying a series of invertible transformations. Normalizing flow provides arbitrarily complex posterior distribution, making it well suited for the inference network in variational autoencoder (Kingma and Welling, 2014). Inverse autoregressive flow (IAF) (Kingma et al., 2016) is a special type of normalizing flow where each invertible transformation is based on an autoregressive neural network. Thus, IAF can reuse the most successful autoregressive architecture, such as PixelCNN and WaveNet (van den Oord et al., 2016b;a). Learning an IAF with maximum likelihood can be very slow. In this work, we distill a Gaussian IAF from a pretrained autoregressive generative model by minimizing a numerically stable variant of KL divergence.
Knowledge distillation is originally proposed for compressing large models to smaller ones (Bucilua et al., 2006). In deep learning (Hinton et al., 2015), a smaller student network is distilled from the
teacher network by minimizing the loss between their outputs (e.g., L2 or cross-entropy). In parallel WaveNet, a non-autoregressvie student-net is distilled from an autoregressive WaveNet by minimizing the reverse KL divergence (Murphy, 2014). Similar techniques are applied in non-autoregressive models for machine translation (Gu et al., 2018; Kaiser et al., 2018; Lee et al., 2018; Roy et al., 2018).

heading: 3 PARALLEL WAVE GENERATION
text: In this section, we present the Gaussian autoregressive WaveNet as the teacher-net and the Gaussian inverse autoregressive flow as the student-net. Then, we develop our knowledge distillation algorithm.

heading: 3.1 GAUSSIAN AUTOREGRESSIVE WAVENET
text: WaveNet models the joint distribution of high dimensional waveform x = {x1, . . . , xT } as the product of conditional distributions using the chain rules of probability,
p(x | c ; θ) = T∏
t=1
p(xt | x<t, c ; θ), (1)
where xt is the t-th variable of x, x<t represent all variables before t-step, c is the conditioner 2 (e.g., mel-spectrogram or hidden states in Section 4), and θ are parameters of the model. The autoregressive WaveNet takes x<t as input, and outputs the probability distribution over xt.
Parallel WaveNet (van den Oord et al., 2018) advocates mixture of logistics (MoL) distribution in PixelCNN++ (Salimans et al., 2017) for autoregressive teacher-net, as it requires much fewer output units compared to categorical distribution (e.g., 65,536 softmax units for 16-bit audios). Actually, the output distribution of student-net is required to be differentiable over samples x and allow backpropagation from teacher to student in distillation. As a result, one also needs to choose a continuous distribution for teacher WaveNet. Directly maximizing the log-likelihood of MoL is prone to numerical issues, and one has to employ the quantized surrogate loss introduced in PixelCNN++.
In this work, we demonstrate that a single Gaussian output distribution for WaveNet suffices to model the raw waveform. It might raise the modeling capacity concern because we use the single Gaussian instead of mixture of Gaussians (Chung et al., 2015). We will demonstrate their comparable performance in experiment. Specifically, the conditional distribution of xt given previous samples is,
p(xt | x<t;θ) = N ( µ(x<t;θ), σ(x<t;θ) ) , (2)
where µ(x<t;θ) and σ(x<t;θ) are mean and standard deviation predicted by the autoregressive WaveNet, respectively. In practice, the network predicts log σ(x<t) and operates at log-scale for numerical stability. Given observed data, we do maximum likelihood estimation (MLE) for θ. Note that, the model may give very accurate prediction of 16-bit discrete xt without real-valued noise (i.e., µ(x<t) ≈ xt), then the log-likelihood calculation can become numerically unstable when it is free to minimize σ(x<t). As a result, we clip the predicted log σ(x<t) at −9 (natural logarithm) before calculating the log-likelihood at training. 3 We discuss the importance of clipping constant for logscale in Appendix A. We also tried the dequantization trick by adding uniform noise u ∈ [0, 265536 ] to the 16-bits samples similar as in image modeling (e.g., Uria et al., 2013). Indeed, these tricks are equivalent, in the sense that they both upper bound the continuous likelihood for modeling quantized data. We prefer the clipping trick, as it explicitly controls the model behavior and simplifies probability density distillation afterwards.

heading: 3.2 GAUSSIAN INVERSE AUTOREGRESSIVE FLOW (IAF)
text: Normalizing flows (Rezende and Mohamed, 2015; Dinh et al., 2017) map a simple initial density q(z) (e.g., isotropic Gaussian) into a complex one by applying an invertible transformation x = f(z). Given f is a bijection, the distribution of x can be obtained through the change of variables formula:
q(x) = q(z) ∣∣∣∣det(∂f(z)∂z )∣∣∣∣−1 , (3)
2We may omit c for concise notations. 3We clip log-scale at −7 at submission. Afterwards, we found smaller clipping constant (e.g., −9) gives
better results for various datasets (e.g., Mandarin data), although it requires more iterations to converge.
where det (∂f(z)
∂z
) is the determinant of the Jacobian and is computationally expensive to obtain in
general. Inverse autoregressive flow (IAF) (Kingma et al., 2016) is a special normalizing flow with a simple Jacobian determinant. In IAF, z has the same dimension as x, and the transformation is based on an autoregressive network taking z as the input: xt = f(z≤t;ϑ), where ϑ are parameters of the model. Note that the t-th variable xt only depends on previous and current latent variables z≤t, thus the Jacobian is a triangular matrix and the determinant is the product of the diagonal entries,
det
( ∂f(z)
∂z ) = ∏ t ∂f(z≤t) ∂zt , (4)
which is easy to calculate. Parallel WaveNet (van den Oord et al., 2018) uses a single logistic distribution based IAF to match its mixture of logistics (MoL) teacher.
We use the Gaussian IAF (Kingma et al., 2016) and define the transformation xt = f(z≤t;ϑ) as:
xt = zt · σ(z<t;ϑ) + µ(z<t;ϑ), (5)
where the shifting function µ(z<t;ϑ) and scaling function σ(z<t;ϑ) are modeled by an autoregressive WaveNet in Section 3.1. The IAF transformation computes x in parallel given z, which makes efficient use of resource like GPU. Importantly, if we assume zt ∼ N (zt | µ0, σ0), it is easy to observe that xt also follows a Gaussian distribution,
q(xt | z<t;ϑ) = N ( µq, σq ) , (6)
where µq = µ0 · σ(z<t;ϑ) + µ(z<t;ϑ) and σq = σ0 · σ(z<t;ϑ). Note that x are highly correlated through the marginalization of latents z, and the IAF jointly models x at all timesteps.
To evaluate the likelihood of observed data x, we can use the identities Eq. (3) and (4), and plug-in the transformation defined in Eq. (5), which will give us,
q(x;ϑ) = q(z) (∏ t σ(z<t;ϑ) )−1 . (7)
However, one need the inverse transformationn f−1 of Eq. (5),
zt = xt − µ(z<t;ϑ) σ(z<t, ϑ) , (8)
to compute the corresponding z from the observed x, which is autoregressive and slow. As a result, learning an IAF directly through maximum likelihood can be very slow.
In general, normalizing flows require a series of transformations until the distribution q(x;ϑ) reaches a desired level of complexity. First, we draw a white noise sample z(0) from the isotropic Gaussian distribution N (0, I). Then, we repeatedly apply the transformation z(i)t = f(z (i−1) ≤t ;ϑ) defined in Eq. (5) from z(0) → . . . z(i) → . . . z(n) and we let x = z(n). We summarize this procedure in Algorithm 1. Note the parameters are not shared across different flows.

heading: 3.3 KNOWLEDGE DISTILLATION

heading: 3.3.1 REGULARIZED KL DIVERGENCE
text: van den Oord et al. (2018) proposed the probability density distillation method to circumvent the difficulty of maximum likelihood learning for IAF. In distillation, the goal is to minimize the sequence-level reverse KL divergence between the student IAF and pretrained teacher WaveNet. This sequence-level KL divergence can be naively approximated by sampling z and x = f(z) from IAF, but it may exhibit high variance. The variance of this estimate can be reduced by marginalizing over the one-step-ahead predictions for each timestep (van den Oord et al., 2018). However, parallel WaveNet has to run a separate Monte Carlo sampling at each timestep, because the per-time-step KL divergence between the logistic and mixture of logistics distribution is still intractable. Indeed, parallel WaveNet first draws a white noise sample z, then it draws multiple different samples xt from q(xt|z<t) to estimate the intractable integral. Our method only need to draw one sample z, then it computes the KL divergence in closed-form thanks to the Gaussian setup.
Algorithm 1 Gaussian Inverse Autoregressive Flows as Student Network
Input: z(0) ∼ N (0, I): white noises; n: number of flows; {ϑ(i)}: parameters of autoregressive WaveNet for the i-th flow; Output: samples x; output distribution q(xt | z<t) with mean µq[t] and standard deviation σq[t] Initialize µz = 0, σz = 1 for i-th flow in [1 : n] do
Given a white noise sample z, Algorithm 1 outputs sample x = f(z), as well as the output Gaussian distribution q(xt | z<t;ϑ) with mean µq and standard deviation σq. We feed the sample x into an autoregressive WaveNet, and obtain its output distribution p(xt | x<t;θ) with mean µp and standard deviation σp. One can show that the per-time-step KL divergence between student’s output distribution q(xt|z<t;ϑ) and teacher’s p(xt|x<t;θ) has closed-form expression (see Appendix D),
KL (q ‖ p) = log σp σq
+ σ2q − σ2p + (µp − µq)2
2σ2p , (9)
which also forms an unbiased estimate of the sequence-level KL divergence between student’s distribution q(x) and teacher p(x) (see Appendix C).
In this submission, we lower bound log σp and log σq at −7 before calculating the KL divergence. 4 However, the division by σ2p still raises serious numerical problem, when we directly minimize the average KL divergence over all timesteps. To elaborate this, we monitor the empirical histograms of σp from teacher WaveNet during distillation in Figure 1 (a). One can see that it is mostly distributed around (e−9, e−2), which incurs numerical problem if σp and σq have very different magnitudes at the beginning of training. This is because a well-trained WaveNet usually has highly peaked output distributions. The same observation holds true for other output distributions, including mixture of Gaussians and mixture of logistics.
To address this problem, we define the following variant of KL divergence: KLreg (q ‖ p) = λ ∣∣ log σp − log σq∣∣2 + KL (q ‖ p) . (10)
4Clipping at −6 also works well and could improve numerical stability. See more discussion in Appendix A.
One can interpret the first term as regularization,5 which largely stabilizes the optimization process by quickly matching the σ’s from student and teacher models, as demonstrated in Figure 1 (a) and (b). In addition, it does not introduce any bias for matching their probability density functions, as we have the following proposition:
Proposition 3.1. For probability distributions in the location-scale family (including Gaussian, logistic distribution etc.), the regularized KL divergence in Eq. (10) still satisfies the following properties: (i) KLreg (q ‖ p) ≥ 0, and (ii) KLreg (q ‖ p) = 0 if and only if p = q.
Given a sample z and its mapped x, we also test the forward KL divergence between the student’s output distribution q(xt|z<t;ϑ) and teacher’s p(xt|x<t;θ),
KL (p ‖ q) = H(p, q)−H(p), (11)
where H(p, q) is the cross entropy, and H(p) is the entropy of teacher model. One can ignore the entropy term H(p) since we are optimizing student q under a pretrained teacher p. Note that the sample-level forward KLD in Eq. (11) is a biased estimate of sequence-level KL (p(x) ‖ q(x)). To make it numerically stable, we apply the same regularization term in Eq. (10) and observe very similar empirical distributions of log σ in Figure 1.

heading: 3.3.2 STFT LOSS
text: In knowledge distillation, it is a common practice to incorporate an additional loss using the groundtruth dataset (e.g., Kim and Rush, 2016). Empirically, we found that training student IAF with KL divergence loss alone will lead to whisper voices. van den Oord et al. (2018) advocates the average power loss to solve this issue, which is actually coupled with the short length of training audio clip (i.e. 0.32s) in their experiments. As the clip length increases, the average power loss will be less effective. Instead, we compute the frame-level loss between the output samples x from student IAF and corresponding ground-truth audio xn:
1
B ∥∥∥∥∣∣STFT(x)∣∣− ∣∣STFT(xn)∣∣∥∥∥∥2 2 ,
where |STFT(x)| are the magnitudes of short-term Fourier transform (STFT), and B = 1025 is the number of frequency bins as we set FFT size to 2048. We use a 12.5ms frame-shift, 50ms window length and Hanning window. Our final loss function is a linear combination of average KL divergence and frame-level loss, and we simply set their coefficients to one in all experiments.

heading: 4 TEXT-TO-WAVE ARCHITECTURE
text: In this section, we present our fully convolutional text-to-wave architecture (see Fig. 2 (a)) for endto-end TTS. Our architecture is based on Deep Voice 3 (DV3), a convolutional attention-based TTS system (Ping et al., 2018). DV3 is capable of converting textual features (e.g., characters, phonemes and stresses) into spectral features (e.g., log-mel spectrograms and log-linear spectrograms). These spectral features can be used as inputs for a separately trained waveform synthesis model, such as WaveNet. In contrast, we directly feed the hidden representation learned from the attention mechanism to the WaveNet through some intermediate processing, and train the whole model from scratch in an end-to-end manner.
Note that, conditioning the WaveNet on hidden representation is crucial to the success of training from scratch. Indeed, we tried to condition WaveNet on predicted mel-spectrogram from DV3, thus the gradients of WaveNet loss can backpropagate through DV3 to improve the text-to-spectrogram model. When the whole model is trained from scratch, we found it performs slightly worse than the separate training pipeline. The major reason is that the predicted mel-spectrogram from DV3 can be inaccurate at early training, and may spoil the training of WaveNet. In order to get satisfactory results, one need pretrain DV3 and WaveNet, then fine-tune the whole system (e.g., Zhao et al., 2018).
The proposed architecture consists of four components: 5We fix λ = 4 in all experiments.
• Encoder: A convolutional encoder as in DV3, which encodes textual features into an internal hidden representation.
• Decoder: A causal convolutional decoder as in DV3, which decodes the encoder representation with attention into the log-mel spectrogram in an autoregressive manner.
• Bridge-net: A convolutional intermediate processing block, which processes the hidden representation from the decoder and predict log-linear spectrogram. Unlike the decoder, it is non-causal and can thus utilize future context information. In addition, it upsamples the hidden representation from frame-level to sample-level.
• Vocoder: A Gaussian autoregressive WaveNet to synthesize the waveform, which is conditioned on the upsampled hidden representation from the bridge-net. This component can be replaced by a student IAF distilled from the autoregressive vocoder.
The overall objective function is a linear combination of the losses from decoder, bridge-net and vocoder; we simply set all coefficients to one in experiments. We introduce bridge-net to utilize future temporal information as it can apply non-causal convolution. All modules in our architecture are convolutional, which enables fast training 6 and alleviates the common difficulties in RNN-based models (e.g., vanishing and exploding gradient problems (Pascanu et al., 2013)). Throughout the whole model, we use the convolution block from DV3 (see Fig. 2(c)) as the basic building block. It consists of a 1-D convolution with a gated linear unit (GLU) and a residual connection. We set the dropout probability to 0.05 in all experiments. We give further details in the following subsections.

heading: 4.1 ENCODER-DECODER
text: We use the same encoder-decoder architecture as DV3 (Ping et al., 2018). The encoder first converts characters or phonemes into trainable embeddings, followed by a series of convolution blocks to extract long-range textual information. The decoder autoregressively predicts the log-mel spectrograms with an L1 loss (teacher-forced at training). It starts with layers of 1x1 convolution to preprocess the input log-mel spectrogram, and then applies a series of causal convolutions and attentions. A multi-hop attention-based alignment is learned between character embeddings and log-mel spectrograms.

heading: 4.2 BRIDGE-NET
text: The hidden states of decoder are fed to the bridge-net for temporal processing and upsampling. The output hidden representation is then fed to the vocoder for waveform synthesis. Bridge-net consists of a stack of convolution blocks, and two layers of transposed 2-D convolution interleaved with softsign
6For example, DV3 trains an order of magnitude faster than its RNN peers.
to upsample the per-timestep hidden representation from 80 per second to 24,000 per second. The upsampling strides in time are 15 and 20 for the two layers, respectively. Correspondingly, we set the 2-D convolution filter sizes as (30, 3) and (40, 3), where the filter sizes (in time) are doubled from strides to avoid the checkerboard artifacts (Odena et al., 2016).

heading: 5 EXPERIMENT
text: In this section, we present several experiments to evaluate the proposed parallel wave generation method and text-to-wave architecture.
Data: We use an internal English speech dataset containing about 20 hours of audio from a female speaker with a sampling rate of 48 kHz. We downsample the audios to 24 kHz.
Autoregressive WaveNet: We first show that a single Gaussian output distribution for autoregressive WaveNet suffices to model the raw waveform. We use the similar WaveNet architecture detailed in Arık et al. (2017a) (see Appendix B). We use 80-band log-mel spectrogram as the conditioner. To upsample the conditioner from frame-level (80 per second) to sample-level (24,000 per second), we apply two layers of transposed 2-D convolution (in time and frequency) interleaved with leaky ReLU (α = 0.4). The upsampling strides in time are 15 and 20 for the two layers, respectively. Correspondingly, we set the 2-D convolution filter sizes as (30, 3) and (40, 3). We also find that normalizing log-mel spectrogram to the range of [0, 1] improves the synthesized audio quality (e.g., Yamamoto, 2018). We train 20-layers WaveNets conditioned on ground-truth log-mel spectrogram with various output distributions, including single Gaussian, 10-component mixture of Gaussians (MoG), 10-component mixture of Logistics (MoL), and softmax with 2048 linearly quantized channels. We set both residual channel (dimension of the hidden state of every layer) and skip channel (the dimension to which layer outputs are projected prior to the output layer) to 128. We set the filter size of dilated convolutions to 2 for teacher WaveNet. All models share the same architecture except the output distributions, and they are trained for 1000K steps using the Adam optimizer (Kingma and Ba, 2015) with batch-size 8 and 0.5s audio clips. The learning rate is set to 0.001 in the beginning and annealed by half for every 200K steps.
We report the mean opinion score (MOS) for naturalness evaluation in Table 1. We use the crowdMOS toolkit (Ribeiro et al., 2011), where batches of samples from these models were presented to workers on Mechanical Turk. The results indicate that the Gaussian autoregressive WaveNet provides comparable results to MoG and softmax outputs, and outperforms MoL in our experiments. We also include the conditional log-likelihoods (CLL) on test audios (conditioned on mel-spectrograms) for continuous output WaveNets, where the Gaussian, MoG, and MoL are trained with the same clipping constant −9. See more discussions about clipping constant for log-scale variable in Appendix A. MoL obtains slightly worse CLL, as it does not directly optimize the continuous likelihood.
Student Gaussian IAF: We distill two 60-layer parallel student-nets from a pre-trained 20-layer Gaussian autoregressive WaveNet. Our student-1 consists six stacked Gaussian IAF and each flow
Method Subjective 5-scale MOS Text-to-Wave Model 4.15± 0.25 Text-to-Wave (distilled vocoder) 4.11± 0.24 DV3 + WaveNet (predicted Mel) 3.81± 0.26 DV3 + WaveNet (true Mel) 3.73± 0.24

heading: 6 CONCLUSION
text: In this work, we first demonstrate that a single Gaussian output distribution is sufficient for modeling the raw waveform in WaveNet without degeneration of audio quality. Then, we propose a parallel wave generation method based on Gaussian inverse autoregressive flow (IAF), in which the IAF is distilled from the autoregressive WaveNet by minimizing a regularized KL divergence for highly peaked distributions. In contrast to parallel WaveNet, our distillation algorithm estimates the KL divergence in closed-form and largely stabilizes the training procedure. Furthermore, we propose the first text-to-wave neural architecture for TTS, which can be trained from scratch in an end-to-end manner. Our text-to-wave architecture outperforms the separately trained pipeline and opens up the research opportunities for fully end-to-end TTS. We also demonstrate appealing results by distilling a parallel neural vocoder conditioned on the hidden representation within the end-to-end model.

heading: ACKNOWLEDGEMENTS
text: We thank Yongguo Kang, Yu Gu and Tao Sun from Baidu Speech Department for very helpful discussions. We also thank anonymous reviewers for their valuable feedback and suggestions.

heading: A CLIPPING LOG-SCALE AT TRAINING
text: Clipping for log σ plays an important role in training Gaussian WaveNet. Without the clipping trick, the optimization process become numerically unstable. The clipping constant also controls the model capacity and largely impacts on final speech quality. We discuss its impact for both autoregressive WaveNet and student IAF. Note that, the clipping is only applied at training, not at inference.
A.1 AUTOREGRESSIVE WAVENET
For Gaussian WaveNet alone, smaller clipping constant for log σ(x<t) at training usually leads to larger likelihood, but it also need more iterations to converge. Figure 3 shows its impact on log-likelihood and convergence behaviour. From Figure 3 (a)-(d), the validation likelihood improves a lot from with clipping constant −7 to −9, but the improvement is negligible from −9 to −10. In addition, (e) shows the numerical instability without clipping, and (f) shows the dequantization with uniform noise u ∈ [0, 265536 ] stabilizes optimization and performs very similar as clipping at −10.
For speech quality, models trained with small clipping constant (e.g., −9) tend to have less artifacts at convergence, especially for the silence portion of utterances. However, very small clipping constant in teacher WaveNet may raise difficulty for distillation, because the range of log σ will be large (see Figure 4). For different datasets and conditioners, the optimal clipping constant may be different. We suggest −9 as the default for Gaussian teacher, after we tried various datasets (including English, Mandarin) and conditioners (including mel-spectrogram, hidden states, linguistic conditioner).
A.2 GAUSSIAN IAF
In distillation, we also clip log σp and log σq for numerical reason before computing the KL divergence (KLD). Note that, the clipping is not applied for the regularization term. In general, larger clipping constant leads to more stable optimization, but it could make the KLD loss less useful. We suggest −6 as the default setting, after we tried various datasets and conditioners. Useful tricks: When we work on student WaveNet with linguistic conditioner on internal Mandarin dataset, we find the following tricks are effective to improve the numerical stability at distillation.
• After initial training (e.g., 500 iterations), if the KLD loss is larger than a threshold (e.g., 10.0), we simply mask it as zero, and let the regularization term and STFT loss to help it out. • After initial training, if the global norm of gradients is larger than 1000.0, we clip the gradients
by small values [−0.1, 0.1]. Otherwise, we clip the values of gradients to [−5.0, 5.0]. • Larger batch size (e.g., 16) and smaller learning rate (e.g., 0.0002) are helpful to stabilize the
distillation.

heading: B DETAILS OF DILATED CONVOLUTION BLOCK
text: We also employ a stack of dilated convolution blocks, where each block has 10 layers and the dilation is doubled at each layer, i.e., {1, 2, 4, ..., 512}. We add the output hidden states from each layer through residual connection before projecting them to the number of skip channels.
In dilated convolution block, we compute the i-th hidden layer h(i) with dialation 2i−1 by gated convolutions (van den Oord et al., 2016b):
h(i) = sigmoid(W (i)g ∗ h (i−1) +A(i)g · c+ b(i)g ) tanh(W (i) f ∗ h (i−1) +A (i) f · c+ b (i) f ),
therein h0 = x is the input of the block, ∗ denotes the causal dilated convolution, · represents 1 × 1 convolution over the upsampled conditioner c, denotes the element-wise multiplication, W (i) g , A (i) g , b (i) g are convolutions and bias parameters at i-th layer for sigmoid gating function, and W (i) f , A (i) f , b (i) f are analogous parameters for tanh function.

heading: C ESTIMATE THE SEQUENCE-LEVEL KL DIVERGENCE
text: The sequence-level KL divergence between student distribution q(x) and teacher’s p(x) can be written as,
KL (q(x) ‖ p(x)) = Eq(x) [ log q(x)− log p(x) ] ,
note that, q(x) = T∏
t=1
q(xt|x<t) and p(x) = T∏
t=1
p(xt|x<t),
= Eq(x) [ T∑
t=1
log q(xt|x<t)− log p(xt|x<t) ]
= T∑ t=1 Eq(x≤t) [ log q(xt|x<t)− log p(xt|x<t) ] =
T∑ t=1 Eq(x<t) Eq(xt|x<t) [ log q(xt|x<t)− log p(xt|x<t) ] =
T∑ t=1 Eq(x<t) [ KL (q(xt|x<t) ‖ p(xt|x<t)) ] = Eq(x)
T∑ t=1 [ KL (q(xt|x<t) ‖ p(xt|x<t)) ]
Note that, the above equality holds for arbitrary distributions. Since q(x) is an IAF, and x are sampled through x = f(z) and z ∼ N(0, I), then
KL (q(x) ‖ p(x)) = E z∼N(0,I) x=f(z) [ T∑ t=1 KL (q(xt|z<t) ‖ p(xt|x<t)) ] .
Thus, the summation of per-time-step KL divergence is an unbiased estimate of the sequence-level KL divergence.

heading: D KL DIVERGENCE BETWEEN GAUSSIAN DISTRIBUTIONS
text: Given two Gaussian distributions p(x) = N (µp, σp) and q(x) = N (µq, σq), their KL divergence is:
KL (q ‖ p) = ∫ q(x) log q(x)
p(x) dx = H(q, p)−H(q)
where log ≡ loge, the entropy, H(q) = − ∫ q(x) log q(x)dx
= − ∫ q(x) log [ (2πσ2q ) − 12 exp ( − (x− µq) 2
2σ2q
)] dx
= 1 2 log ( 2πσ2q ) ∫ q(x)dx + 1
2σ2q
∫ q(x)(x− µq)2dx
= 1 2 log ( 2πσ2q ) · 1 + 1 2σ2q · σ2q
= 1 2 log ( 2πσ2q ) + 1 2
and the cross entropy, H(q, p) = − ∫ q(x) log p(x)dx
= − ∫ q(x) log [ (2πσ2p) − 12 exp ( − (x− µp) 2
2σ2p
)] dx
= 1 2 log ( 2πσ2p ) ∫ q(x)dx + 1
2σ2p
∫ q(x)(x− µp)2dx
= 1 2 log ( 2πσ2p ) + 1
2σ2p
∫ q(x)(x2 − 2µpx+ µ2p)dx
= 1 2 log ( 2πσ2p ) + µ2q + σ 2 q − 2µpµq + µ2p
2σ2p
= 1 2 log ( 2πσ2p ) + σ2q + (µp − µq)2 2σ2p .
Combining H(q) and H(q, p) together, we obtain
KL (q ‖ p) = log σp σq
+ σ2q − σ2p + (µp − µq)2
2σ2p .

Review summaries:
This paper proposes some modifications to established procedures for neural speech synthesis and investigates their effect experimentally. The proposed modifications are mostly fairly straightforward conceptually, but appear to work well, and this reviewer feels the paper has huge value in its experimental contributions extending and clarifying certain aspects of WaveNet training and distillation. The paper is well-written and fairly concise, with a short-and-sweet experimental results section.