A Deep Generative Model for Code-Switched Text

TL;DR

This paper introduces VACS, a novel variational autoencoder designed to generate realistic, diverse code-switched text by modeling syntactic and language-switching signals, improving language modeling in multilingual NLP tasks.

Contribution

VACS is the first hierarchical VAE architecture specifically tailored for code-switching, enabling effective synthesis of realistic code-switched sentences.

Findings

Synthetic code-switched text reduces perplexity by 33.06%.

VACS generates well-formed, diverse code-switched sentences.

Improves language modeling for code-switched NLP tasks.

Abstract

Code-switching, the interleaving of two or more languages within a sentence or discourse is pervasive in multilingual societies. Accurate language models for code-switched text are critical for NLP tasks. State-of-the-art data-intensive neural language models are difficult to train well from scarce language-labeled code-switched text. A potential solution is to use deep generative models to synthesize large volumes of realistic code-switched text. Although generative adversarial networks and variational autoencoders can synthesize plausible monolingual text from continuous latent space, they cannot adequately address code-switched text, owing to their informal style and complex interplay between the constituent languages. We introduce VACS, a novel variational autoencoder architecture specifically tailored to code-switching phenomena. VACS encodes to and decodes from a two-level hierarchical representation, which models syntactic contextual signals in the lower level, and language switching signals in the upper layer. Sampling representations from the prior and decoding them produced well-formed, diverse code-switched sentences. Extensive experiments show that using synthetic code-switched text with natural monolingual data results in significant (33.06%) drop in perplexity.

Tables

Table 1. Table 1: Different code-switching metrics of real and generated code-switched text.

Dataset	Avg CMI	M-index	Burstiness	Span Entropy
rCS-train	0.56	0.778	0.232	1.498
pVAE-gCS	-0.20	+0.108	+0.081	-0.527
rVAE-gCS	+0.01	+0.216	+0.058	-0.375
VACS-gCS	+0.08	+0.078	+0.065	-0.192
aLM-gCS	+0.12	+0.201	+0.036	-0.299
bLM-gCS	+0.14	+0.155	+0.023	-0.287
rGAN-gCS	+0.17	+0.219	+0.081	-0.622

Table 2. Table 2: Perplexity of payload language model using different training curricula. VACS achieves the lowest perplexity. Green: lower perplexity than Mono baseline; yellow and red: larger perplexity than Mono baseline (gray).

	Training Curricula	Valid PPL	Test PPL
1	Mono	3034.251	3123.827
2a	aLM-gCS $\mid$ Mono	3094.998	3179.039
	bLM-gCS $\mid$ Mono	3051.042	3123.510
	rGAN-gCS $\mid$ Mono	3206.175	3298.085
	pVAE-gCS $\mid$ Mono	2383.426	2337.617
	VACS-gCS $\mid$ Mono	2243.578	2296.533
2b	Mono $\mid$ aLM-gCS	3083.314	3189.905
	Mono $\mid$ bLM-gCS	2829.149	2896.337
	Mono $\mid$ rGAN-gCS	3015.820	3069.263
	Mono $\mid$ pVAE-gCS	2807.296	2869.633
	Mono $\mid$ rVAE-gCS	2418.342	2493.023
	Mono $\mid$ VACS-gCS	2081.774	2090.781

Table 3. Table 3: Sentences synthesized by VACS. Each row corresponds to sentences sampled from a fixed context representation. The Blue segments are in Hindi. Green: English translation of CS text.

	Sentences
a	hara gaya pakistan hamen logon ke tweet rato karane (Pakistan defeats us to stop people from tweeting) apane logon ko batting upalabdh series ke (Batting series available to our people) cricket run banaake kiya SA ke haar (Defeated SA by making runs in cricket)
b	ladakiyon 20 assembly pratishat se (Girls from 20 assembly percent) vichaar bhee bikree that is 25 guna assembly ka (Justice is also sold, that is 25 times assembly) assembly against asia pradesh irfaan teesree har breaking (Assembly against asia irfaan’s third deafeat was breaking)
c	sarkar kee sthaapana jawaharlal achchhee ki (Government’s establishment was done well by Jawaharlal) normal bikree vaalee ek tha smartphone (One smartphone was for normal sale) modi aye ke break it in 54 wheels (Modi came and break it in 54 wheels)

