Copy mechanism and tailored training for character-based data-to-text generation

TL;DR

This paper introduces a character-based sequence-to-sequence model with attention and copying mechanisms for data-to-text generation, eliminating the need for delexicalization and enabling transfer learning.

Contribution

It presents an end-to-end character-level model with a novel training pipeline and a copy mechanism, improving text generation quality and generality over existing word-based methods.

Findings

Competitive performance on standard metrics

Effective copying of input facts in generated text

Eliminates need for delexicalization and tokenization

Abstract

In the last few years, many different methods have been focusing on using deep recurrent neural networks for natural language generation. The most widely used sequence-to-sequence neural methods are word-based: as such, they need a pre-processing step called delexicalization (conversely, relexicalization) to deal with uncommon or unknown words. These forms of processing, however, give rise to models that depend on the vocabulary used and are not completely neural. In this work, we present an end-to-end sequence-to-sequence model with attention mechanism which reads and generates at a character level, no longer requiring delexicalization, tokenization, nor even lowercasing. Moreover, since characters constitute the common "building blocks" of every text, it also allows a more general approach to text generation, enabling the possibility to exploit transfer learning for training. These skills are obtained thanks to two major features: (i) the possibility to alternate between the standard generation mechanism and a copy one, which allows to directly copy input facts to produce outputs, and (ii) the use of an original training pipeline that further improves the quality of the generated texts. We also introduce a new dataset called E2E+, designed to highlight the copying capabilities of character-based models, that is a modified version of the well-known E2E dataset used in the E2E Challenge. We tested our model according to five broadly accepted metrics (including the widely used BLEU), showing that it yields competitive performance with respect to both character-based and word-based approaches.

Figures

Tables

Table 1. Table 1: Descriptive statistics: on the left, sizes of training, validation and test sets are shown. On the right, the average number of characters, respectively for Meaning Representations and natural language sentences, are presented

Dataset	Number of instances				Avg. number of characters
	training	validation	test		MRs	NL sentences
E2E	42061	4672	4693		112.11	115.07
E2E+	42061	4672	4693		112.91	115.65
Hotel	2210	275	275		52.74	61.31
Restaurant	2874	358	358		53.89	63.22

Table 2. Table 2: The ablation study on the E2E dataset evidences the final performance improvement reached by our model. Best values for each metric are highlighted (the higher the better)

EDA	bleu	0.4999
	nist	7.1146
	meteor	0.3369
	rouge_l	0.5634
	cider	1.3176
EDA_C	bleu	0.6255
	nist	7.7934
	meteor	0.4401
	rouge_l	0.6582
	cider	1.7286

Table 3. (a)

EDA	bleu	0.4999
	nist	7.1146
	meteor	0.3369
	rouge_l	0.5634
	cider	1.3176
EDA_C	bleu	0.6255
	nist	7.7934
	meteor	0.4401
	rouge_l	0.6582
	cider	1.7286

Table 4. (b)

EDA_S	bleu	0.6538
	nist	8.4601
	meteor	0.4337
	rouge_l	0.6646
	cider	1.9944
EDA_CS	bleu	0.6705
	nist	8.5150
	meteor	0.4449
	rouge_l	0.6894
	cider	2.2355

Table 5. Table 3: Performance comparison. Note the absence of transfer learning on dataset E2E+ because in this case the training and fine-tuning datasets are the same. Best values for each metric are highlighted (the higher the better)

		E2E+	E2E	Hotel	Restaurant
EDA	bleu	0.3773	0.4999	0.4316	0.3599
	nist	5.7835	7.1146	5.9708	5.5104
	meteor	0.2672	0.3369	0.3552	0.3367
	rouge_l	0.4638	0.5634	0.6609	0.5892
	cider	0.2689	1.3176	3.9213	3.3792
TGen	bleu	0.6292	0.6593	0.5059	0.4074
	nist	9.4070	8.6094	7.0913	6.4304
	meteor	0.4367	0.4483	0.4246	0.3760
	rouge_l	0.6724	0.6850	0.7277	0.6395
	cider	2.8004	2.2338	5.0404	4.1650
