H IGH F IDELITY S PEECH S YNTHESIS WITH A DVERSARIAL N ETWORKS
Anonymous authors
Paper under double-blind review
A BSTRACT
Generative adversarial networks have seen rapid development in recent years and have led to remarkable improvements in generative modelling of images.
However, their application in the audio domain has received limited attention, and autoregressive models, such as WaveNet, remain the state of the art in generative modelling of audio signals such as human speech.
To address this paucity, we introduce GAN-TTS, a Generative Adversarial Network for Text-to-Speech.
Our architecture is composed of a conditional feed-forward generator producing raw speech audio, and an ensemble of discriminators which operate on random windows of different sizes.
The discriminators analyse the audio both in terms of general realism, as well as how well the audio corresponds to the utterance that should be pronounced.
To measure the performance of GAN-TTS, we employ both subjective human evaluation (MOS – Mean Opinion Score), as well as novel quantitative metrics (Fr´echet DeepSpeech Distance and Kernel DeepSpeech Distance), which we ﬁnd to be well correlated with MOS.
We show that GAN-TTS is capable of generating high-ﬁdelity speech with naturalness comparable to the state-of-the-art models, and unlike autoregressive models, it is highly parallelisable thanks to an efﬁcient feed-forward generator.
Listen to GAN-TTS reading this abstract at http://tiny.cc/gantts .
I NTRODUCTION
The Text-to-Speech (TTS) task consists in the conversion of text into speech audio.
In recent years, the TTS ﬁeld has seen remarkable progress, sparked by the development of neural autoregressive models for raw audio waveforms such as WaveNet (van den Oord et al., 2016), SampleRNN (Mehri et al., 2017) and WaveRNN (Kalchbrenner et al., 2018).
A notable limitation of these models is that they are difﬁcult to parallelise over time: they predict each time step of an audio signal in sequence, which is computationally expensive and often impractical.
A lot of recent research on neural models for TTS has focused on improving parallelism by predicting multiple time steps in parallel, e.g. using ﬂow-based models (van den Oord et al., 2018;
Ping et al., 2019; Prenger et al., 2019;
Kim et al., 2019).
Such highly parallelisable models are more suitable to run efﬁciently on modern hardware.
An alternative approach for parallel waveform generation would be to use Generative Adversarial Networks (GANs, Goodfellow et al., 2014).
GANs currently constitute one of the dominant paradigms for generative modelling of images, and they are able to produce high-ﬁdelity samples that are almost indistinguishable from real data.
However, their application to audio generation tasks has seen relatively limited success so far.
In this paper, we explore raw waveform generation with GANs, and demonstrate that adversarially trained feed-forward generators are indeed able to synthesise high-ﬁdelity speech audio.
Our contributions are as follows:
• We introduce GAN-TTS, a Generative Adversarial Network for text-conditional highﬁdelity speech synthesis.
Its feed-forward generator is a convolutional neural network, coupled with an ensemble of multiple discriminators which evaluate the generated (and real) audio based on multi-frequency random windows.
Notably, some discriminators take the linguistic conditioning into account (so they can measure how well the generated audio corresponds to the input utterance), while others ignore the conditioning, and can only assess the general realism of the audio.
• We propose a family of quantitative metrics for speech generation based on Fr´echet Inception Distance (FID, Heusel et al., 2017) and Kernel Inception Distance (KID, Bi´nkowski et al., 2018), where we replace the Inception image recognition network with the DeepSpeech audio recognition network.
• We present quantitative and subjective evaluation of TTS-GAN and its ablations, demonstrating the importance of our architectural choices.
Our best-performing model achieves a MOS of 4 . 2 , which is comparable to the state-of-the-art WaveNet MOS of 4 . 4 , and establishes GANs as a viable option for efﬁcient TTS.
R ELATED W ORK 2. A UDIO GENERATION
Most neural models for audio generation are likelihood-based: they represent an explicit probability distribution and the likelihood of the observed data is maximised under this distribution.
Autoregressive models achieve this by factorising the joint distribution into a product of conditional distributions (van den Oord et al., 2016; Mehri et al., 2017; Kalchbrenner et al., 2018; Arik et al., 2017).
Another strategy is to use an invertible feed-forward neural network to model the joint density directly (Prenger et al., 2019;
Kim et al., 2019).
Alternatively, an invertible feed-forward model can be trained by distilling an autoregressive model using probability density distillation (van den Oord et al., 2018; Ping et al., 2019), which enables it to focus on particular modes.
Such mode-seeking behaviour is often desirable in conditional generation settings: we want the generated speech signals to sound realistic and correspond to the given text, but we are not interested in modelling every possible variation that occurs in the data.
This reduces model capacity requirements, because parts of the data distribution may be ignored.
Note that adversarial models exhibit similar behaviour, but without the distillation and invertibility requirements.
Many audio generation models, including all of those discussed so far, operate in the waveform domain: they directly model the amplitude of the waveform as it evolves over time.
This is in stark contrast to most audio models designed for discriminative tasks (e.g. audio classiﬁcation): such models tend to operate on time-frequency representations of audio ( spectrograms ), which encode certain inductive biases with respect to the human perception of sound, and usually discard all phase information in the signal.
While phase information is often inconsequential for discriminative tasks, generated audio signals must have a realistic phase component, because ﬁdelity as judged by humans is severely affected otherwise.
Because no special treatment for the phase component of the signal is required when generating directly in the waveform domain, this is usually more practical.
Tacotron (Wang et al., 2017) and MelNet (Vasquez & Lewis, 2019) constitute notable exceptions, and they use the Grifﬁn-Lim algorithm (Grifﬁn & Lim, 1984) to reconstruct missing phase information, which the models themselves do not generate.
Models like Deep Voice 2 & 3 (Gibiansky et al., 2017; Ping et al., 2018) and Tacotron 2 (Shen et al., 2018) achieve a compromise by ﬁrst generating a spectral representation, and then using a separate autoregressive model to turn it into a waveform and ﬁll in any missing spectral information.
Because the generated spectrograms are imperfect, the waveform model has the additional task of correcting any mistakes.
Char2wav (Sotelo et al., 2017) uses intermediate vocoder features in a similar fashion.
2. G ENERATIVE ADVERSARIAL NETWORKS
Generative Adversarial Networks (GANs, Goodfellow et al., 2014) form a subclass of implicit generative models that relies on adversarial training of two networks: the generator , which attempts to produce samples that mimic the reference distribution, and the discriminator , which tries to differentiate between real and generated samples and, in doing so, provides a useful gradient signal to the generator.
Following rapid development, GANs have achieved state-of-the-art results in image (Zhang et al., 2019; Brock et al., 2019; Karras et al., 2019) and video generation (Clark et al., 2019), and have been successfully applied for unsupervised feature learning (Donahue et al., 2017;
Dumoulin et al., 2017a; Donahue & Simonyan, 2019), among many other applications.
Despite achieving impressive results in these domains, limited work has so far shown good performance of GANs in audio generation.
Two notable exceptions include WaveGAN (Donahue et al.,
and GANSynth (Engel et al., 2019), which both successfully applied GANs to simple datasets of audio data.
The former is the most similar to this work in the sense that it uses GANs to generate raw audio; results were obtained for a dataset of spoken commands of digits from zero to nine.
The latter provides state-of-the-art results for a dataset of single note recordings from various musical instruments (NSynth, Engel et al., 2017) by training GANs to generate magnitude-phase spectrograms of the notes (which can easily be converted to waveforms, up to 64000 samples in length).
Neekhara et al.
(2019) propose an adversarial vocoder model that is able to synthesise magnitude spectrograms from mel-spectrograms generated by Tacotron 2, and combine this with phase estimation using the Local Weighted Sums technique (Le Roux et al., 2010). Saito et al.
(2018) propose to enhance a parametric speech synthesiser with a GAN to avoid oversmoothing of the generated speech parameters.
Yamamoto et al.
(2019) replace the probabilistic distillation loss in Parallel WaveNet with an adversarial version.
Tanaka et al. (2018) use a variant of CycleGAN directly on raw waveforms for voice conversion. GANs have seen limited application at large scale in non-visual domains so far.
Two seconds of audio at 24kHz 1 has a dimensionality of 48000 , which is comparable to RGB images at 128 ×resolution.
Until recently, high-quality GAN-generated images at such or higher resolution were uncommon (Zhang et al., 2019; Karras et al., 2019), and it was not clear that training GANs at scale would lead to extensive improvements (Brock et al., 2019).
Multiple discriminators have been used in GANs for different purposes.
For images, Denton et al.
; Zhang et al.
Karras et al.
(2018) proposed to use separate discriminators for different resolutions.
Similar approaches have also been used in image-to-image transfer (Huang et al., 2018) and video synthesis (Saito & Saito, 2018).
Clark et al.
(2019), on the other hand, combine a 3D-discriminator that scores the video at lower resolution and a 2D-frame discriminator which looks at individual frames.
In adversarial feature learning, Donahue & Simonyan (2019) combine outputs from three discriminators to differentiate between joint distributions of images and latents.
Discriminators operating on windows of the input have been used in adversarial texture synthesis (Li & Wand, 2016) and image translation (Isola et al., 2017; Zhu et al., 2017).
GAN-TTS 3. D ATASET
Our text-to-speech models are trained on a dataset which contains high-ﬁdelity audio of human speech with the corresponding linguistic features and pitch information.
The linguistic features encode phonetic and duration information, while the pitch is represented by the logarithmic fundamental frequency log F 0 .
In total, there are 567 features.
We do not use ground-truth duration and pitch for subjective evaluation; we instead use duration and pitch predicted by separate models.
The dataset is formed of variable-length audio clips containing single sequences, spoken by a professional voice actor in North American English.
For training, we sample 2 second windows (ﬁltering out shorter examples) together with corresponding linguistic features.
The total length of the ﬁltered dataset is 44 hours.
The sampling frequency of the audio is 24 kHz, while the linguistic features and pitch are computed for 5 ms windows (at 200 Hz).
This means that the generator network needs to learn how to convert the linguistic features and pitch into raw audio, while upsampling the signal by a factor of 120 .
We apply a µ -law transform to account for the logarithmic perception of volume (see Appendix C).
3. G ENERATOR
A summary of generator G ’s architecture is presented in Table 2 in Appendix A.2.
The input to G is a sequence of linguistic and pitch features at 200 Hz, and its output is the raw waveform at 24 kHz.
The generator is composed of seven blocks (GBlocks, Figure 1a), each of which is a stack of two residual blocks (He et al., 2016).
As the generator is producing raw audio (e.g. a 2 s training clip corresponds to a sequence of 48000 samples), we use dilated convolutions (Yu & Koltun, 2016) to ensure that the receptive ﬁeld of G is large enough to capture long-term dependencies.
The four kernel size- convolutions in each GBlock have increasing dilation factors: 1 , 2 , 4 , 8 .
Convolutions are preceded by Conditional Batch Normalisation (Dumoulin et al., 2017b), conditioned on the linear embeddings of the noise term z ∼ N (0 , I 128 ) in the single-speaker case, or the concatenation of z and a onehot representation of the speaker ID in the multi-speaker case.
The embeddings are different for each BatchNorm instance.
A GBlock contains two skip connections, the ﬁrst of which performs upsampling if the output frequency is higher than the input, and it also contains a size- 1 convolution if the number of output channels is different from the input.
GBlocks 3–7 gradually upsample the temporal dimension of hidden representations by factors of 2 , 2 , 2 , 3 , 5 , while the number of channels is reduced by GBlocks 3, 6 and 7 (by a factor of 2 each).
The ﬁnal convolutional layer with Tanh activation produces a single-channel audio waveform.
3. E NSEMBLE OF R ANDOM W INDOW D ISCRIMINATORS
Instead of a single discriminator, we use an ensemble of Random Window Discriminators ( RWD s) which operate on randomly sub-sampled fragments of the real or generated samples.
The ensemble allows for the evaluation of audio in different complementary ways, and is obtained by taking a Cartesian product of two parameter spaces: (i) the size of the random windows fed into the discriminator; (ii) whether a discriminator is conditioned on linguistic and pitch features.
For example, in our best-performing model, we consider ﬁve window sizes ( 240 , 480 , 960 , 1920 , 3600 samples), which yields 10 discriminators in total.
Notably, the number of discriminators only affects the training computation requirements, as at inference time only the generator network is used, while the discriminators are discarded.
However, thanks to the use of relatively short random windows, the proposed ensemble leads to faster training than conventional discriminators.
Using random windows of different size, rather than the full generated sample, has a data augmentation effect and also reduces the computational complexity of RWD s, as explained next.
In the ﬁrst layer of each discriminator, we reshape (downsample) the input raw waveform to a constant temporal dimension ω = 240 by moving consecutive blocks of samples into the channel dimension, i.e. from [ ωk, 1] to [ ω, k ] , where k is the downsampling factor (e.g. k = 8 for input window size 1920 ).
This way, all the RWD s have the same architecture and similar computational complexity despite different window sizes.
We conﬁrm these design choices experimentally in Section 5.
The conditional discriminators have access to linguistic and pitch features, and can measure whether the generated audio matches the input conditioning.
This means that random windows in conditional discriminators need to be aligned with the conditioning frequency to preserve the correspondence between the waveform and linguistic features within the sampled window.
This limits the valid sampling to that of the frequency of the conditioning signal ( 200 Hz, or every 5 ms).
The unconditional discriminators, on the contrary, only evaluate whether the generated audio sounds realistic regardless of the conditioning.
The random windows for these discriminators are sampled without constraints at full 24 kHz frequency, which further increases the amount of training data.
More formally, let λ = 120 denote the frequency ratio between waveform and linguistic features and let D C k ( (cid:63), ∗ ; θ ) and D U k
( (cid:63) ; θ (cid:48) ) be conditional and unconditional discriminator networks parametrized by θ and θ (cid:48) , respectively, which downsample the waveform input (cid:63) by a factor of k . 2 .
We deﬁne conditional and unconditional RWD s as stochastic functions:
[Equation]
where x and c are respectively the waveform and linguistic features and a l : r = ( a l , a l +1 , . . . , a r − 1 ) T denotes a vector slice.
The ﬁnal ensemble discriminator combines 10 different RWD ’s:
[Equation]
Algorithm 1 in Appendix D shows pseudocode for computation of RWD ∗ .
In Section 5 we describe other combinations of RWD s as well as a full, deterministic discriminator which we used in our ablation study.
3. D ISCRIMINATOR A RCHITECTURE
[Figure] The full discriminator architecture is shown in Figure 2.
The discriminators consists of blocks (DBlocks) that are similar to the GBlocks used without
The architectures of standard and conditional DBlocks are shown in Figures 1b and 1c respectively.
The only difference between the two DBlocks is that in the conditional DBlock, the embedding of the linguistic features is added after the ﬁrst convolution.
The ﬁrst and the last two DBlocks do not downsample (i.e. keep the temporal dimension ﬁxed).
Apart from that, we add at least two downsampling blocks in the middle, with downsample factors depending on k , so as to match the frequency of the linguistic features (see Appendix A.2 for details).
Unconditional RWD s are composed entirely of DBlocks.
In conditional RWD s, the input waveform is gradually downsampled by
DBlocks, until the temporal dimension of the activation is equal to that of the conditioning, at which point a conditional DBlock is used.
This joint information is then passed to the remaining DBlocks, whose ﬁnal output is average-pooled to obtain a scalar.
The dilation factors in the DBlocks’ convolutions follow the pattern 1 , 2 , 1 , 2 – unlike the generator, the discriminator operates on a relatively small window, and we did not observe any beneﬁt from using larger dilation factors. [Figure]
E VALUATION
We provide subjective human evaluation of our model using Mean Opinion Scores ( MOS ), as well as quantitative metrics.
4. MOS
We evaluate our model on a set of 1000 sentences, using human evaluators.
Each evaluator was asked to mark the subjective naturalness of a sentence on a 1-5 Likert scale, comparing to the scores reported by van den Oord et al.
(2018) for WaveNet and Parallel WaveNet.
Although our model was trained to generate 2 second audio clips with the starting point not necessarily aligned with the beginning of a sentence, we are able to generate samples of arbitrary length.
This is feasible due to the fully convolutional nature of the generator and carried out using a convolutional masking trick, detailed in Appendix A.1.
Human evaluators scored full sentences with a length of up to 15 seconds.
4. S PEECH D ISTANCES
We introduce a family of quantitative metrics for generative models of speech, which include the unconditional and conditional Fr ´ echet DeepSpeech Distance ( FDSD, cFDSD ) and Kernel DeepSpeech Distance ( KDSD, cKDSD ) .
These metrics follow common metrics used in evaluation of
GANs for images, Fr´echet Inception Distance (FID, Heusel et al., 2017) and Kernel Inception Distance (KID, Bi´nkowski et al., 2018).
FID and KID compute the Fr´echet distance and the Maximum Mean Discrepancy (MMD, Gretton et al., 2012) respectively between representations of reference and generated distributions extracted from a pre-trained Inception network (Szegedy et al., 2016).
To obtain analogous metrics for speech, we extract the features from an open-source implementation of an accurate speech recognition model, DeepSpeech
(Amodei et al., 2016).
Speciﬁcally, we use the implementation available in the NVIDIA OpenSeq2Seq library (Kuchaiev et al., 2018) and extract features from the last layer, whose output is used in the CTC loss during training.
We use representations in the resulting feature space to compute the Fr´echet distance and MMD (See Appendix B.1 for details).
We note that Kilgour et al.
(2019) proposed a similar metric, Fr´echet Audio Distance .
This metric uses a network trained for audio event classiﬁcation on the AudioSet dataset (Gemmeke et al., 2017) as a feature extractor, whereas we use a network that was trained for speech recognition.
As conditioning plays a crucial role in our task, we compute two variants of these metrics, conditional ( cFDSD, cKDSD ) and unconditional ( FDSD, KDSD ).
Both Fr´echet and Kernel distance provide scores with respect to a reference real sample and require both the real sample and the generated one to be independent and identically distributed.
Assume that variables x real and x G are drawn from the real and and generated distributions, while c is drawn from the distribution of linguistic features.
In the conditional case, cFDSD and cKDSD compute distances between conditional distributions p ( x G | c ) and p ( x real | c ) .
In the unconditional case, FDSD and KDSD compare p ( x G ) and p ( x real ) .
Both metrics are estimated using 10,000 generated and reference samples, drawn independently with the same (in the conditional case), or independent (in the unconditional case) linguistic features.
This procedure is detailed in Appendix B.3.
The main reason for using both Fr ´ echet and Kernel distances is the popularity of FID in the image domain, despite the issue of its biased estimator, as shown by Bi ´ nkowski et al.
Thanks to the availability of an unbiased estimator of MMD, this issue does not apply to kernel-based distances.
For instance, they yield zero values for real data, which allows comparison in the conditional case.
We give more details on these distances in Appendix B.2.
E XPERIMENTS
In this section we discuss the experiments, comparing GAN-TTS with WaveNet and carrying out ablations that validate our architectural choices.
As mentioned in Section 3, the main architectural choices made in our model include the use of multiple RWD s, conditional and unconditional, with a number of different downsampling factors.
We thus consider the following ablations of our best-performing model:
1. full-input discriminator FullD = D C 1 , 2.
single conditional RWD : cRWD 1 , 3.
multiple conditional RWD s: cRWD { 1 , 2 , 4 , 8 , 15 } = (cid:80) k ∈{ 1 , 2 , 4 , 8 , 15 } cRWD k , 4.
single conditional and single unconditional RWD : cRWD 1 + uRWD 1 , 5.
ﬁve independent cRWD s and uRWD s: ( cRWD 1 + uRWD 1 ) × 5 ( x, c ) :
= (cid:80)
i =1 cRWD 1 ( x, c ; θ i ) + uRWD 1 ( x ; θ (cid:48) i ) , 6.
10 RWD s without downsampling but with different window sizes: RWD 1 , 240 ×{ 1 , 2 , 4 , 8 , 15 } = (cid:80) k ∈{ 1 , 2 , 4 , 8 , 15 } ( cRWD 1 , 240 k + uRWD 1 , 240 k ) 7.
10 RWD s with longer window: RWD ∗ 480 .
All other parameters of these models were the same as in the proposed one.
In Appendix D we present details of the hyperparameters used during training as well as pseudocode for training GANTTS.
5. R ESULTS
Table 1 presents quantitative evaluations of the proposed model, together with benchmarks and other variants of GAN-TTS that we considered in this work.
Our best model achieves worse yet comparable scores to the strong baselines, WaveNet and Parallel
WaveNet.
This performance, however, has not yet been achieved using adversarial techniques and [Table] is still very good, especially when compared to parametric text-to-speech models.
These results are however not directly comparable due to dataset differences; for instance WaveNet and Parallel
WaveNet were trained on 65 hours of data, a bit more than GAN-TTS.
Our ablation study conﬁrms the importance of combining multiple RWD s. The deterministic full discriminator achieved the worst scores.
All multiple- RWD models achieved better results than a single cRWD 1 ; all models that used unconditional RWD s were better than those that did not.
Comparing 10-discriminator models, it is clear that combinations of different window sizes were beneﬁcial, as a simple ensemble of 10 ﬁxed-size windows was signiﬁcantly worse.
All three 10- RWD models with varying discriminator sizes achieved similar mean opinion scores, with the downsampling model with base window size 240 performing best.
We also observe a noticeable correlation between human evaluation scores (MOS) and the proposed metrics, which demonstrates that these metrics are well-suited for the evaluation of neural audio synthesis models.
5. D ISCUSSION
Random window discriminators.
Although it is difﬁcult to say why RWD s work much better than the full discriminator, we conjecture that this is because of the relative simplicity of the distributions that the former must discriminate between, and the number of different samples we can draw from these distributions.
For example, the largest window discriminators used in our best model discriminate between distributions supported on R 3600 , and there are respectively 371 and 44,401 different windows that can be sub-sampled from a 2s clip (real or generated) by conditional and unconditional RWD s of effective window size 3600.
The full discriminator, on the other hand, always sees full real or generated examples sampled from a distribution supported on R 48000 .
Computational efﬁciency.
Our Generator has a larger receptive ﬁeld (590ms, i.e. 118 steps at the frequency of the linguistic features) and three times fewer FLOPs (0.64 MFLOP/sample) than
Parallel WaveNet (receptive ﬁeld size: 320ms, 1.97 MFLOP/sample).
However, the discriminators used in our ensemble compare windows of shorter sizes, from 10ms to 150ms.
Since these windows are much shorter than the entire generated clips, training with ensembles of such RWD s is faster than with FullD .
In terms of depth, our generator has 30 layers, which is a half of Parallel WaveNet’s, while the depths of the discriminators vary between 11 and 17 layers, as discussed in Appendix A.2.
Stability.
The proposed model enjoyed very stable training, with gradual improvement of subjective sample quality and decreasing values of the proposed metrics.
Despite training for as many asmillion steps, we have not experienced model collapses often reported in GAN literature and studied in detail by Brock et al.
C ONCLUSION
We have introduced GAN-TTS, a GAN for raw audio text-to-speech generation.
Unlike state-ofthe-art text-to-speech models, GAN-TTS is adversarially trained and the resulting generator is a feed-forward convolutional network.
This allows for very efﬁcient audio generation, which is important in practical applications.
Our architectural exploration lead to the development of a model with an ensemble of unconditional and conditional Random Window Discriminators operating at different window sizes, which respectively assess the realism of the generated speech and its correspondence with the input text.
We showed in an ablation study that each of these components is instrumental to achieving good performance.
We have also proposed a family of quantitative metrics for generative models of speech: (conditional) Fr´echet DeepSpeech Distance and (conditional) Kernel DeepSpeech Distance , and demonstrated experimentally that these metrics rank models in line with Mean Opinion Scores obtained through human evaluation.
As they are based on the publicly available DeepSpeech recognition model, they will be made available for the machine learning community.
Our quantitative results as well as subjective evaluation of the generated samples showcase the feasibility of text-to-speech generation with GANs.
A A RCHITECTURE DETAILS A. M ASKING CONVOLUTIONS TO GENERATE LONGER SAMPLES
Since our generator is a fully-convolutional network, in theory it is capable of generating samples of arbitrary length.
However, since deep learning frameworks usually require processing ﬁxed-size samples in batches for efﬁciency reasons, our inputs of different lengths need to be zero-padded to ﬁt in a ﬁxed-size tensor.
Convolutional layers, including the ones used in our model, often pad their inputs to create outputs of the desired dimensionality, hence we only need to ensure that the padded part of the input tensors to all layers is always zero.
As shown in Figure 3, this would not normally be the case after the second convolutional layer, since convolutions (with kernel sizes greater than one) would propagate non-zero values outside the border between meaningful input and padding.
A simple way to address this issue is masking, i.e. multiplying the input by a zero-one mask tensor, directly before each convolutional layer.
This enables batched sampling of utterances of different length, which is efﬁcient on many hardware platforms, optimised for batching.
A. G ENERATOR AND D ISCRIMINATOR DETAILS
layer/input t freq.
ch linguistic features , z 200Hz conv, kernel size 200Hz
[Table]
In Table 2 we present the details of Generator architecture.
Overall, the generator has 30 layers, most of which are parts of dilated residual blocks
[Table]
Table 3 shows the numbers of residual DBlocks and downsample factors in these blocks for different initial downsample factors of RWD s.
[Table]
All conditional discriminators eventually add the representations of the waveform and the linguistic features.
This happens once the temporal dimension of the main residual stack is downsampled to the dimension of the linguistic features, i.e. by a factor of 120.
Downsampling is carried out via an initial reshape operation (by a factor k varying per RWD ) and then in residual blocks, whose downsample factors are prime divisors of 120 /k , in decreasing order.
For unconditional discriminators, we use only the ﬁrst two largest prime divisors of 120 /k .
Algorithm 1 in Appendix D presents pseudocode for forward pass through RWD ensemble.
B D EEP S PEECH DISTANCES - DETAILS B. D EEP S PEECH
Our evaluation metrics extract high-level features from raw audio using the pre-trained DeepSpeech model from the NVIDIA OpenSeq2Seq library (Kuchaiev et al., 2018).
Let w = 480 be a 20 ms window of raw audio at 24kHz, and let f : R w −→ R 1600 be a function that maps such a window through the DeepSpeech2 network up to the 1600-dimensional output of the layer labeled
ForwardPass/ds2_encoder/Reshape_2:0 .
We use default values for all settings of the
DeepSpeech2 model; f also includes the model’s preprocessing layers.
For a 2s audio clip a ∈ R 100 w , we deﬁne
[Equation]
where a i : j = ( a i , a i +1 , . .
, a j − 1 ) (cid:48) is a vector slice.
The function DS therefore computes 1600 features for each 20ms window, sampled evenly with 10ms overlap, and then takes the average of the features along the temporal dimension.
B. M ETRICS IN DISTRIBUTION SPACE
Given samples X ∈ R m × d and Y ∈ R n × d , where d is the representation dimension, the Fr´echet distance and MMD can be computed using the following estimators:
[Equation]
where µ X , µ Y and Σ X , Σ Y are the means and covariance matrices of X and Y respectively, while k : R d × R d −→ R is a positive deﬁnite kernel function.
Following Bi´nkowski et al.
we use the polynomial kernel
[Equation]
Estimator (5) has been found to be biased (Bi´nkowski et al., 2018), even for large sample sizes.
For this reason, FID estimates for real data (i.e. when X and Y are both drawn independently from the same distribution) are positive, even though the theoretical value of such a metric is zero.
KID, however, does not suffer from this issue thanks to the use of the unbiased estimator (6).
These properties also apply to the proposed DeepSpeech metrics.
The lack of bias in an estimator is particularly important for establishing scores on real data for conditional distances.
In our conditional text-to-speech setting, we cannot sample two independent real samples with the same conditioning, and for this reason we cannot estimate the value of cFDSD for real data, which would be positive due to bias of estimator (5).
For cKDSD , however, we know that such an estimator would have given values very close to zero, if we had been able to evaluate it on two real i.i.d.
samples with the same conditioning.
B. D ISTANCE ESTIMATION
Let G and DS represent the generator function and a function that maps audio to DeepSpeech features as deﬁned in Eq.
Let
[Equation]
where ( x i , c i ) iid ∼ p ( x real , c ) , i = 1 , . . .
, 2 N are jointly sampled real examples and linguistic features, and z i iid ∼ N (0 , 1) .
In the conditional case, we use the same conditioning in the reference and generated samples, comparing conditional distributions p ( x G | c ) and p ( x real | c ) :
[Equation]
[Equation]
where ÷ Fr ´ echet and ’ MMD are estimators of the Fr ´ echet distance and MMD deﬁned in Eq.
5 and 6, respectively.
In the unconditional case, we compare p ( x G ) and p ( x real ) :
[Equation]
C µ - LAW PREPROCESSING
Many generative models of audio use the µ -law transform to account for the logarithmic perception of volume.
Although µ -law is typically used in the context of non-uniform quantisation, we use the transform without the quantisation step as our model operates in the continuous domain:
[Equation]
where x ∈ [ − 1 , 1] and µ = 2 8 − 1 = 255 for 8-bit encoding or µ = 2 16 − 1 = 65 , 535 for 16-bit encoding.
Our early experiments showed better performance of models generating µ -law transformed audio than non-transformed waveforms.
We used the 16-bit transformation.
D T RAINING DETAILS
We train all models with a single discriminator step per generator step, but with doubled learning rate: 10 − 4 for the former, compared to 5 × 10 − 5 for the latter.
We use the hinge loss (Lim & Ye, 2017), a batch size of 1024 and the Adam optimizer (Kingma & Ba, 2015) with hyperparameters β 1 = 0 , β 2 = 0 .
Following Brock et al.
(2019), we use spectral normalisation (Miyato et al., 2018) and orthogonal initialisation (Saxe et al., 2014) in both the generator and discriminator(s), and apply off-diagonal require: N - waveform length, λ - waveform-conditioning frequency ratio, ω - base window size, n steps - number of training steps, n batch - batch size, η D , η G - discriminator and generator learning rates. 1: procedure RWD *( x, c, θ ∗ ) (cid:46) Compute value of RWD s ensemble 2: v ←3: for k ∈ { 1 , 2 , 4 , 8 , 15 } do (cid:46) conditional RWD s 4: j ← U ( { 0 , λ, 2 λ, . . . , N − ωk } ) (cid:46) sample random index 5: ¯ x ← x j : j + ωk (cid:46) assign the slice of waveform 6: ¯ c ← c j/λ :( j + ωk ) /λ
(cid:46) assign the corresponding slice of conditioning 7: v ← v + D Ck (¯ x, ¯ c ; θ k ) 8: end for 9: for k ∈ { 1 , 2 , 4 , 8 , 15 } do (cid:46) unconditional RWD s 10: j ← U ( { 0 , 1 , . .
. , N − ωk } ) (cid:46) sample random index 11: ¯ x ← x j : j + ωk (cid:46) assign the slice of waveform 12: v ← v + D Uk (¯ x ; θ (cid:48) k ) 13: end for 14: return v 15: end procedure 1: procedure TTS-GAN( ψ, θ ∗ ) (cid:46) Main training algorithm 2: for s :=
1 to n steps do 3:
#discriminator step 4: (( x 1 , c 1 ) , . . .
, ( x n batch , c n batch ))
iid ∼ p ( x , c ) (cid:46) sample batch of iid real waveforms and corresponding linguistic features 5: c (cid:48) ← ( c (cid:48)
, c (cid:48) n batch ) iid ∼ p ( c ) (cid:46) sample batch of iid linguistic features 6: z ← ( z 1 , . .
, z n batch )
iid ∼ N (0 , I 128 ) (cid:46) sample noise 7: x (cid:48) ← G ( c (cid:48) , z ; ψ ) (cid:46) generate fake waveforms 8: l D ← 1 n batch (cid:80) n batch i =
((1 − RWD ∗ ( x i , c i , θ ∗ ))
+
+ (1 + RWD ∗ ( x (cid:48)
i , c (cid:48)
i , θ ∗ )) + ) 9: (cid:46) compute D s’ loss 10: θ ∗ ← Adam ( ∇ θ ∗ l D , η D ) (cid:46) update D s 11: #generator step 12: c (cid:48) ← ( c (cid:48) 1 , . . .
, c (cid:48) n batch )
iid ∼ p ( c ) (cid:46) sample batch of iid linguistic features 13: z ← ( z 1 , . . . ,
z n batch )
iid ∼ N (0 , I 128 ) (cid:46) sample noise 14: x (cid:48) ← G ( c (cid:48) , z ; ψ ) (cid:46) generate fake waveforms 15: l G ← − 1 n batch (cid:80) n batch i =
RWD ∗ ( x (cid:48) i , c (cid:48) i , θ ∗ ) (cid:46) compute G ’s loss 16: ψ ← Adam ( ∇ ψ l G , η G ) (cid:46) update G 17: end for 18: return 19: end procedure orthogonal regularisation (Brock et al., 2016; 2019) and exponential moving averaging to the generator weights with a decay rate of 0.9999 for sampling.
We also use cross-replica BatchNorm (Ioffe & Szegedy, 2015), which aggregates batch statistics from all devices across which the batch is split and standing statistics during sampling.
The latter means that we accumulate batch statistics from 100 forward passes through the generator before the actual sampling takes place, allowing for inference at arbitrary batch sizes.
In fact, accumulating standing statistics makes the BatchNorm layers in the generator independent of any characteristics of the samples produced during inference.
This technique is thus vital for sampling audio of unspeciﬁed length: producing samples that are longer than those used during training typically requires using a smaller batch size, with partially padded samples (See Appendix A.1).
These smaller batches would naturally have different statistics than the batches used during [Figure] training.
We trained our models on Cloud TPU v3 Pods with data parallelism over 128 replicas for 1 million generator and discriminator updates, which usually took up to 48 hours. In Algorithm 1 we present the pseudocode for training GAN-TTS.
Figure 4 presents the stable and gradual decrease of cFDSD during training.