Equations

$$\displaystyle\max_{\phi}\max_{\theta}\mathbb{E}_{D}\Bigl{[}\mathbb{E}_{q_{\phi}(z|x)}\log p_{\theta}(x|z)-\text{KL}\bigl{(}q_{\phi}(z|x)||p_{\pi}(z)\bigr{)}\Bigr{]}$$

$$q_{\varphi }(Z|x)$$

$$p_{\pi }(Z)$$

$$p_{\theta }(x|Z)$$

$$\text{We initialize}{h}_0^{(q,c)}$$

$$\text{For i=1,…,I:}{h}_i^{(q,c)}$$

$$\text{Finally,}[{\mu }_{q,c},{\sigma }_{q,c}]$$

$$\text{and then}{z}_c\sim q_{\varphi }(z_c|\mathbf{W})$$

$$\text{We initialize}{h}_0^{(q,l)}$$

$$\text{For i=1,…,I:}{h}_i^{(q,l)}$$

$$\text{Finally,}[{\mu }_{q,l},{\sigma }_{q,l}]$$

$$\text{and then}{z}_l\sim q_{\varphi }(z_l|z_c,\mathbf{Y})$$

$$\text{Overall,}{q}_{\varphi }(Z|\mathbf{W},\mathbf{Y})$$

$$\text{We initialize}{h}_0^{(p,l)}$$

$$\text{For o=1,…,O:}{h}_o^{(p,l)}$$

$$y_o$$

$$[{\mu }_{p,c},{\sigma }_{p,c}]$$

$$z_c\sim p_{\theta }(z_c|z_l,h_O^{(p,l)})$$

$$\text{We initialize}{h}_0^{(p,c)}$$

$$\text{For o=1,…,O:}{h}_o^{(p,c)}$$

$$w_o$$

$$p_{\pi }(z_l)$$

$$p_{\pi }(Z)$$

$$\underset{\varphi ,\theta }{\max }$$

$$-{\mathbb{E}}_{q_{\varphi }(z_c|{\mathbf{W}}^{(m)})}\text{KL}(q_{\varphi }(z_l|z_c,{\mathbf{Y}}^{(m)})||p_{\pi }(z_l))$$

$$\displaystyle-\mathbb{E}_{q_{\phi}(z_{c}|\bm{W}^{(m)}),p_{\theta}(z_{c}|z_{l})}\text{KL}(q_{\phi}(z_{c})||p_{\theta}(z_{c}|z_{l}))\Bigr{]}$$

Full text

††*∗*Both the authors contributed equally

1 Introduction

Multilingual text is very common on social media platforms like Twitter and Facebook. A prominent expression of multilingualism in informal text and speech is code-switching: alternating between two languages, often with one rendered in the other’s character set. Many NLP tasks benefit from accurate statistical language models. Therefore, extending monolingual language models to code-switched text is important.

Many state-of-the-art monolingual models are based on recurrent neural networks (RNNs) [7, 11, 27]. We call them RNN language models or RNNlms. RNNlm decoders, conditioned on task-specific features, are heavily used in machine translation [25, 1], image captioning [26, 9] textual entailment [4] and speech recognition [8].

Training RNNlms is data-intensive. The paucity of language-tagged code-switched text has been a major impediment to training RNNlms well. This strongly motivates the automatic generation of plausible synthetic code-switched text to train state-of-the-art neural language models.

Synthetic but realistic monolingual text generation is itself a challenging problem, on which recent deep generative techniques have made considerable progress. Two generative architectures are predominantly used: (a) Generative Adversarial Networks (GAN) [12] and (b) Variational AutoEncoders (VAE) [16]. Several recent works have successfully extended GANs [28, 14] and VAEs [5] to generate diverse and plausible synthetic monolingual texts.