EDA_CS	bleu	0.6197	0.6705	0.5515	0.4925
	nist	9.2103	8.5150	7.4447	6.9813
	meteor	0.4428	0.4449	0.4379	0.4191
	rouge_l	0.6610	0.6894	0.7499	0.7002
	cider	2.8118	2.2355	5.1376	4.7821
EDA_CSTL	bleu	-	0.6580	0.5769	0.5099
	nist	-	8.5615	7.4286	7.3359
	meteor	-	0.4516	0.4439	0.4340
	rouge_l	-	0.6740	0.7616	0.7131
	cider	-	2.1803	5.3456	4.9915

Equations

$$e_{ij}=att(s_{i-1},h_j),1\le j\le T_x,1\le i\le T_y$$

$${\alpha }_{ij}=\frac{\exp (e_{ij})}{{\sum }_{k=1}^{T_x}\exp (e_{ik})}\equiv [softmax(e_i){]}_j,1\le j\le T_x,1\le i\le T_y$$

$$C_i=\sum _{j=1}^{T_x}{\alpha }_{ij}{h}_j,1\le i\le T_y,$$

$$P(y_i|y_1,\dots ,y_{i-1},\text{x})=g(y_{i-1},s_i,C_i),$$

$$P_{alph}^i=softmax(V[s_i;C_i]+b),$$

$$P_{att}^{ij}\equiv {\alpha }_{ij}$$

$$\begin{gathered} P^i(c)=p_{gen}^i\cdot P_{alph}^i[c] \\ +(1-p_{gen}^i)\sum _{j\mid x_i=c}{P}_{att}^{ij}(c), \end{gathered}$$

$$\begin{gathered} p_{gen}^i=\sigma (W_y\cdot {\tilde{y}}_{i-1}+W_s\cdot s_i \\ +W_p\cdot p_{gen}^{i-1}+W_c\cdot C_i) \end{gathered}$$

$$\begin{gathered} P^i(c)=p_{gen}^i\cdot P_{alph}^i(c) \\ +(1-p_{gen}^i)\sum _{j\mid x_i=c}{P}_{att}^{i,j-1}(c) \end{gathered}$$

Full text

In this work, we present an end-to-end sequence-to-sequence model with attention mechanism which reads and generates at a character level, no longer requiring delexicalization, tokenization, nor even lowercasing. Moreover, since characters constitute the common “building blocks" of every text, it also allows a more general approach to text generation, enabling the possibility to exploit transfer learning for training. These skills are obtained thanks to two major features:

(i) the possibility to alternate between the standard generation mechanism and a copy one, which allows to directly copy input facts to produce outputs, and

(ii) the use of an original training pipeline that further improves the quality of the generated texts.

We also introduce a new dataset called E2E+, designed to highlight the copying capabilities of character-based models, that is a modified version of the well-known E2E dataset used in the E2E Challenge. We tested our model according to five broadly accepted metrics (including the widely used bleu), showing that it yields competitive performance with respect to both character-based and word-based approaches.

1 Introduction

The ability of recurrent neural networks (RNNs) to model sequential data stimulated interest towards deep learning models which face data-to-text generation. An interesting application is the generation of descriptions for factual tables that consist of a set of field-value pairs; an example is shown in Table 3.3. We present in this paper an effective end-to-end approach to this task.

Sequence-to-sequence frameworks [Cho:14, Sutskever:14, Aharoni:16] have proved to be very effective in natural language generation (NLG) tasks [Karpathy:14, Wen:15a, Mei:16], as well as in machine translation [Cho:14, Sutskever:14, Bahdanau:14, Sennrich:16] and in language modeling [Al-Rfou:18]. Usually, data are represented word-by-word both in input and output sequences; anyways, such schemes can’t be effective without a special, non-neural delexicalization phase that handles unknown words, such as proper names or foreign words (see  [Wen:15a]). The delexicalization step has the benefit of reducing the dictionary size and, consequently, the data sparsity, but it is affected by various shortcomings. In particular, according to [Goyal:16] - it needs some reliable mechanism for entity identification, i.e. the recognition of named entities inside text; - it requires a subsequent “re-lexicalization” phase, where the original named entities take back placeholders’ place; - it cannot account for lexical or morphological variations due to the specific entity, such as gender and number agreements, that can’t be achieved without a clear context awareness.

