C LARI N ET : P ARALLEL W AVE G ENERATION IN E ND - TO -E ND T EXT - TO -S PEECH
Anonymous authors
Paper under double-blind review
A BSTRACT
In this work, we propose a new solution for parallel wave generation by WaveNet.
In contrast to parallel WaveNet (van 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 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 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 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 per-time-step 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 inverse autoregressive ﬂow (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 novel 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 spectrograms as in previous work (Shen et al., 2018; Arık et al., 2017b), 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, frequency, and waveform synthesis models.
In contrast, Tacotron, Deep Voice 3, 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-toend” speech synthesis.
However, they actually depend on a traditional vocoder (Morise et al., 2016), the Grifﬁn-Lim algorithm (Grifﬁn & 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 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 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 learned hidden representation within the end-to-end model.
Normalizing ﬂows (Rezende & 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 & 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 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 learned hidden representation 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 .
The original WaveNet treats x t as a 256-way categorical variable (van Oord et al., 2016a).
In practice, high ﬁdelity audio (16-bit per sample) may require as many as 65,536 softmax units to model, which could be prohibitively expensive.
Parallel WaveNet (van Oord et al., 2018) advocates mixture of logistics (MoL) distribution introduced in PixelCNN++ (Salimans et al., 2017) for autoregressive teacher-net, as it requires much fewer output units.
More importantly, the output distribution of student-net is required to be differentiable over random samples x and allow backpropagation from teacher-net to student-net during distillation.
As a result, one needs to choose a continuous output distribution for teacher-net in order to be consistent with the student-net.
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 as the output distribution.
We will demonstrate their comparable performance in experiments.
3 Actually, parallel WaveNet uses a single logistic distribution as the output of student-net and obtains good results, which implies the mixture density is not a necessary ingredient to success.
Speciﬁcally, our conditional distribution of x t given previous samples x <t 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 perform maximum likelihood estimation (MLE) for parameters θ .
Note that, the model can give very accurate prediction of µ ( x <t ) without observation noise in x t (i.e., µ ( x <t )
≈ x t ), and the log-likelihood can approach to inﬁnity if it is free to minimize σ ( x <t ) .
To avoid this degenerate case, we lower bound the predicted log σ ( x <t ) at − 7 (natural logarithm) before calculating the log-likelihood in our experiment.
Smaller clipping constant (e.g., − 8 ) may work even better.
We use the similar WaveNet architecture detailed in Arık et al.
(2017a)
(see details in Appendix B).
3. G AUSSIAN I NVERSE A UTOREGRESSIVE F LOW (IAF)
Normalizing ﬂows (Rezende & 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]
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 particular 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, det
[Equation]
which is easy to calculate.
Parallel WaveNet (van 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 | z ; ϑ ) 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
[Equation]
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 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 student IAF and the pretrained teacher WaveNet.
This can be naively approximated by drawing multiple samples 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 time step (van Oord et al., 2018).
However, parallel WaveNet has to use a separate Monte Carlo sampling at each timestep, because the KL divergence between the logistic and mixture of logistics distribution is still intractable.
Indeed, parallel WaveNet ﬁrst draws a white noise sample z and passes it as an input for student-net, then it draws multiple different samples x t from q ( x t | z <t ) to estimate the intractable integral.
In contrast, our density distillation method only need to draw one sample z , then it computes the KL divergence in closed-form thanks to the Gaussian setup.
Given a white noise sample z , Algorithm 1 outputs the mapped sample x , as well as the output
Gaussian distribution q ( x t | z <t ; ϑ ) with mean µ q and standard deviation σ q .
We feed the sample x
Input: z (0) ∼ N (0 , I ) : white noises;
Output: samples mean and standard t ]
Initialize µ z = 0 , σ z =for i -th ﬂow in [1 : n ] do
Run autoregressive WaveNet ϑ ( i ) by taking z ( i − 1) as input µ [ t ] ← µ ( z ( i − 1) <t ; ϑ ( i ) )
σ [ t ] ← σ ( z ( i − 1) <t ; ϑ ( i ) )
z ( i ) =
z ( i − 1) (cid:12) σ + µ σ z
=
σ z (cid:12) σ µ z = µ z (cid:12) σ + µ end for x = z ( n ) , µ q = µ z , σ q = σ z
Remark : iterating over log σ in log-scale improves numerical stability in practice.
[Figure]
into a Gaussian autoregressive WaveNet, and obtain its output distribution p ( x t | x <t ; θ ) with mean µ p and standard deviation σ p .
One can show (in Appendix A) that the reverse KL divergence between the student output distribution q ( x t | z <t ; ϑ ) and teacher p ( x t | x <t ; θ ) has closed-form expression,
[Equation]
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 time steps.
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.
Note that one can ignore the entropy term H ( p ) since we are optimizing student q under a pretrained teacher p , which is similar to the typical cross-entropy loss for knowledge distillation (Hinton et al., 2015).
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. S PECTROGRAM F RAME L OSS
In knowledge distillation, it is a common practice to incorporate an additional loss using the groundtruth dataset (e.g., Kim & Rush, 2016).
Empirically, we found that training student IAF with KL divergence loss alone will lead to whisper voices.
van 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]
[Table]
, 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 neural vocoder through some intermediate processing, and train the whole model from scratch in an end-to-end manner.
The proposed architecture consists of four components:
• 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.
[Figure]
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]
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) (Gehring et al., 2017) 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 to upsample the per-timestep hidden representation from 80 per second to 24,000 per second.
We use the same transposed convolution strides and ﬁlter sizes described in Section 3.1.
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.
[Table] [Table]
Autoregressive WaveNet: We ﬁrst show that a single Gaussian output distribution for autoregressive
WaveNet sufﬁces to model the raw waveform.
We use 80-band log-mel spectrogram as the global conditioner.
To upsample the conditioner from frame-level (80 per second) to sample-level (24, 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) , where the ﬁlter sizes (in time) are doubled from strides to avoid the checkerboard artifacts (Odena et al., 2016).
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 withlinearly 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 500K steps using the
Adam optimizer (Kingma & 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.
The results indicate that the Gaussian autoregressive WaveNet provides comparable results to MoG and softmax outputs, and outperforms
MoL in our experiments.
Student Gaussian IAF: We distill a 60-layer parallel student-net from a pre-trained 20-layer Gaussian autoregressive WaveNet.
It consists of six stacked Gaussian inverse autoregressive ﬂows and each ﬂow is parameterized by a 10-layer WaveNet with 128 residual channels, 128 skip channels, and ﬁlter size 3 in dilated convolutions.
7 Note that the student IAF shares 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 frame-loss, and we simply set their combination coefﬁcients to one in all experiments.
The student models are trained for 500K 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.
We expect further improvements by incorporating perceptual and contrastive losses introduced in van Oord et al.
and we will leave it for future work.
At inference, the parallel student-net runs three orders of magnitude faster than the autoregressive teacher-net on GPUs, when we use straightforward implementations.
[Table]
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.
Appendices A 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 , the entropy,
[Equation]
and the cross entropy,
[Equation]
Combining H ( q ) and H ( q, p ) together, we obtain
[Equation]
B D ETAILS OF D ILATED C ONVOLUTION B LOCK
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 2 i − 1 by gated convolutions (van Oord et al., 2016b):
[Equation] [Equation]
i )
[Equation]
· c
[Equation]
b
[Equation]
i ) f ) , 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.