Generating plausible code-switched text is an even more delicate task than generating monolingual text. Linguistic studies show that bilingual speakers switch languages by following various complex constraints [18, 17] which may even include the intensity of sentiment expressed in various segments of text [23]. [20] synthesized code-mixed sentences by leveraging linguistic constraints arising from Equivalence Constraint Theory. While this works well for language pairs with good structural correspondence (like English-Spanish), we observe performance degrades with weaker correspondence (like English-Hindi).  [3] proposes a method to generate code-switched text given a source and target sentence pair, however they can only generate restrictive set of switching patterns. Therefore, a code-switched text synthesizer needs to learn overall syntax distributions of code-switched sentences, as well as model complex switching patterns conditioned on it.

Owing to its great syntactic and switching diversity, large volumes of language-labeled code-switched text is needed to train monolingual deep generative models, which are not available. The only alternative is to train monolingual models with parallel corpora of the two constituent languages which may be relatively easily obtainable. However, training a GAN with aligned parallel corpora may not help, because it is designed to generate a sentence from a noise distribution instead of any learned latent embedding space. Using a VAE RNNlm [5] is more promising. Aligned parallel corpora are expected to yield similar representations for a source-target sentence pair. Therefore, a VAE decoder conditioned on this embedding may generate some code-switch text without applying explicit external force. However, it is unlikely to learn subtle connections between context and switching decisions as well as a customized VAE solution, which is our goal.

Here we present VACS, a new deep generator of code-switched text, based on a hierarchical VAE augmented with language- and syntax-informed switching components.

• •

Observed language-labeled code-switched text is encoded to a two-layer compressed representation. The lower layer encodes sequential word context. Conditioned on this lower layer, the encoder models the switching behavior in the higher layer. This contrasts with existing dual-RNNlm architectures [11] that do not have any explicit gadget to model the switching behavior. Our encoder learns the two-layer representation via variational inference so that the resulting encoded representations enable our decoder to readily generate new code-mixed sentences.

• •

Our decoder is designed to sample a context sequence, given a switching pattern. Unlike previous RNNlms [7] which consider context and tag generation as independent processes, the decoder of VACS first decodes a switching pattern from the switching embedding and then uses this switching pattern memory as well as the lower-layer compressed encoding, to generate a context sequence. The restricted word sequence sampling space improves output quality.

• •

During the decoding process, VACS (trivially) generates the language labels for each word in the sentence. Thus, VACS lets us synthesize unlimited amounts of labeled code-switched text, starting with modest-sized samples.

Owing to the asymmetry between word and label sequences, our encoder and decoder layers show some asymmetries tailored to code-switching, which distinguishes VACS from a regular RNN-based VAE.

Through extensive experiments reported here, we establish that augmenting scarce natural labeled code-switched text with plentiful synthetic code-switched text generated by VACS significantly improves the perplexity of state-of-the-art language models. The perplexity of the models on held-out natural Hindi-English text drops by 33.32% compared to using only natural training data. Manual inspection also shows that VACS generates sentences with diverse mixing patterns.111https://github.com/bidishasamantakgp/VACS

2 Background on VAEs

VAEs [16] are among the most popular deep generative models. They define a decoding probability distribution $p_{\theta}(x|z)$ to generate observation $x$, given latent variables $z$, which are sampled from a simple prior distribution $p_{\pi}(z)$. The objective of the VAE is to learn an approximate probabilistic inference model $q_{\phi}(z|x)$ that encodes latent factors or features $z$ of the variation in the observed data $x$.

Distributions $p$ and $q$ are often parameterized using deep neural networks. We use the maximum likelihood principle to train a VAE, i.e., maximize the expected lower bound of the likelihood on observed data $x\sim D$:

[TABLE]

To represent more complex features in the latent space, multiple VAEs are stacked hierarchically [21, 24]. The stack of latent variables $Z$ are designed to learn a “feature hierarchy”. For a hierarchical VAE with $\Lambda$ layers, the prior, encoding and decoding probability distributions are modeled as below:

[TABLE]

The performance of the above scheme is sensitive to the design of the layers. Layers $\lambda\gg 1$ may fail to capture extra information. Excessively deep hierarchies with large $\Lambda$ may lead to training difficulties [24].

3 VACS: A VAE for code-switched text

This section gives a high-level overview of VACS, followed by details of the building blocks, highlighting key advances beyond prior art. Our focus will be on components that implement a context-based switching distribution. Later, we describe the training process and other implementation details.