Recently, some strategies have been proposed to solve these issues: [Gu:16] and [See:17] face this problem using a special neural copying mechanism that is quite effective in alleviating the out-of-vocabulary words problem, while [Luong:15] tries to extend neural networks with a post-processing phase that copies words as indicated by the model’s output sequence. Some character-level aspects appear as a solution of the issue as well, either as a fallback for rare words [Luong:16], or as subword units [Sennrich:16].

A significantly different approach consists in employing characters instead of words, for input slot-value pairs tokenization as well as for the generation of the final utterances, as done for instance in [Agarwal:17, Al-Rfou:18].

In order to give an original contribution to the field, in this paper we present a character-level sequence-to-sequence model with attention mechanism that results in a completely neural end-to-end architecture. In contrast to traditional word-based ones, it does not require delexicalization, tokenization nor lowercasing; besides, according to our experiments it never hallucinates words, nor duplicates them. As we will see, such an approach achieves rather interesting performance results and produces a vocabulary-free model that is inherently more general, as it does not depend on a specific domain’s set of terms, but rather on a general alphabet. Because of this, it opens up the possibility, not viable when using words, to adapt already trained networks to deal with different datasets.

More specifically, our model shows two important features, with respect to the state-of-art architecture proposed by [Bahdanau:14]:

(i) a character-wise copy mechanism, consisting in a soft switch between generation and copy mode, that disengages the model to learn rare and unhelpful self-correspondences, and

(ii) a peculiar training procedure, which improves the internal representation capabilities, enhancing recall; it consists in the exchange of encoder and decoder RNNs, (GRUs [Cho:14] in our specific case), depending on whether the input is a tabular Meaning Representation (MR) or a natural language sentence.

As a further original contribution, we also introduce a new dataset, described in section 3.1, whose particular structure allows to better highlight improvements in copying/recalling abilities with respect to character-based state-of-art approaches.

In section 2, after resuming the main ideas on encoder-decoder methods with attention, we detail our model: section 2.2 is devoted to explaining the copy mechanism while in section 2.3 our peculiar training procedure is presented. Section 3 includes the datasets descriptions, some implementation specifications, the experimental framework and the analysis and evaluation of the achieved results. Finally, in section LABEL:sec:conclusion some conclusions are drawn, outlining future work.

2 Model Description

2.1 Summary on Encoder-decoder Architectures with Attention

The sequence-to-sequence encoder-decoder architecture with attention [Bahdanau:14] is represented in figure 1: on the left, the encoder, a bi-directional RNN, outputs one annotation $h_{j}$ for each input token $x_{j}$. Each vector $h_{j}$ corresponds to the concatenation of the hidden states produced by the backward and forward RNNs. On the right side of the figure, we find the decoder, which produces one state $s_{i}$ for each time step; on the center of the figure the attention mechanism is shown. The main components of the attention mechanism are:

(i) the alignment model $e_{ij}$

[TABLE]

which is parameterized as a feedforward neural network and scores how well input in position $j$-th and output observed in the $i$-th time instant match; $T_{x}$ and $T_{y}$ are the length of the input and output sequences, respectively.

(ii) the attention probability distribution $\alpha_{ij}$

[TABLE]

($e_{i}$ is the vector whose $j$-th element is $e_{ij}$)

(iii) the context vector $C_{i}$

[TABLE]

weighted sum of the encoder annotations $h_{j}$.

According to [Bahdanau:14], the context vector $C_{i}$ is the key element for evaluating the conditional probability $P(y_{i}|y_{1},\dots,y_{i-1},\textbf{x})$ to output a target token $y_{i}$, given the previously outputted tokens $y_{1},\dots,y_{i-1}$ and the input x. They in fact express this probability as:

[TABLE]

where $g$ is a non-linear, potentially multi-layered, function. So doing, the explicit information about $y_{1},\dots,y_{i-1}$ and x is replaced with the knowledge of the context $C_{i}$ and the decoder state $s_{i}$.

The model we present in this paper incorporates two additional mechanisms, detailed in the next sections: a character-wise copy mechanism and a peculiar training procedure based on GRUs switch.

2.2 Learning to Copy

