C LARI N ET : P ARALLEL W AVE G ENERATION IN E ND - TO -E ND T EXT - TO -S PEECH
A BSTRACT
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 ﬂow 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 simpliﬁes the training algorithm and provides very efﬁcient distillation.
In addition, we introduce the ﬁrst text-to-wave neural architecture for speech synthesis, which is fully convolutional and enables fast end-to-end training from scratch.
It signiﬁcantly 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.
I NTRODUCTION
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-ﬁdelity 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-ﬁdelity 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-ﬁdelity 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 ﬂow (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.
Speciﬁcally, we make the following contributions:
We demonstrate that a single variance-bounded Gaussian is sufﬁcient 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).
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 simpliﬁes the distillation algorithm and stabilizes the training process.
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 ﬁrst 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 signiﬁcantly outperforms the separately trained pipeline (Ping et al., 2018) in naturalness.
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.
R ELATED W ORK
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 Grifﬁn-Lim algorithm (Grifﬁn 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 ﬁrst 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 ( F 0 ), 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 ﬂows (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 ﬂow provides arbitrarily complex posterior distribution, making it well suited for the inference network in variational autoencoder (Kingma and Welling, 2014).
Inverse autoregressive ﬂow (IAF) (Kingma et al., 2016) is a special type of normalizing ﬂow 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).
P ARALLEL W AVE G ENERATION
In this section, we present the Gaussian autoregressive WaveNet as the teacher-net and the Gaussian inverse autoregressive ﬂow as the student-net.
Then, we develop our knowledge distillation algorithm.
3. G AUSSIAN A UTOREGRESSIVE W AVE N ET
WaveNet models the joint distribution of high dimensional waveform x = { x 1 , . . .
, x T } as the product of conditional distributions using the chain rules of probability,
[Equation]
where x t 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 x t .
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 sufﬁces 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.
Speciﬁcally, the conditional distribution of x t given previous samples is,
[Equation]
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 x t without real-valued noise (i.e., µ ( x <t )
≈ x t ), 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 , ] to the 16-bits samples similar as in image modeling (e.g., Uria et al., 2013).
Indeed, both tricks are equivalent, in the sense that they upper bound the continuous likelihood for modeling discrete data.
We prefer the clipping trick, as it explicitly controls the model behavior and simpliﬁes probability density distillation afterwards.
3. G AUSSIAN I NVERSE A UTOREGRESSIVE F LOW (IAF)
Normalizing ﬂows (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:
[Equation]
We 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 (cid:0) ∂f ( z ) ∂ z (cid:1) is the determinant of the Jacobian and is computationally expensive to obtain in general.
Inverse autoregressive ﬂow (IAF) (Kingma et al., 2016) is a special normalizing ﬂow 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: x t = f
( z ≤ t ; ϑ ) , where ϑ are parameters of the model.
Note that the t -th variable x t 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,
[Equation]
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 deﬁne the transformation x t = f ( z ≤ t ; ϑ ) as: [Equation]
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 efﬁcient use of resource like GPU.
Importantly, if we assume z t ∼ N ( z t | µ 0 , σ 0 ) , it is easy to observe that x t also follows a Gaussian distribution,
[Equation]
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 deﬁned in Eq.
(5), which will give us,
[Equation]
However, one need the inverse transformationn f − 1 of Eq.
[Equation]
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 ﬂows 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 ; ϑ ) deﬁned 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 ﬂows.
3. K NOWLEDGE D ISTILLATION 3.3. R EGULARIZED KL D IVERGENCE
van den Oord et al.
(2018) proposed the probability density distillation method to circumvent the difﬁculty 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 ﬁrst draws a white noise sample z , then it draws multiple different samples x t from q ( x t | 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. do
Run autoregressive WaveNet ϑ ( by taking z ( − as input µ [ t ] ← µ ( z ( i − 1) <t ; ϑ ( i ) ) σ [ t ] ← σ ( z ( i − 1) <t ; ϑ i ( i
= z i − 1) (cid:12) σ + µ σ z = σ z (cid:12) σ µ z = µ z (cid:12) σ + µ for x µ q µ σ q = σ z Remark : iterating over log σ in log-scale improves numerical stability in practice.
[Figure] Given a white noise sample z , Algorithm 1 outputs sample x = f ( z ) , as well as the output Gaussian distribution q ( x t | z <t ; ϑ ) with mean µ q and standard deviation σ q . We feed the sample x into an autoregressive WaveNet, and obtain its output distribution p ( x t | 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 ( x t | z <t ; ϑ ) and teacher’s p ( x t | x <t ; θ ) has closed-form expression (see Appendix D), KL ( q (cid:107) p ) =
[Equation]
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.
However, the division by σ 2 p 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 deﬁne the following variant of KL divergence:
[Equation]
One can interpret the ﬁrst 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 satisﬁes the following properties: (i) KL reg ( q (cid:107) p ) ≥ 0 , and (ii) KL reg ( q (cid:107) p )
=
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 ( x t | z <t ; ϑ ) and teacher’s p ( x t | x <t ; θ ) ,
[Equation]
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 ) (cid:107) 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.
3.3. STFT L OSS
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 .
32 s ) 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 x n :
[Equation]
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 .
5 ms frame-shift, 50 ms window length and Hanning window.
Our ﬁnal loss function is a linear combination of average KL divergence and frame-level loss, and we simply set their coefﬁcients to one in all experiments.
T EXT - TO -W AVE A RCHITECTURE
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 ﬁne-tune the whole system (e.g., Zhao et al., 2018).
The proposed architecture consists of four components:
Text
Encoder
Decoder
Waveform
Vocoder (distill)
Bridge-net
Linear Output
Attention
Mel Output
Frame-level
Convolution Block
Transpose Conv.
x N
Sample-level
Linear Output FC x N
Bridge-net
Convolution Block
Input
Conv.
+ ⨉
Output
Dropout
GLU
[Figure]
• 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 coefﬁcients 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 difﬁculties 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.
4. E NCODER -D ECODER
We use the same encoder-decoder architecture as DV3 (Ping et al., 2018).
The encoder ﬁrst 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.
4. B RIDGE - NET
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 [Table] [Table] 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 ﬁlter sizes as (30 , 3) and (40 , 3) , where the ﬁlter sizes (in time) are doubled from strides to avoid the checkerboard artifacts (Odena et al., 2016).
E XPERIMENT
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 ﬁrst show that a single Gaussian output distribution for autoregressive
WaveNet sufﬁces 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 ﬁlter sizes as (30 , 3) and (40 , 3) .
We also ﬁnd 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 ﬁlter 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 .
5 s 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 best clipping constant ( − 9 , − 10 and − 9 , respectively).
See more discussions about clipping constant for log-scale variable in Appendix A.
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 ﬂow [Table]
is parameterized by a 10-layer WaveNet with 64 residual channels, 64 skip channels, and ﬁlter size 3 in dilated convolutions. Student-2 consists of four stacked Gaussian IAF blocks, which are parameterized by [10, 10, 10, 30]-layer WaveNets respectively, with the same channels and ﬁlter size as studuent-1.
For student-2, we also reverse the sequence being generated in time between successive IAF blocks and ﬁnd it improves the performance.
Note that the student models share the same conditioner network (layers of transposed 2-D convolution) with teacher WaveNet during distillation.
Training conditioner network of student model from scratch leads to worse result.
We test both the forward and reverse KL divergences combined with the STFT-loss, and we simply set their combination coefﬁcients to one in all experiments.
The student models are trained for 1000K steps using Adam optimizer.
The learning rate is set to 0.001 in the beginning and annealed by half for every 200K steps.
Surprisingly, we always ﬁnd good results after only 50K steps of distillation, which perhaps beneﬁts from the closed-form computation of KL divergence.
The models are trained longer for extra improvement.
We report the MOS evaluation results in Table 2.
Both of these distillation methods work well and obtain comparable results.
Student-2 outperforms student-1 by generating “clearner” voices.
We expect further improvements by incorporating perceptual and contrastive losses introduced in van den Oord et al.
and we will leave it for future work.
At inference, the parallel student-net runs ∼ 20 times faster than real time on NVIDIA GeForce GTX 1080 Ti.
Text-to-Wave Model: We train the proposed text-to-wave model from scratch and compare it with the separately trained pipeline presented in Deep Voice 3 (DV3)
(Ping et al., 2018).
We use the same text preprocesssing and joint character-phoneme representation in DV3.
The hyper-parameters of encoder and decoder are the same as the single-speaker DV3.
The bridge-net has 6 layers of convolution blocks with input/output size of 256.
The hyper-parameters of the vocoders are the same as previous subsections. The vocoder part is trained by conditioning on sliced hidden representations corresponding to 0 . 5 s audio clips. Other parts of model are trained on whole-length utterances.
The model is trained for 1.5M steps using Adam optimizer with batch size 16.
The learning rate is set to 0.001 in the beginning and annealed by half for every 500K steps. We also distill a Gaussian IAF from the trained autoregressive vocoder within this end-to-end model. Both student IAF and autoregressive vocoder are conditioned on the upsampled hidden representation from the bridge-net. For the separately trained pipeline, we train two Gaussian autoregressive WaveNets conditioned on groundtruth mel-spectrogram and predicted mel-spectrogram from DV3, respectively.
We run inference on the same unseen text as DV3 and report the MOS results in Table 3. The results demonstrate that the text-to-wave model signiﬁcantly outperforms the separately trained pipeline. The text-to-wave model with a distilled parallel vocoder gives slightly worse result to the one with autoregressive vocoder. In the separately trained pipeline, training a WaveNet conditioned on predicted mel-spectrograms eases the training/test mismatch, thus outperforms training with ground-truth.
C ONCLUSION
In this work, we ﬁrst demonstrate that a single Gaussian output distribution is sufﬁcient 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 ﬂow (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 ﬁrst 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.
A CKNOWLEDGEMENTS
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.
Appendices A C LIPPING L OG - SCALE AT T RAINING
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 ﬁnal 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.
[Figure]
A. A UTOREGRESSIVE W AVE N ET
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 , 2 65536 ] 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 difﬁculty 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).
[Figure]
A. G AUSSIAN 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 ﬁnd 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 .
Otherwise, we clip the values of gradients to [ − 5 . 0 , 5 . 0] .
• Larger batch size (e.g., 16 ) and smaller learning rate (e.g.,
. 0002 ) are helpful to stabilize the distillation.
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 directly 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 2 i − 1 by gated convolutions (van den Oord et al., 2016b):
[Equation]
therein h
= x is the input of the block, ∗ denotes the causal dilated convolution, · represents 1 × 1 convolution over the upsampled conditioner c , (cid:12) 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.
C E STIMATE THE S EQUENCE - LEVEL KL D IVERGENCE
The sequence-level KL divergence between student distribution q ( x ) and teacher’s p ( x ) can be written as,
[Equation]
note that, q ( x ) =
T (cid:89) t = q ( x t | x <t ) and p ( x ) =
T (cid:89) t = p ( x t | x <t ) , =
E q ( x ) (cid:104)
T (cid:88) t =
[Equation]
=
[Equation]
t
[Equation]
=
[Equation]
t
[Equation]
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
[Equation]
Thus, the summation of per-time-step KL divergence is an unbiased estimate of the sequence-level
KL divergence.
D KL D IVERGENCE BETWEEN G AUSSIAN D ISTRIBUTIONS
Given two Gaussian distributions p ( x ) =
N ( µ p , σ p ) and q ( x ) = N ( µ q , σ q ) , their KL divergence is:
[Equation]
where log ≡ log e
[Equation]
the entropy,
[Equation]
and the cross entropy,
[Equation]
Combining H ( q ) and H ( q, p ) together, we obtain
[Equation]