We propose a method for generating paraphrases of English questions that retain the original intent but use a different surface form. Our model combines a careful choice of training objective with a principled information bottleneck, to induce a latent encoding space that disentangles meaning and form. We train an encoder-decoder model to reconstruct a question from a paraphrase with the same meaning and an exemplar with the same surface form, leading to separated encoding spaces. We use a Vector-Quantized Variational Autoencoder to represent the surface form as a set of discrete latent variables, allowing us to use a classifier to select a different surface form at test time. Crucially, our method does not require access to an external source of target exemplars. Extensive experiments and a human evaluation show that we are able to generate paraphrases with a better tradeoff between semantic preservation and syntactic novelty compared to previous methods. A paraphrase of an utterance is an alternative surface form in the same language expressing the same semantic content as the original form (Mad-nani and Dorr, 2010). For questions, a paraphrase should have the same intent, and should lead to the same answer as the original, as in the examples in Table 1. Question paraphrases are of significant interest, with applications in data augmentation (Iyyer et al., 2018), query rewriting (Dong et al., 2017) and duplicate question detection (Shah et al., 2018), as they allow a system to better identify the underlying intent of a user query. Recent approaches to paraphrasing use information bottlenecks with VAEs (Bowman et al., 2016) or pivot languages (Wieting and Gimpel, 2018) to try to extract the semantics of an input utterance, before projecting back to a (hopefully different) surface form. However, these methods have lit-How is a dialect different from a language? tle to no control over the preservation of the input meaning or variation in the output surface form. Other work has specified the surface form to be generated (Iyyer et al., 2018; Chen et al., 2019a; Kumar et al., 2020), but has so far assumed that the set of valid surface forms is known a priori. In this paper, we propose SEPARATOR , a method for generating paraphrases that exhibit high variation in surface form while still retaining the original intent. Our key innovations are: (a) to train a model to reconstruct a target question from an input paraphrase with the same meaning, and an exemplar with the same surface form, and (b) to separately encode the form and meaning of questions as discrete and continuous latent variables respectively, enabling us to modify the output surface form while preserving the original question intent. Crucially, unlike prior work on syntax controlled paraphrasing, we show that we can generate diverse paraphrases of an input question at test time by inferring a different discrete syntactic encoding, without needing access to reference exemplars. We limit our work to English questions for three reasons: (a) the concept of a paraphrase is more Paraphrase Exemplar Encoder Decoder Target <latexit sha1_base64="okZ9kE0B/H/GUPAmQmIgeXGjogY=">AAAB+XicbVBNS8NAEN34WetX1KOXYBE8lUQUPRa9eKxgP6ANZbOdtEs3m7A7KdaQf+LFgyJe/Sfe/Ddu2xy09cHA470ZZuYFieAaXffbWlldW9/YLG2Vt3d29/btg8OmjlPFoMFiEat2QDUILqGBHAW0EwU0CgS0gtHt1G+NQWkeywecJOBHdCB5yBlFI/Vsu4vwiEGYPeW9TEOU9+yKW3VncJaJV5AKKVDv2V/dfszSCCQyQbXueG6CfkYVciYgL3dTDQllIzqAjqGSRqD9bHZ57pwape+EsTIl0ZmpvycyGmk9iQLTGVEc6kVvKv7ndVIMr/2MyyRFkGy+KEyFg7EzjcHpcwUMxcQQyhQ3tzpsSBVlaMIqmxC8xZeXSfO86l1W3fuLSu2miKNEjskJOSMeuSI1ckfqpEEYGZNn8krerMx6sd6tj3nrilXMHJE/sD5/AJYilEY=</latexit> z sem <latexit sha1_base64="hq5NcnPDoSAKxkWrI48luXZIFDY=">AAAB+XicbVBNS8NAEN34WetX1KOXxSJ4Kokoeix68VjBfkAbwma7aZduNmF3Uowh/8SLB0W8+k+8+W/ctjlo64OBx3szzMwLEsE1OM63tbK6tr6xWdmqbu/s7u3bB4dtHaeKshaNRay6AdFMcMlawEGwbqIYiQLBOsH4dup3JkxpHssHyBLmRWQoecgpASP5tt0H9ghBmD8Vfq4zWfh2zak7M+Bl4pakhko0ffurP4hpGjEJVBCte66TgJcTBZwKVlT7qWYJoWMyZD1DJYmY9vLZ5QU+NcoAh7EyJQHP1N8TOYm0zqLAdEYERnrRm4r/eb0Uwmsv5zJJgUk6XxSmAkOMpzHgAVeMgsgMIVRxcyumI6IIBRNW1YTgLr68TNrndfey7txf1Bo3ZRwVdIxO0Bly0RVqoDvURC1E0QQ9o1f0ZuXWi/VufcxbV6xy5gj9gfX5A7YflFs=</latexit> z syn How [heavy] ADVP is a [moose] NP ? clearly defined for questions compared to generic utterances, as question paraphrases should lead to the same answer; (b) the space of possible surface forms is smaller for questions, making the task more achievable, and (c) better dataset availability. However, our approach does not otherwise make any assumptions specific to questions. The task is to learn a mapping from an input question, represented as a sequence of tokens X , to paraphrase(s) Y which have different surface form to X , but convey the same intent . Our proposed approach, which we call SEPARATOR , uses an encoder-decoder model to transform an input question into a latent encoding space, and then back to an output paraphrase. We hypothesize that a principled information bottleneck (Section 2.1) and a careful choice of training scheme (Section 2.2) lead to an encoding space that separately represents the intent and surface form. This separation enables us to paraphrase the input question, varying the surface form of the output by directly manipulating the syntactic encoding of the input and keeping the semantic encoding constant (Section 2.3). We assume access to reference paraphrase clusters during training (e.g., Table 1), sets of questions with different surface forms that have been collated as having the same meaning or intent . Our model is a variant of the standard encoder-decoder framework (Cho et al., 2014), and consists of: (a) a vanilla Transformer sentence encoder (Vaswani et al., 2017), that maps an input question X to a multi-head sequence of encodings, e h,t = ENCODER ( X ) ; (b) a principled choice of information bottleneck, with a continuous variational path and a discrete vector-quantized path, that maps the encoding sequence to a pair of latent vectors, z sem , z syn = BOTTLENECK ( e h,t ) , represented in more detail in Figure 1; (c) a vanilla Transformer decoder, that attends over the latent vectors to generate a sequence of output tokens,  Y = DECODER ( z sem , z syn ) . The separation between z sem and z syn is induced by our proposed training scheme, shown in Figure 1 and described in detail in Section 2.2. While the encoder and decoder used by the model are standard Transformer modules, our bottleneck is more complex and we now describe it in more detail. Let the encoder output be { e h, 1 , . . . , e h, | X | } = ENCODER ( X ) , where e h,t  R D/H T , h  1 , ..., HT with HT the number of transformer heads, | X | the length of the input sequence and D the dimension of the transformer. We first pool this sequence of encodings to a single vector, using the multi-head pooling described in Liu and Lapata (2019). For each head h , we calculate a distribution over time indexes  h,t using attention:  h,t = exp a h,t (cid:80) t (cid:48) | X | exp a h,t (cid:48) , (1) a h,t = k Th e h,t , (2) with k h  R D/H a learned parameter. We then take a weighted average of a linear projection of the encodings, to give pooled output  e h ,  e h = (cid:88) t (cid:48) | X |  h,t (cid:48) V h e h,t (cid:48) , (3) with V h  R D/H  D/H a learned parameter. Transformer heads are assigned either to a semantic group H sem , that will be trained to encode the intent of the input,  e sem = [ . . . ;  e h ; . . . ] , h  H sem , or to a syntactic group H syn , that will be trained to represent the surface form  e syn = [ . . . ;  e h ; . . . ] , h  H syn (see Figure 1). The space of possible question intents is extremely large and may be reasonably approximated by a continuous vector space. However, the possible surface forms are discrete and smaller in number. We therefore use a Vector-Quantized Variational Autoencoder (VQ-VAE, van den Oord et al., 2017) for the syntactic encoding z syn , and model the semantic encoding z sem as a continuous Gaussian latent variable, as shown in the upper and lower parts of Figure 1, respectively. Vector Quantization Let q h be discrete latent variables corresponding to the syntactic quantizer heads, h  H syn . 1 Each variable can be one of K possible latent codes, q h  [0 , K ] . The heads use distinct codebooks, C h  RK  D/H , which map each discrete code to a continuous embedding C h ( q h )  R D/H . Given sentence X and its pooled encoding {  e 1 , ...,  e H } , we independently quantize the syntactic subset of the heads h  H syn to their nearest codes from C h and concatenate, giving the syntactic encoding z syn = [ C 1 ( q 1 ); . . . ; C | H syn | ( q | H syn | )] . The quantizer module is trained through backpropagation using straight-through estimation (Bengio et al., 2013), with an additional loss term to constrain the embedding space as described in van den Oord et al. (2017), where the stopgradient operator sg (  ) is defined as identity during forward computation and zero on backpropagation, and  is a weight that controls the strength of the constraint. We follow the soft 1 The number and dimensionality of the quantizer heads need not be the same as the number of transformer heads. EM and exponentially moving averages training approaches described in earlier work (Roy et al., 2018; Angelidis et al., 2021), which we find improve training stability. Variational Bottleneck For the semantic path, we introduce a learned Gaussian posterior, that represents the encodings as smooth distributions in space instead of point estimates (Kingma and Welling, 2014). Formally,  ( z h | e h )  N (  ( e h ) ,  ( e h )) , where  (  ) and  (  ) are learned linear transformations. To avoid vanishingly small variance and to encourage a smooth distribution, a prior is introduced, p ( z h )  N ( 0 , 1 ) . The VAE objective is the standard evidence lower bound (ELBO), given by ELBO =  KL [  ( z h | e h ) || p ( z h )] + E  [log p ( e h | z h )] . We use the usual Gaussian reparameterisation trick, and approximate the expectation in Equation (6) by sampling from the training set and updating via backpropagation (Kingma and Welling, 2014). The VAE component therefore only adds an additional KL term to the overall loss, LKL =  KL [  ( z h | e h ) || p ( z h )] . In sum, BOTTLENECK ( e h,t ) maps a sequence of token encodings to a pair of vectors z sem , z syn , with z sem a continuous latent Gaussian, and z syn a combination of discrete code embeddings. We now describe the training scheme that causes the model to learn separate encodings for meaning and form: z sem should encode only the intent of the input, while z syn should capture any information about the surface form of the input. Although we refer to z syn as the syntactic encoding , it will not necessarily correspond to any specific syntactic formalism. We also acknowledge that meaning and form are not completely independent of each other; arbitrarily changing the form of an utterance is likely to change its meaning. However, it is possible for the same intent to have multiple phrasings , and it is this local independence' that we intend to capture. We create triples { X sem , X syn , Y } , where X sem has the same meaning but different form to Y (i.e., it is a paraphrase, as in Table 1) and X syn is a question with the same form but different meaning Input How heavy is a moose? (i.e., it shares the same syntactic template as Y ), which we refer to as an exemplar . We describe the method for retrieving these exemplars in Section 2.3. The model is then trained to generate a target paraphrase Y from the semantic encoding z sem of the input paraphrase X sem , and from the syntactic encoding z syn of the exemplar X syn , as demonstrated in Figure 1. Recalling the additional losses from the variational and quantized bottlenecks, the final combined training objective is given by L = LY + L cstr + LKL , (8) where LY ( X sem , X syn ) is the cross-entropy loss of teacher-forcing the decoder to generate Y from z sem ( X sem ) and z syn ( X syn ) . It is important to note that not all surface forms are valid or licensed for all question intents. As shown in Figure 1, our approach requires exemplars during training to induce the separation between latent spaces. We also need to specify the desired surface form at test time , either by supplying an exemplar as input or by directly predicting the latent codes. The output should have a different surface form to the input but remain fluent. Exemplar Construction During training, we retrieve exemplars X syn from the training data following a process which first identifies the underlying syntax of Y , and finds a question with the same syntactic structure but a different, arbitrary meaning. We use a shallow approximation of syntax, to ensure the availability of equivalent exemplars in the training data. An example of the exemplar retrieval process is shown in Table 2; we first apply a chunker (FlairNLP, Akbik et al., 2018) to Y , then extract the chunk label for each tagged span, ignoring stopwords. This gives us the template that Y follows. We then select a question at random from the training data with the same template to give X syn . If no other questions in the dataset use this template, we create an exemplar by replacing each chunk with a random sample of the same type. We experimented with a range of approaches to determining question templates, including using part-of-speech tags and (truncated) constituency parses. We found that using chunks and preserving stopwords gave a reasonable level of granularity while still combining questions with a similar form. The templates (and corresponding exemplars) need to be granular enough that the model is forced to use them, but abstract enough that the task is not impossible to learn. Prediction at Test Time In general, we do not assume access to reference exemplars at test time and yet the decoder must generate a paraphrase from semantic and syntactic encodings. Since our latent codes are separated, we can directly predict the syntactic encoding, without needing to retrieve or generate an exemplar. Furthermore, by using a discrete representation for the syntactic space, we reduce this prediction problem to a simple classi-fication task. Formally, for an input question X , we learn a distribution over licensed discrete codes q h , h   H syn . We assume that the heads are independent, so that p ( q 1 , . . . , q  H syn ) = (cid:81) i p ( q i ) . We use a small fully connected network with the semantic and syntactic encodings of X as inputs, giving p ( q h | X ) = MLP ( z sem ( X ) , z syn ( X )) . The network is trained to maximize the likelihood of all other syntactic codes licensed by each input. We calculate the discrete syntactic codes for each question in a paraphrase cluster, and minimize the cross-entropy loss of the network with respect to these codes. At test time, we set q h = argmax q (cid:48) h [ p ( q (cid:48) h | X test )] . Datasets We evaluate our approach on two datasets: Paralex (Fader et al., 2013), a dataset of question paraphrase clusters scraped from WikiAn-swers; and Quora Question Pairs (QQP) 2 sourced from the community question answering forum Quora. We observed that a significant fraction of the questions in Paralex included typos or were ungrammatical. We therefore filter out any questions marked as non-English by a language detection 2 https://www.kaggle.com/c/quora-question-pairs script (Lui and Baldwin, 2012), then pass the questions through a simple spellchecker. While this destructively edited some named entities in the questions, it did so in a consistent way across the whole dataset. There is no canonical split for Paralex, so we group the questions into clusters of paraphrases, and split these clusters into train/dev/test partitions with weighting 80/10/10. Similarly, QQP does not have a public test set. We therefore partitioned the clusters in the validation set randomly in two, to give us our dev/test splits. Summary statistics of the resulting datasets are given in Appendix B. All scores reported are on our test split. Model Configuration Following previous work (Kaiser et al., 2018; Angelidis et al., 2021), our quantizer uses multiple heads ( H = 4 ) with distinct codebooks to represent the syntactic encoding as 4 discrete categorical variables q h , with z syn given by the concatenation of their codebook embeddings C h ( q h ) . We use a relatively small codebook size of K = 256 , relying on the combinatoric power of the multiple heads to maintain the expressivity of the model. We argue that, assuming each head learns to capture a particular property of a template (see Section 4.3), the number of variations in each property is small, and it is only through combination that the space of possible templates becomes large. We include a detailed list of hyperparameters in Appendix A. Our code is available at http:// github.com/tomhosking/separator . Comparison Systems We compare SEPARATOR against several related systems. These include a model which reconstructs Y only from X sem , with no signal for the desired form of the output. In other words, we derive both z sem and z syn from X sem , and no separation between meaning and form is learned. This model uses a continuous Gaussian latent variable for both z syn and z sem , but is otherwise equivalent in architecture to SEPARATOR . We refer to this as the VAE baseline. We also experiment with a vanilla autoencoder or AE baseline by removing the variational component, such that z sem , z syn =  e sem ,  e syn . We include our own implementation of the VQ-VAE model described in Roy and Grangier (2019). They use a quantized bottleneck for both z sem and z syn , with a large codebook K = 64 , 000 , H = 8 heads and a residual connection within the quantizer. For QQP, containing only 55,611 train-Cluster type Encoding Paraphrase Template z sem 0.943 0.096 z syn 0.952 0.092 z 0.960 0.096 ing clusters, the configuration in Roy and Grangier (2019) leaves the model overparameterized and training did not converge; we instead report results for K = 1 , 000 . ParaNMT (Wieting and Gimpel, 2018) translates input sentences into a pivot language (Czech), then back into English. Although this system was trained on high volumes of data (including Common Crawl), the training data contains relatively few questions, and we would not expect it to perform well in the domain under consideration. Di-verse Paraphraser using Submodularity' (DiPS; Kumar et al. 2019) uses submodular optimisation to increase the diversity of samples from a standard encode-decoder model. Latent bag-of-words (BoW; Fu et al. 2019) uses an encoder-decoder model with a discrete bag-of-words as the latent encoding. SOW/REAP (Goyal and Durrett, 2020) uses a two stage approach, deriving a set of feasible syntactic rearrangements that is used to guide a second encoder-decoder model. We additionally implement a simple tf-idf baseline (Jones, 1972), retrieving the question from the training set with the highest similarity to the input. Finally, we include a basic copy baseline as a lower bound, that simply uses the input question as the output. Our experiments were designed to answer three questions: (a) Does SEPARATOR effectively factorize meaning and form? (b) Does SEPARATOR Paralex QQP Model BLEU  Self-BLEU  iBLEU  BLEU  Self-BLEU  iBLEU  Copy 37.10 100.00  4.03 32.61 100.00  7.17 VAE 40.26 66.12 8.35 19.36 35.29 2.96 AE 40.10 75.71 5.36 19.90 39.81 1.99 tf-idf 25.08 25.25 9.98 22.73 61.81  2.63 VQ-VAE 40.26 65.71 8.47 16.19 26.15 3.43 ParaNMT 20.42 39.90 2.32 24.24 56.42 0.04 DiPS 24.90 29.58 8.56 18.47 32.45 3.19 SOW/REAP 33.09 37.07 12.04 12.64 24.19 1.59 LBoW 34.96 35.86 13.71 16.17 29.00 2.62 SEPARATOR 36.36 35.37 14.84 14.70 14.84 5.84 ORACLE 53.37 24.55 29.99 24.50 16.04 12.34 Table 4: Generation results, without access to oracle exemplars. manage to generate diverse paraphrases (while preserving the intent of the input)? (c) What does the underlying quantized space encode (i.e., can we identify any meaningful syntactic properties)? We address each of these questions in the following sections. Inspired by Chen et al. (2019b) we use a semantic textual similarity task and a template detection task to confirm that SEPARATOR does indeed lead to encodings { z sem , z syn } in latent spaces that represent different types of information. Using the test set, we construct clusters of questions that share the same meaning C sem , and clusters that share the same template C syn . For each cluster C q  {C sem , C syn } , we extract one question at random X q  C q , compute its encodings { z sem , z syn , z } 3 , and its cosine similarity to the encodings of all other questions in the test set. We take the question with maximum similarity to the query X r , r = argmax r (cid:48) ( z q . z r (cid:48) ) , and compare the cluster that it belongs to, C r , to the query cluster I ( C q = C r ) , giving a retrieval accuracy score for each encoding type and each clustering type. For the VAE, we set { z sem , z syn } to be the same heads of z as the separated model. Table 3 shows that our approach yields encodings that successfully factorise meaning and form, with negligible performance loss compared to the VAE baseline; paraphrase retrieval performance using z sem for the separated model is comparable to using z for the VAE. 3 z refers to the combined encoding, i.e., [ z sem ; z syn ] . Automatic Evaluation While we have shown that our approach leads to disentangled representations, we are ultimately interested in generating diverse paraphrases for unseen data . That is, given some input question, we want to generate an output question with the same meaning but different form. We use iBLEU (Sun and Zhou, 2012) as our primary metric, a variant of BLEU (Papineni et al., 2002; Post, 2018) that is penalized by the similarity between the output and the input , iBLEU =  BLEU ( output, references )  (1   ) BLEU ( output, input ) , (9) where  = 0 . 7 is a constant that weights the tradeoff between fidelity to the references and variation from the input. We also report the usual BLEU ( output, references ) as well as Self-BLEU ( output, input ) . The latter allows us to examine whether the models are making trivial changes to the input. The Paralex test set contains 5.6 references on average per cluster, while QQP contains only 1.3. This leads to lower BLEU scores for QQP in general, since the models are evaluated on whether they generated the specific paraphrase(s) present in the dataset. Table 4 shows that the Copy, VAE and AE models display relatively high BLEU scores, but achieve this by parroting' the input; they are good at reconstructing the input, but introduce little variation in surface form, reflected in the high Self-BLEU scores. This highlights the importance of considering similarity to both the references and to the input. The tf-idf baseline performs surprisingly Input What is the most known singer? well on Paralex; the large dataset size makes it more likely that a paraphrase cluster with a similar meaning to the query exists in the training set. The other comparison systems (in the second block in Table 4) achieve lower Self-BLEU scores, indicating a higher degree of variation introduced, but this comes at the cost of much lower scores with respect to the references. SEPARATOR achieves the highest iBLEU scores, indicating the best balance between fidelity to the references and novelty compared to the input. We give some example output in Table 5; while the other systems mostly introduce lexical variation, SEPARATOR is able to produce output with markedly different syntactic structure to the input, and can even change the question type while successfully preserving the original intent. The last row in Table 4 (ORACLE ) reports results when our model is given a valid exemplar to use directly for generation, thus bypassing the code prediction problem. For each paraphrase cluster, we select one question at random to use as input, and select another to use as the target. We retrieve a question from the training set with the same template as the target to use as an oracle exemplar . This represents an upper bound on our model's performance. While SEPARATOR outperforms existing methods, our approach to predicting syntactic codes (using a shallow fully-connected network) is relatively simple. SEPARATOR using oracle exemplars achieves by far the highest scores in Table 4, demonstrating the potential expressivity of our approach when exemplars are guaranteed to be valid. A more powerful code prediction model could close the gap to this upper bound, as well as enabling the generation of multiple diverse paraphrases for a single input question. However, we leave this to future work. Human Evaluation In addition to automatic evaluation we elicited judgements from crowd-workers on Amazon Mechanical Turk. Specifically, they were shown a question and two paraphrases thereof (corresponding to different systems) and asked to select which one was preferred along three dimensions: the dissimilarity of the paraphrase compared to the original question, how well the paraphrase reflected the meaning of the original, and the fluency of the paraphrase (see Appendix C). We evaluated a total of 200 questions sampled equally from both Paralex and QQP, and collected 3 ratings for each sample. We assigned each system a score of +1 when it was selected,  1 when the other system was selected, and took the mean over all samples. Negative scores indicate that a system was selected less often than an alternative. We chose the four best performing models according to Table 4 for our evaluation: SEPARATOR , DiPS (Kumar et al., 2019), Latent BoW (Fu et al., 2019) and VAE. Figure 2 shows that although the VAE baseline is the best at preserving question meaning, it is also the worst at introducing variation to the output. SEPARATOR introduces more variation than the other systems evaluated and better preserves the original question intent, as well as generating significantly more fluent output (using a one-way ANOVA with post-hoc Tukey HSD test, p < 0.05). When predicting latent codes at test time, we assume that the code for each head may be predicted independently of the others, as working with the full joint distribution would be intractable. We now examine this assumption as well as whether different encodings represent distinct syntactic proper-Meaning Dissimilarity Fluency 60 40 20 0 20 40 60 R e l a t i v e p r e f e r e n c e % +58 -6 -12 -39 -56 +7 +2 +47 +38 +3 -20 -21 VAE Separator (ours) Latent BoW DiPS Figure 2: Results of our human evaluation. ties. Following Angelidis et al. (2021), we compute the probability of a question property f 1 , f 2 , . . . taking a particular value a , conditioned by head h and quantized code k h as P ( f i | h, k h ) = (cid:80) x X I ( q h ( x ) = k h ) I ( f i ( x ) = a ) (cid:80) x X I ( q h ( x ) = k h ) , (10) where I (  ) is the indicator function, and examples of values a are shown in Figure 3. We then calculate the mean entropy of these distributions, to determine how property-specific each head is: H h = 1 K (cid:88) k h (cid:88) a P ( a | h, k h ) log P ( a | h, k h ) . (11) Heads with lower entropies are more predictive of a property, indicating specialisation and therefore independence. Figure 3 shows our analysis for four syntactic properties: head #2 has learned to control the high level output structure, including the question type or whword , and whether the question word appears at the beginning or end of the question. Head #3 controls which type of prepositional phrase is used. The length of the output is not determined by any one head, implying that it results from other properties of the surface form. Future work could leverage this disentanglement to improve the exemplar prediction model, and could lead to more fine-grained control over the generated output form. In summary, we find that SEPARATOR successfully learns separate encodings for meaning and form. SEPARATOR is able to generate question 1 2 3 4 Head # Whword Fronting Length Preposition Q u e s t i o n p r o p e r t y Property entropy by quantizer head 0.4 0.6 0.8 1.0 1.2 1.4 Figure 3: Predictive entropy by head for various question properties lower entropy indicates higher predictive power. paraphrases with a better balance of diversity and intent preservation compared to prior work. Although we are able to identify some high-level properties encoded by each of the syntactic latent variables, further work is needed to learn interpretable syntactic encodings. Paraphrasing Prior work on generating paraphrases has looked at extracting sentences with similar meaning from large corpora (Barzilay and McKeown, 2001; Bannard and Callison-Burch, 2005; Ganitkevitch et al., 2013), or identifying paraphrases from sources that are weakly aligned (Dolan et al., 2004; Coster and Kauchak, 2011). More recently, neural approaches to paraphrasing have shown promise. Several models have used an information bottleneck to try to encode the semantics of the input, including VAEs (Bowman et al., 2016), VQ-VAEs (van den Oord et al., 2017; Roy and Grangier, 2019), and a latent bag-of-words model (Fu et al., 2019). Other work has relied on the strength of neural machine translation models, translating an input into a pivot language and then back into English (Mallinson et al., 2017; Wieting and Gimpel, 2018; Hu et al., 2019). Kumar et al. (2019) use submodular function maximisation to improve the diversity of paraphrases generated by an encoder-decoder model. Dong et al. (2017) use an automatic paraphrasing system to rewrite inputs to a question answering system at inference time, reducing the sensitivity of the system to the specific phrasing of a query. Syntactic Templates The idea of generating paraphrases by controlling the structure of the output has seen recent interest, but most work so far has assumed access to a template oracle. Iyyer et al. (2018) use linearized parse trees as a template, then sample paraphrases by using multiple templates and reranking the output. Chen et al. (2019a) use a multi task objective to train a model to generate output that follows an input template. Their approach is limited by their use of automatically generated paraphrases for training, and their reliance on the availability of oracle templates. Bao et al. (2019) use a discriminator to separate spaces, but rely on noising the latent space to induce variation in the output form. Their results show good fidelity to the references, but low variation compared to the input. Goyal and Durrett (2020) use the artif-ically generated dataset ParaNMT-50m (Wieting and Gimpel, 2018) for their training and evaluation, which displays low output variation according to our results. Kumar et al. (2020) show strong performance using full parse trees as templates, but focus on generating output with the correct parse and do not consider the problem of template prediction. Huang and Chang (2021) independently and concurrently propose training a model with a similar split training' approach to ours, but using constituency parses instead of exemplars, and a bag-of-words' instead of reference paraphrases. Their approach has the advantage of not requiring paraphrase clusters during training, but they do not attempt to solve the problem of template prediction and rely on the availability of oracle target templates. Russin et al. (2020) modify the architecture of an encoder-decoder model, introducing an inductive bias to encode the structure of inputs separately from the lexical items to improve compositional generalisation on an artificial semantic parsing task. Chen et al. (2019b) use a multi-task setup to generate separated encodings, but do not experiment with generation tasks. Shu et al. (2019) learn discrete latent codes to introduce variation to the output of a machine translation system. We present SEPARATOR , a method for generating paraphrases that balances high variation in surface form with strong intent preservation. Our approach consists of: (a) a training scheme that causes an encoder-decoder model to learn separated latent encodings, (b) a vector-quantized bottleneck that results in discrete variables for the syntactic encoding, and (c) a simple model to predict different yet valid surface forms for the output. Extensive experiments and a human evaluation show that our approach leads to separated encoding spaces with negligible loss of expressivity, and is able to generate paraphrases with a better balance of variation and semantic fidelity than prior methods. In future, we would like to investigate the properties of the syntactic encoding space, and improve on the code prediction model. It would also be interesting to reduce the levels of supervision required to train the model, and induce the separation without an external syntactic model or reference paraphrases. We thank our anonymous reviewers for their feedback. We are grateful to Stefanos Angelidis for many valuable discussions, and Hao Tang for their comments on the paper. This work was supported in part by the UKRI Centre for Doctoral Training in Natural Language Processing, funded by the UKRI (grant EP/S022481/1) and the University of Edinburgh. Lapata acknowledges the support of the European Research Council (award number 681760, Translating Multiple Modalities into Text).
objective objective method method abstain result abstain abstain abstain abstain abstain abstain abstain objective abstain abstain method result method abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain method abstain abstain method method other abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain method abstain abstain method abstain abstain abstain method abstain method abstain abstain abstain abstain method abstain abstain method abstain method abstain method method abstain abstain method method method abstain method method abstain abstain abstain method method other abstain method abstain method method method method method other method abstain method abstain method method method abstain abstain method abstain method abstain abstain abstain method method abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain result abstain abstain abstain result abstain abstain abstain result abstain abstain abstain other other other other other other other other other other other other abstain other other other other other other method abstain abstain abstain abstain result objective abstain other other other other