On top of the just recalled model, we build a character-based copy mechanism inspired by the Pointer-Generator Network [See:17], a word-based model that hybridizes the Bahdanau traditional model and a Pointer Network [Vinyals:15]. Basing on these ideas, in our model we identify two probability distributions that, differently from what done by [See:17] and [Wiseman:17], act now on characters rather than on words: the alphabet distribution $P_{alph}$ and the attention distribution $P_{att}$.

The former is the network’s generative probability of sampling a given character at time $i$, recalled in eq. (4):

[TABLE]

where $V$ and $b$ are trainable parameters.

The latter is the distribution reminded in eq. (2), created by the attention mechanism over the input tokens, i.e. in our case, over input characters:

[TABLE]

In our method this distribution is used for directly copying characters from the input to the output, pointing their input positions, while in [Bahdanau:14] $P_{att}$ is used only internally to weigh the input annotations and create the context vector $C_{i}$.

The final probability of outputting a specific character $c$ is obtained combining $P_{alph}$ and $P_{att}$ through the quantity $p_{gen}$, defined later, which acts as a soft switch between generating $c$ or copying it:

[TABLE]

where $P^{i}_{alph}[c]$ is the component of $P^{i}_{alph}$ corresponding to that character $c$.

The backpropagation training algorithm, therefore, brings $p_{gen}$ close to 1 when it is necessary to generate the output as in a standard encoder-decoder with attention ($P^{i}(c)\simeq P^{i}_{alph}[c])$; conversely, $p_{gen}$ will be close to 0 (i.e. $P^{i}(c)\simeq\sum_{j\mid x_{i}=c}P_{att}^{j}(c)$) when a copying step is needed.

The model we propose therefore learns when to sample from $P_{alph}$ for selecting the character to be generated, and when to sample from $P_{att}$ for selecting the character that has to be copied directly from the input.

This copy mechanism is fundamental to output all the unknown words present in the input, i.e. words which never occur in the training set. In fact, generating characters in the right order to reproduce unknown words is a sub-task not “solvable” by a naive sequence-to-sequence model, which learns to output only known words.

The generation probability $p_{gen}\in[0,1]$ is computed as follows:

[TABLE]

where $\sigma$ is the sigmoid function, $\tilde{y}_{i-1}$ is the last output character’s embedding, $s_{i}$ is the current decoder’s cell state and $C_{i}$ is the current context vector. $W_{y}$, $W_{s}$, $W_{c}$ and $W_{p}$ are the parameters whose training allows $p_{gen}$ to have the convenient value.

We highlight that in our formulation $p_{gen}^{i-1}$, i.e. the value of $p_{gen}$ at time $i-1$, contributes to the determination of $p_{gen}^{i}$. In fact, in a character-based model it is desirable that this probability remains unchanged for a fair number of time steps, and knowing its last value helps this behavior. This never happens in word-based models (such as [See:17]), in which copying for a single time step is usually enough.

2.3 Switching GRUs

Aiming at improving performance, we enrich our model’ training pipeline with an additional phase, which forces an appropriate language representation inside the recurrent components of the model. In order to achieve this goal, the encoder and the decoder do not own a fixed GRU, differently from what happens in classical end-to-end approaches. The recurrent module is passed each time as a parameter, depending on which one of the two training phases is actually performed.

In the first phase, similar to the usual one, the GRU assigned to the encoder deals with a tabular representation $x$ as input, the GRU assigned to the decoder has to cope with natural language, and the model generates an output utterance $\tilde{y}=F(x)$. Conversely, in the second phase GRUs are switched and we use as input the just obtained natural language utterance $\tilde{y}$ to generate a new table $\tilde{x}=G(\tilde{y})=G(F(x))$. Therefore, the same model can build both $F$ and $G$, thanks to the switch of GRUs.

In other words, the learning iteration is performed as follows.

• •

A dataset example $(x,y)$ is given. $x$ is a tabular meaning representation and $y$ is the corresponding reference sentence.

• •

We generate an output utterance $\tilde{y}=F(x)$

• •

We perform an optimization step on the model’s parameters, aiming at minimizing $L_{forward}=loss(\tilde{y},y)$

• •

We reconstruct the meaning representation $\tilde{x}$ back from the previously generated output: $\tilde{x}=G(\tilde{y})=G(F(x))$