3.1 Overview

We aim to design a VAE for code-switched text, which, once trained on a collection of tagged code-mixed text should be able to generate new code-mixed text from the same vocabulary. We represent a code-switched sentence $S$ as $\{(w_{i},y_{i}):i=1,\ldots,|S|\}$, where $(w_{i},y_{i})$ is a pair comprised of a word $w_{i}$ at position $i$ and the corresponding language label $y_{i}$ to which it belongs. Here we consider the simple case of switching between two languages, a source language $s$ and a target language $t$. Let SOS, EOS denote start and end of sentence markers. Generation of output stops when label EOS is generated. We let $y_{i}$ take values from $\{s,t,\texttt{EOS}\}$. When discrete values like $w_{i},y_{i}$ are input to networks, they are one-hot encoded. VACS is characterized by these components:

Prior:

$p_{\pi}(Z)$

Inference model (encoder):

$q_{\phi}(Z|\bm{W},\bm{Y})$

Generative model (decoder):

$p_{\theta}(\bm{W},\bm{Y}|Z)$

In our formulation, $Z$ will consist of two latent encoded representations $z_{l}$ and $z_{c}$. Here $z_{l}$ is the representation of language-switching behavior, which is generated conditioned on the context representation $z_{c}$, which captures syntactic and structural properties of a sentence. $\bm{W}$ is the observed sequence of words and $\bm{Y}$ is the corresponding label sequence. Given our objective, a hierarchical VAE architecture is adapted for the basic formulation with suitable departures whenever required. The next subsections will cover in details the inference model, generative model and prior.

3.2 Encoder

Given observed labeled sentence $(\bm{W},\bm{Y})$, our inference model $q_{\phi}$ defines a hierarchical probabilistic encoding $Z=(z_{c},z_{l})$ by first learning the content, structural embedding $z_{c}$ of the entire sentence. Using this embedding $z_{c}$ along with sequentially learned language label information the inference model $q_{\phi}$ encodes the latent switching pattern embedding $z_{l}$. Figure 1 (a) illustrates the encoder. We use two distinct RNN (LSTM) cells in the encoder, $r_{q,c}$ and $r_{q,l}$. Their corresponding recurrent states are denoted $h^{(q,c)}$ and $h^{(q,l)}$. Input token positions are indexed as $i=0,1,\ldots,I$. The recurrence to estimate $z_{c}$ goes like this.

[TABLE]

Here, $\mu_{q,c},\sigma_{q,c}$ are the mean and standard deviation for the context encoding and $\mu_{q,l},\sigma_{q,l}$ are the mean and standard deviation for the switching behavior encoding distribution. $\mathcal{N}$ denotes normal distribution. $\text{diag}(\cdot)$ represents a diagonal covariance matrix. $f_{q,c},f_{q,l}$ are modeled as feed forward stages, $r_{q,c},r_{q,l}$ are designed as recurrent units. We use the subscript $q$ (or $p$) to highlight if it belongs to encoder (or decoder).

Summarizing the distinction from traditional hierarchical VAE, VACS’s inference module accepts inputs in both encoding layers: word sequence at the ground layer and language label sequence at the upper layer. Learning a sequence model over language labels becomes difficult (even with hierarchical encoding) if we provide both the inputs only in the lowest level, possibly by concatenating suitable embeddings [27].

3.3 Decoder

Starting from $Z=(z_{l},z_{c})$, our probabilistic decoder generates synthetic code-switched text with per-token language ID labels, using a two-level hierarchy of latent encoding. However, unlike the conventional hierarchical variational decoder, VACS decodes a switching pattern given $z_{l}$ at the upper level, then conditioned on $z_{l}$ and the decoded tag history it generates a content distribution $z_{c}$. Here we need to design a specific decoupling mechanism of $z_{c}$ from $z_{l}$, which is not just the reverse of encoding technique. As $z_{l}$ has the switching information as well as the context information, we use both $z_{l}$ and $h(y)$ which is the history of label decoding to decode the distribution of $z_{c}$. We design the loss in such a way that tries to minimize the difference between encoding and decoding distribution of $z_{c}$.