• •

We perform a further optimization step on the model’s parameters, this time aiming at minimizing $L_{backward}=loss(\tilde{x},x)$

The higher training time, direct consequence of the just described technique, is a convenient investment, as it brings an appreciable improvement of the model’s performance (see section 3.3).

3 Experiments

3.1 Datasets

We tested our model on four datasets, whose main descriptive statistics are given in table 1: among them, the most known and frequently used in literature is the E2E dataset [Novikova:17], used as benchmark for the E2E Challenge organized by the Heriot-Watt University in 2017. It is a crowdsourced collection of roughly 50,000 instances, in which every input is a list of slot-value pairs and every expected output is the corresponding natural language sentence. The dataset has been partitioned by the challenge organizers in predefined training, validation and test sets, conceived for training data-driven, end-to-end Natural Language Generation models in the restaurant domain.

However, during our experiments, we noticed that the values contained in the E2E dataset are a little naive in terms of variability. In other words, a slot like name, that could virtually contain a very broad range of different values, is filled alternating between 19 fixed possibilities. Moreover, values are partitioned among training, validation and test set, in such a way that test set always contains values that are also present in the training set. Consequently, we created a modified version of the E2E dataset, called E2E+, as follows: we selected the slots that represent more copy-susceptible attributes, i.e. name, near and food, and conveniently replaced their values, in both meaning representations and reference sentences. New values for food are picked from Wikipedia’s list of adjectival forms of countries and nations111https://en.wikipedia.org/wiki/List_of_adjectival_and_demonymic_forms_for_countries_and_nations, consulted on August 30, 2018, while both name and near are filled with New York restaurants’ names contained in the Entree dataset presented in [Burke:97]. It is worth noting that none of the values of name are found in near; likewise, values that belong to the training set are not found in the validation set nor in the test one, and vice versa. This value partitioning shall ensure the absence of generation bias in the copy mechanism, stimulating the models to copy attribute values, regardless of their presence in the training set. The MR and 1st reference fields in table 3.3 are instances of this new dataset.

Finally, we decided to test our model also on two datasets, Hotel and Restaurant, frequently used in literature (for instance in [Wen:15a] and [Goyal:16]). They are built on a 12 attributes ontology: some attributes are common to both domains, while others are domain specific. Every MR is a list of key-value pairs enclosed in a dialogue act type, such as inform, used to present information about restaurants, confirm, to check that a slot value has been recognized correctly, and reject, to advise that the user’s constraints cannot be met. For the sake of compatibility, we filtered out from Hotel and Restaurant all inputs whose dialogue act type was not inform, and removed the dialogue act type. Besides, we changed the format of the key-value pairs to E2E-like ones.

Tables are encoded simply converting all characters to ASCII and feeding every corresponding index to the encoder, sequentially. The resulting model’s vocabulary is independent of the input, allowing the application of the transfer learning procedure.

3.2 Implementation Details

We developed our system using the PyTorch framework222Code and datasets are publicly available at https://github.com/marco-roberti/char-data-to-text-gen, release 0.4.1333https://pytorch.org/. The training has been carried out as described in subsection 2.3: this training procedure needs the two GRUs to have the same dimensions, in terms of input size, hidden size, number of layers and presence of a bias term. Moreover, they both have to be bidirectional, even if the decoder ignores the backward part of its current GRU.

We minimize the negative log-likelihood loss using teacher forcing [Williams:89] and Adam [Kingma:14], the latter being an optimizer that computes individual adaptive learning rates. As a consequence of the length of the input sequences, a character-based model is often subject to the exploding gradient problem, that we solved via the well-known technique of gradient norm clipping [Pascanu:13].

We also propose a new formulation of $P(c)$ that helps the model to learn when it is necessary to start a copying phase:

[TABLE]

Sometimes, our model has difficulty in focusing on the first letter it has to copy. This may be caused by the variety of characters it could be attending on; instead, it seems easier to learn to focus on the most largely seen characters, as for instance ‘ ’ and ‘[’. As these special characters are very often the prefix of the words we need to copy, when this focus is achieved, we would like the attention distribution to be translated one step to the right, over the first letter that must be copied. Therefore, the final probability of outputting a specific character $c$, introduced in eq. (7), is modified to $P_{att}^{i,j-1}$, i.e. the attention distribution shifted one step to the right and normalized.

Notice that $P_{att}^{i,j-1}$ is the only shifted probability, while $P_{alph}^{i}$ remains unchanged. Therefore, if the network is generating the next token (i.e. $p_{gen}^{i}\simeq 1$ ), the shift trick does not involve $P^{i}(c)$ and the network samples the next character from $P_{alph}^{i}$, as usual. This means that the shift operation is not degrading the generation ability of the model, whilst improving the copying one.

3.3 Results and Discussion

In order to show that our model represents an effective and relevant improvement, we carry out two different experimentations: an ablation study and a comparison with two well-known models. The first model is the encoder-decoder architecture with attention mechanism by [Bahdanau:14] (hereafter “EDA”), used character-by-character. The second one is TGen [Dusek:16], a word-based model, still derived from [Bahdanau:14], but integrating a beam search mechanism and a reranker over the top $k$ outputs, in order to disadvantage utterances that do not verbalize all the information contained in the MR. We chose it because it has been adopted as baseline in the E2E NLG Challenge444www.macs.hw.ac.uk/InteractionLab/E2E/.

We used the official code provided in the E2E NLG Challenge website for TGen, and we developed our models and EDA in PyTorch, training them on NVIDIA GPUs. Hyperparameter tuning is done through 10-fold cross-validation, using the bleu metric [Papineni:02] for evaluating each model. The training stopping criterion was based on the absence of models’ performance improvements (see [Dusek:16]).

We evaluated the models’ performance on test sets’ output utterances using the Evaluation metrics script555https://github.com/tuetschek/E2E-metrics provided by the E2E NLG Challenge organizers. It rates quality according to five different metrics: bleu [Papineni:02], nist [Doddington:02], meteor [Lavie:07], rouge_l [Lin:04] and cider [Vedantam:15].

Our first experimentation, the ablation study, refers to the E2E dataset because of its wide diffusion, and is shown in table 2; “EDA_CS” identifies our model, and ‘C’ and ‘S’ stand for “Copy” and “Switch”, the two major improvements presented in this work. It is evident that the partially-improved networks are able to provide independent benefits to the performance. Those components cooperate positively, as EDA_CS further enhances those results. Furthermore, the obtained bleu metric value on the E2E test set would allow our model to be ranked fourth in the E2E NLG Challenge, while its baseline TGen was ranked tenth.

Our second experimentation, the comparison study, is shown in table 3. The character-based design of EDA_CS led us to explore in this context also a possible behavior as a transfer learning capable model: in order to test this hypothesis, we used the weights learned during training on the E2E+ dataset as the starting point for a fine-tuning phase on all the other datasets. We chose E2E+ because it reduces the generation bias, as discussed in subsection 3.1. We named this approach EDA_CSTL.

A first interesting result is that our model EDA_CS always obtains higher metric values with respect to TGen on the Hotel and Restaurant datasets, and three out of five higher metrics values on the E2E dataset. However, in the case of E2E+, TGen achieves three out of five higher metrics values. These results suggest that EDA_CS and TGen are comparable, at least from the point of view of automatic metrics’ evaluation.

A more surprising result is that the approach EDA_CSTL allows to obtain better performance with respect to training EDA_CS in the standard way on the Hotel and Restaurant datasets (for the majority of metrics); on E2E, EDA_CSTL outperforms EDA_CS only in one case (i.e. meteor metric).

Moreover, EDA_CSTL shows a bleu increment of at least $14\%$ with respect to TGen’s score when compared to both Hotel and Restaurant datasets.

Finally, the baseline model, EDA, is largely outperformed by all other examined methods.

Therefore, we can claim that our model exploits its transfer learning capabilities effectively, showing very good performances in a context like data-to-text generation in which the portability of features learned from different datasets, in the extent of our knowledge, has not yet been explored.

We highlight that EDA_CS’s model’s good results are achieved even if it consists in a fully end-to-end model which does not benefit from the delexicalization-relexicalization procedure, differently from TGen. Most importantly, the latter represents a word-based system: as such, it is bound to a specific, limited vocabulary, in contrast to the general-purpose character one used in our work.