We use two distinct RNN (LSTM) cells in the decoder, $r_{p,l}$ and $r_{p,c}$. Their corresponding recurrent states are denoted $h^{(p,l)}$ and $h^{(p,c)}$. Output token positions are indexed $o=1,\ldots,O$. The feedforward network to convert $h^{(p,l)}_{o}$ to a multinomial distribution over $y_{o}$ is called $f_{p,l}$.

[TABLE]

Decoding continues until some $y_{O}=\texttt{EOS}$ is sampled at some $O$, and then stops. Effectively this amounts to sampling from $p_{\theta}(\bm{Y}|z_{l})$. Once all labels $\bm{Y}=y_{1},\ldots,y_{O}$ are generated, we decode $z_{c}$ and start generating words $w_{1},\ldots,w_{O}$. $f_{p,c}$ denotes the feedforward network to decode $z_{c}$ as follows.

[TABLE]

The feedforward network $f_{p,w}$ converts $h^{(p,c)}_{o}$ to a multinomial distribution over words from the languages indicated by $y_{1},\ldots,y_{O}$.

[TABLE]

If $y_{o}=s$, $f_{p,c}$ returns a multinomial distribution over the source vocabulary, and if $y_{o}=t$, $f_{p,c}$ returns a multinomial distribution over the target vocabulary. Effectively, we have sampled $\bm{W}$ from the distribution $p_{\theta}(\bm{W}|\bm{Y},z_{c})$. Overall, decoding amounts to sampling from $p_{\theta}(\bm{Y},\bm{W}|Z)=p_{\theta}(\bm{Y}|z_{l})\;p_{\theta}(\bm{W}|\bm{Y},z_{c})$.

Figure 1 (b) illustrates the decoder architecture. VACS departs from existing dual RNN architectures [11] (two RNNs dedicated to $s$ and $t$) in the following two ways:

• •

Instead of using a softmax output of two decoding RNNs corresponding to two language generators, VACS learns to decode language labels explicitly from a latent space.

• •

By using tightly-coupled decoding RNNs, parameter learning in VACS becomes more effective.

This way the decoder can generate word sequence in a more controlled fashion. The recursive word decoding unit generates a word given the predicted label from the language ID decoding layer.

3.4 Prior

The latent variable $z_{l}$ can be sampled from the standard normal distribution:

[TABLE]

3.5 Training

Given a collection of $M$ code-switched text ${S^{(m)}=(\bm{W}^{(m)},\bm{Y}^{(m)}):m=1,\ldots,M}$, we train our model by maximizing the evidence lower bound (ELBO), as described in Section 2. In our case, after taking into consideration the dependence between $z_{c}$ and $z_{l}$, the ELBO can be simplified to:

[TABLE]

Because human-labeled code-mixed text is scarce, we first train VACS with the parallel corpora specified in Section 4.1, with aligned word embeddings. Then we further tune model parameters using real code-switched data, also specified in Section 4.1. We used Adam optimiser and KL cost annealing technique as described  [5] to train VACS.

4 Experimental setup

Here, we describe the labeled data sets, baseline paradigms, and evaluation criteria, followed by the description of language models used to evaluate the utility of the synthesized text.

4.1 Data sets to train generative models

To train the generative models, we use a subset of the (real) Hindi-English tweets collected by [19] and automatically language-tagged by [22] with reasonable accuracy. From this set we sample 6K tweets where code-switching is present, which we collect into folds rCS-train, rCS-valid. 5K tweets are found labeled with only one language. These monolingual instances are converted into parallel corpora by translating Hindi sentences to English and vise versa using Google Translation API222https://translation.googleapis.com, generating 10K instances. The word embeddings of the two languages are aligned.

4.2 Baseline generative models

Deep generative models. To understand the difficulties of extending existing monolingual text generators to code-switched text, we design four baselines from two state-of-the-art generative models. [5] showed impressive results at generating monolingual sentences from a continuous latent space. They extended RNNlms with a variational inference mechanism. However, their model does not allow inclusion of hand crafted features like language ID, POS tag etc. Meanwhile, [28] proposed a GAN model to generate a diverse set of sentences. Based on these, our baseline approaches are:

pVAE:

We train the network of [5] with the parallel corpora. The probability of generating a word is designed as a softmax over the union vocabulary. As both of the corpora are mapped to the same latent space due to aligned embeddings, we expect the model to switch language whenever it finds a word from the other language more probable than a word in the same language as the current word.

rVAE:

To further make the model learn specific switching behaviors we train the model with the real code mixed text along with the parallel data.

pGAN:

Similar to pVAE, we train the network proposed by [28] with the parallel text corpora.

rGAN:

GAN trained with the real code-switched data along with the parallel corpora.

RNNlm based generative models. Though language models are built primarily to estimate the likelihood of a given sentence, they can also be used as a generative tool. Recently, RNN based language models have been used to generate code-switched text as well, giving significant perplexity reduction compared to generic language models that do not consider features specific to code-switching. We compare VACS against the following code-switched LMs:

aLM:

We train the system proposed by [27] using the real code-switched text and then use a word decoder and language decoder to generate synthetic texts.

bLM:

After training the system proposed by [7] with the real code-mixed text, we use their LSTM decoder to generate synthetic text.

4.3 Direct/intrinsic evaluation

Here we analyse the features like length distribution and diversity of code-switching of generated synthetic texts. We also measured one sentence level metric Code-Mixing Index (CMI) coined by  [10], and three corpus level metrics Multilingual index (M-Index), Burstiness and Span Entropy that were introduced in  [13] to demonstrate how different the generated texts are from the training corpus in terms of switching.

4.4 Indirect/extrinsic evaluation

We will use prior methods and VACS to generate large volumes of code-switched text. These will be used to train a payload language model (as distinct from the generative model of VACS and baselines) — specifically, the character-level LSTM proposed by [15]. Each training corpus will result in a trained payload model. The various payload models will then be used to calculate perplexity [6] scores on a held-out natural code-switched corpus. The assumption is that the payload model with the smallest perplexity was trained by the ‘best’ synthetic text.

Training curricula:

[2] show that language models perform better when trained with an interleaved curriculum of monolingual text from both the participating languages, then ending with code-switched (CS) text, rather than randomly mixing them. We build the curriculum from the following corpora:

Mono:

2K monolingual Hindi and 2K monolingual English tweets were sampled from the dataset. We translated Hindi to English and vice versa and make a set of 8K tweets.

X-gCS:

This is the generated synthetic data. We sampled 5K generated synthetic code-switched text from various generative models. Here X denotes the generative method, which is one of {pVAE, rVAE, pGAN, rGAN, aLM, bLM, VACS}.

The specific curricula we use are:

Mono,

which uses no synthetic data.

gCS $|$ Mono,

first synthetic then parallel monolingual.

Mono $|$ gCS,

first parallel monolingual, then synthetic.

Here $C_{1}|C_{2}$ denotes the sequence of corpora used to train the language model. Designing multi-task losses to guard against catastrophic forgetting is left for future work.

Validation and testing:

We sample 7K instances from the original real code-switched pool for validation and 7K for testing. These are considered as scarce evaluation resources and not used in payload training.

5 Results and analysis

In Section 5.1 we compare intrinsic properties of synthetic texts generated from various models. In Section 5.2 we compare perplexities of payload language models prepared from text synthesized by various generators. Finally, in Section 5.3, we present anecdotes about generated text and its quality. pGAN fails to generate any appreciable rate of code-switching. Therefore, we refrain from considering pGAN any further.

5.1 Intrinsic properties of synthesized text

Based on 5000 synthetic sentences sampled from different generative methods, we report the following properties.

Length:

We investigate the quality of generation methods in terms of variation in length and diversity. Figure 2 depicts that VACS can generate sentences of different sizes, unlike the other generative models which can only produce short texts. Other than bLM, all baselines tend to produce sentences shorter than 15 words. But Figure 2 shows that real sentences have average length $\sim$16 and may be as long as 25 words. rGAN generates very short sentences, at most 5 words long, and pVAE and rVAE generate sentences with an average length of $\sim$10. For aLM and bLM average lengths are $\sim$10 and $\sim$12 respectively. VACS has a mean of $\sim$17 and follows the distribution of real code-switched data most closely.

CMI, M-index, Burstiness, Span-Entropy:

We report the metric values of the generated corpus and the real corpus in Table 1. VACS is closest to the real corpus in terms of M-index and Span entropy, which indicates the ratio different language tokens in the generated sentences and language span distribution is closer to the real data. Though VACS produces a larger CMI and burstiness as it can produce sentences of different lengths and various switching patterns; its CMI is still smaller than GAN, aLM, and bLM and burstiness smaller than GAN and pVAE. GAN generates the highest CMI and burstiness indicating haphazard switching patterns. On the other hand, pVAE produces lowest CMI and span entropy indicating that the generated sentences are “almost monolingual” or the language spans are equal in length. rVAE produces CMI very close to real and less diverse in terms of both switching and length distribution. Along with generating Burstiness with various switching patterns GAN also has highest burstiness

5.2 Extrinsic perplexity

Table 2 provides a comparative study on the perplexity achieved on real validation and test CS text, after training a payload language model with different curricula spanning parallel monolingual (Mono) and synthetically generated CS (gCS) text.

Obviously, a payload language model that has seen only monolingual text when training will have large perplexity on held-out real CS text, which shows a diversity of switching behavior, in terms of both syntax structure near switches and the distribution of words used in switched segments. We expect that, in the absence of real CS text adequate to train the payload model, large volumes of synthetic text will help.

Surprisingly, this does not happen for aLM-gCS, bLM-gCS, and rGAN-gCS. Adding these texts to the monolingual baseline makes payload perplexity generally worse and much worse in some cases, in particular, rGAN-gCS. VAE has better success. For the gCS$|$Mono curriculum, pVAE-gCS improves upon the baseline, but rVAE-gCS does worse. On further investigation we found that, pVAE generates $\sim$80% monolingual data, this contributes to the monolingual corpus which makes the training more coherent than mixing with code-switched data with low quality. For the Mono$|$gCS curriculum, both pVAE and rVAE perform worse than Mono.

In sharp contrast, VACS-gCS achieves the best (smallest) perplexity in both curricula, and much smaller than the Mono baseline. This shows that synthetic text from VACS can be used effectively to supplement parallel monolingual corpora. pVAE is the second best choice.

GAN-based synthetic text performs poorly. pGAN fails to generate any plausible code-switched text as it does not get any real code-switch samples from the parallel corpora. rGAN performance is also worse than other generative models. Though [28] avoided mode collapsing problems common in GANs, we observed that the problem prevailed for longer sentences ($>$10 words) when trying to train with small amounts of code-switched text. The problem persists because CS text is much more syntactically diverse than monolingual corpus, so training a GAN with a small number of real samples produces sub-optimal results.

The performance of aLM and bLM, while better than GANs, is far from VACS. These LMs are designed explicitly for code-switched languages and require language-tagged data. Hence the generative power of such models strongly depends on the size and quality of tagged training data available.

5.3 Sample synthetic sentences

Table 3 shows sentences generated by VACS. All sentences in a row block are sampled from the same context embedding $z_{c}$, and each row corresponds to a different $z_{l}$. Note that the generated sentences seem to be able to produce a similar context. Like row (a) corresponds to cricket and (b) to assembly. It learns to produce meaningful phrases most of the cases which seem reasonable syntactically; however, semantics and pragmatics are not realistic, like in monolingual synthesis.

6 Conclusion

We proposed VACS, a novel variational autoencoder to synthesize unlimited volumes of language-tagged code-switched text starting with modest real code-switched and abundant monolingual text. We showed that VACS generates text of various lengths and switching pattern. We also showed that synthetic code-switched text produced by VACS can help train a language model that then has low perplexity on real code-switched text. We further demonstrated that we can generate reasonable syntactically valid sentences. As VACS can generate plausible language-tagged code-switched sentences, these can be used for various downstream applications like language labeling, POS tagging, NER etc.

Acknowledgments

B. Samanta is funded by Google India Ph.D. fellowship and the “Learning Representations from Network Data” project sponsored by Intel. We would like to thank Dr. Dipanjan Das and Dr. Dan Garrette of Google Research, New York for their valuable inputs.