Natural Language Processing Tasks and References
In a controlled experiment of sequence-to-sequence approaches for the task of sentence correction, we find that character-based models are generally more effective than word-based models and models that encode subword information via convolutions, and that modeling the output data as a series of diffs improves effectiveness over standard approaches. Our strongest sequence-to-sequence model improves over our strongest phrase-based statistical machine translation model, with access to the same data, by 6 M2 (0.5 GLEU) points. Additionally, in the data environment of the standard CoNLL-2014 setup, we demonstrate that modeling (and tuning against) diffs yields similar or better M2 scores with simpler models and/or significantly less data than previous sequence-to-sequence approaches.READ FULL TEXT VIEW PDF
Automatic spelling and grammatical correction systems are one of the mos...
Most of the existing Neural Machine Translation (NMT) models focus on th...
Attention is an operation that selects some largest element from some se...
We formulate coherence modeling as a regression task and propose two nov...
Text simplification aims at making a text easier to read and understand ...
Placeholder translation systems enable the users to specify how a specif...
Lingvo is a Tensorflow framework offering a complete solution for
Natural Language Processing Tasks and References
The task of sentence correction is to convert a natural language sentence that may or may not have errors into a corrected version. The task is envisioned as a component of a learning tool or writing-assistant, and has seen increased interest since 2011 driven by a series of shared tasks (Dale and Kilgarriff, 2011; Dale et al., 2012; Ng et al., 2013, 2014).
Most recent work on language correction has focused on the data provided by the CoNLL-2014 shared task (Ng et al., 2014), a set of corrected essays by second-language learners. The CoNLL-2014 data consists of only around 60,000 sentences, and as such, competitive systems have made use of large amounts of corrected text without annotations, and in some cases lower-quality crowd-annotated data, in addition to the shared data. In this data environment, it has been suggested that statistical phrase-based machine translation (MT) with task-specific features is the state-of-the-art for the task (Junczys-Dowmunt and Grundkiewicz, 2016), outperforming word- and character-based sequence-to-sequence models (Yuan and Briscoe, 2016; Xie et al., 2016; Ji et al., 2017), phrase-based systems with neural features (Chollampatt et al., 2016b, a), re-ranking output from phrase-based systems (Hoang et al., 2016)
, and combining phrase-based systems with classifiers trained for hand-picked subsets of errors(Rozovskaya and Roth, 2016).
We revisit the comparison across translation approaches for the correction task in light of the Automated Evaluation of Scientific Writing (AESW) 2016 dataset, a correction dataset containing over 1 million sentences, holding constant the training data across approaches. The dataset was previously proposed for the distinct binary classification task of grammatical error identification.
Experiments demonstrate that pure character-level sequence-to-sequence models are more effective on AESW than word-based models and models that encode subword information via convolutions over characters, and that representing the output data as a series of diffs significantly increases effectiveness on this task. Our strongest character-level model achieves statistically significant improvements over our strongest phrase-based statistical machine translation model by 6 (0.5 GLEU) points, with additional gains when including domain information. Furthermore, in the partially crowd-sourced data environment of the standard CoNLL-2014 setup in which there are comparatively few professionally annotated sentences, we find that tuning against the tags marking the diffs yields similar or superior effectiveness relative to existing sequence-to-sequence approaches despite using significantly less data, with or without using secondary models. All code is available at https://github.com/allenschmaltz/grammar.
We follow recent work and treat the task of sentence correction as translation from a source sentence (the unedited sentence) into a target sentence (a corrected version in the same language as the source). We do not make a distinction between grammatical and stylistic corrections.
We assume a vocabulary of natural language word types (some of which have orthographic errors). Given a sentence , where is the -th token of the sentence of length , we seek to predict the corrected target sentence , where is the -th token of the corrected sentence of length . We are given both and for supervised training in the standard setup. At test time, we are only given access to sequence . We learn to predict sequence (which is often identical to ).
We explore word and character variants of the sequence-to-sequence framework. We use a standard word-based model (Word), similar to that of Luong et al. (2015)
, as well as a model that uses a convolutional neural network (CNN) and a highway network over characters (CharCNN), based on the work of Kim et al. (2016), instead of word embeddings as the input to the encoder and decoder. With both of these models, predictions are made at the word level. We also consider the use of bidirectional versions of these encoders (+Bi).
Our character-based model (Char+Bi) follows the architecture of the Word+Bi model, but the input and output consist of characters rather than words. In this case, the input and output sequences are converted to a series of characters and whitespace delimiters. The output sequence is converted back to prior to evaluation.
The Word models encode and decode over a closed vocabulary (of the 50k most frequent words); the CharCNN models encode over an open vocabulary and decode over a closed vocabulary; and the Char models encode and decode over an open vocabulary.
Our contribution is to investigate the impact of sequence-to-sequence approaches (including those not considered in previous work) in a series of controlled experiments, holding the data constant. In doing so, we demonstrate that on a large, professionally annotated dataset, the most effective sequence-to-sequence approach can significantly outperform a state-of-the-art SMT system without augmenting the sequence-to-sequence model with a secondary model to handle low-frequency words (Yuan and Briscoe, 2016) or an additional model to improve precision or intersecting a large language model (Xie et al., 2016). We also demonstrate improvements over these previous sequence-to-sequence approaches on the CoNLL-2014 data and competitive results with Ji et al. (2017), despite using significantly less data.
The work of Schmaltz et al. (2016) applies Word and CharCNN models to the distinct binary classification task of error identification.
The standard formulation of the correction task is to model the output sequence as above. Here, we also propose modeling the diffs between and . The diffs are provided in-line within and are described via tags marking the starts and ends of insertions and deletions, with replacements represented as deletion-insertion pairs, as in the following example selected from the training set: “Some key points are worth <del> emphasiz </del> <ins> emphasizing </ins> .”. Here, “emphasiz” is replaced with “emphasizing”. The models, including the Char model, treat each tag as a single, atomic token.
The diffs enable a means of tuning the model’s propensity to generate corrections by modifying the probabilities generated by the decoder for the 4 diff tags, which we examine with the CoNLL data. We include four bias parameters associated with each diff tag, and run a grid search between 0 and 1.0 to set their values based on the tuning set.
It is possible for models with diffs to output invalid target sequences (for example, inserting a word without using a diff tag). To fix this, a deterministic post-processing step is performed (greedily from left to right) that returns to source any non-source tokens outside of insertion tags. Diffs are removed prior to evaluation. We indicate models that do not incorporate target diff annotation tags with the designator –diffs.
The AESW dataset provides the paragraph context and a journal domain (a classification of the document into one of nine subject categories) for each sentence.111The paragraphs are shuffled for purposes of obfuscation, so document-level context is not available. For the sequence-to-sequence models we propose modeling the input and output sequences with a special initial token representing the journal domain (+dom).222Characteristics of the dataset preclude experiments with additional paragraph context features. (See Appendix A.)
AESW (Daudaravicius, 2016; Daudaravicius et al., 2016) consists of sentences taken from academic articles annotated with corrections by professional editors used for the AESW shared task. The training set contains 1,182,491 sentences, of which 460,901 sentences have edits. We set aside a 9,947 sentence sample from the original development set for tuning (of which 3,797 contain edits), and use the remaining 137,446 sentences as the dev set333The dev set contains 13,562 unique deletion types, 29,952 insertion types, and 39,930 replacement types. (of which 53,502 contain edits). The test set contains 146,478 sentences.
The primary focus of the present study is conducting controlled experiments on the AESW dataset, but we also investigate results on the CoNLL-2014 shared task data in light of recent neural results (Ji et al., 2017) and to serve as a baseline of comparison against existing sequence-to-sequence approaches (Yuan and Briscoe, 2016; Xie et al., 2016). We use the common sets of public data appearing in past work for training: the National University of Singapore (NUS) Corpus of Learner English (NUCLE) (Dahlmeier et al., 2013) and the publicly available Lang-8 data (Tajiri et al., 2012; Mizumoto et al., 2012). The Lang-8 dataset of corrections is large444about 1.4 million sentences after filtering but is crowd-sourced555derived from the Lang-8 language-learning website and is thus of a different nature than the professionally annotated AESW and NUCLE datasets. We use the revised CoNLL-2013 test set as a tuning/dev set and the CoNLL-2014 test set (without alternatives) for testing. We do not make use of the non-public Cambridge Learner Corpus (CLC) (Nicholls, 2003), which contains over 1.5 million sentence pairs.
All our models, implemented with OpenNMT (Klein et al., ), are -layer LSTMs with hidden units. For the Word model, the word embedding size is also set to , while for the CharCNN and Char models we use a character embedding size of . The CharCNN model has a convolutional layer with filters of width
followed by max-pooling, which is fed into a-layer highway network. Additional training details are provided in Appendix A. For AESW, the Word+Bi model contains around 144 million parameters, the CharCNN+Bi model around 79 million parameters, and the Char+Bi model around 25 million parameters.
As a baseline of comparison, we experiment with a phrase-based machine translation approach (SMT) shown to be state-of-the-art for the CoNLL-2014 shared task data in previous work (Junczys-Dowmunt and Grundkiewicz, 2016), which adds task specific features and the metric as a scorer to the Moses statistical machine translation system. The SMT model follows the training, parameters, and dense and sparse task-specific features that generate state-of-the-art results for CoNLL-2014 shared task data, as implemented in publicly available code.666SRI International provided access to SRILM (Stolcke, 2002) for running Junczys-Dowmunt and Grundkiewicz (2016) However, to compare models against the same training data, we remove language model features associated with external data.777We found that including the features and data associated with the large language models of Junczys-Dowmunt and Grundkiewicz (2016), created from Common Crawl text filtered against the NUCLE corpus, hurt effectiveness for the phrase-based models. This is likely a reflection of the domain specific nature of the academic text and LaTeX holder symbols appearing in the text. Here, we conduct controlled experiments without introducing additional domain-specific monolingual data. We experiment with tuning against (+) and BLEU (+BLEU). Models trained with diffs were only tuned with BLEU, since the tuning pipeline from previous work is not designed to handle removing such annotation tags prior to scoring.
|Replacement Error Type (out of 39,930) – Frequency relative to training|
|Raw frequency in dev||11507||1691||6788||8974||2271||1620||7079|
|Number of unique instances||371||367||215||2918||1510||1242||5819|
Table 1 shows the full set of experimental results on the AESW development and test data.
The Char+Bi+dom model is stronger than the Word+Bi+dom and CharCNN+dom models by 2.9 (0.2 GLEU) and 3.3 (0.3 GLEU), respectively. The sequence-to-sequence models were also more effective than the SMT models, as shown in Table 1. We find that training with target diffs is beneficial across all models, with an increase of about 5 points for the Word+bi model, for example. Adding +dom information slightly improves effectiveness across models.
We analyzed deletion, insertion, and replacement error types. Table 2 compares effectiveness across replacement errors. We found the CharCNN+Bi models were less effective than CharCNN variants in terms of GLEU and , and the strongest CharCNN models were eclipsed by the Word+Bi models in terms of the GLEU and scores. However, Table 2 shows CharCNN+dom is stronger on lower frequency replacements than Word models. The Char+Bi+dom model is relatively strong on article and punctuation replacements, as well as errors appearing with low frequency in the training set and overall across deletion and insertion error types, which are summarized in Table 3.
The comparatively high Micro score (18.66) for the Char+Bi+dom model on replacement errors (Table 2) never occurring in training is a result of a high precision (92.65) coupled with a low recall (4.45). This suggests some limited capacity to generalize to items not seen in training. A selectively chosen example is the replacement from “discontinous” to “discontinuous”, which never occurs in training. However, similar errors of low edit distance also occur once in the dev set and never in training, but the Char+Bi+dom model never correctly recovers many of these errors, and many of the correctly recovered errors are minor changes in capitalization or hyphenation.
About 39% of the AESW training sentences have errors, and of those sentences, on average, 2.4 words are involved in changes in deletions, insertions, or replacements (i.e., the count of words occurring between diff tags) per sentence. In the NUCLE data, about 37% of the sentences have errors, of which on average, 5.3 words are involved in changes. On the AESW dev set, if we only consider the 9545 sentences in which 4 or more words are involved in a change (average of 5.8 words in changes per sentence), the Char+Bi model is still more effective than SMT+BLEU, with a GLEU score of 67.21 vs. 65.34. The baseline GLEU score (No Change) is 60.86, reflecting the greater number of changes relative to the full dataset (cf. Table 1).
The AESW dataset only provides 1 annotation for each sentence, so we perform a small re-annotation of the data to gauge effectiveness in the presence of multiple annotations. We collected 3 outputs (source, gold, and generated sentences from the Char+Bi+dom model) for 200 randomly sampled sentences, re-annotating to create 3 new references for each sentence. The GLEU scores for the 200 original source, Char+Bi+dom, and original gold sentences evaluated against the 3 new references were 79.79, 81.72, and 84.78, respectively, suggesting that there is still progress to be made on the task relative to human levels of annotation.
|Word+Bi, before tuning||72.34||0.97||4.60|
|Word+Bi, after tuning||46.66||15.35||33.14|
Since the CoNLL data does not contain enough data for training neural models, previous works add the crowd-sourced Lang-8 data; however, this data is not professionally annotated. Since the distribution of corrections differs between the dev/test and training sets, we need to tune the precision and recall.
As shown in Table 4, Word+Bi effectiveness increases significantly by tuning the weights888In contrast, in early experiments on AESW, tuning yielded negligible improvements. assigned to the diff tags on the CoNLL-2013 set999The single model with highest score was then run on the test set. Here, a single set is used for tuning and dev.. Note that we are tuning the weights on this same CoNLL-2013 set. Without tuning, the model very rarely generates a change, albeit with a high precision. After tuning, it exceeds the effectiveness of Word+Bi–diffs. The comparatively low effectiveness of Word+Bi–diffs is consistent with past sequence-to-sequence approaches utilizing data augmentation, additional annotated data, and/or secondary models to achieve competitive levels of effectiveness.
Table 5 shows that Word+Bi is within 0.2 of Ji et al. (2017), despite using over 1 million fewer sentence pairs, and exceeds the scores of Xie et al. (2016) and Yuan and Briscoe (2016) without the secondary models of those systems. We hypothesize that further gains are possible utilizing the CLC data and moving to the character model. (The character model is omitted here due to the long training time of about 4 weeks.) Notably, SMT systems (with LMs) are still more effective than reported sequence-to-sequence results, as in Ji et al. (2017), on CoNLL.101010For reference, the reported results of the carefully optimized SMT system of Junczys-Dowmunt and
Grundkiewicz (2016) trained on NUCLE and Lang-8, with parameter vectors averaged over multiple runs, with a Wikipedia LM is 45.95 and adding a Common Crawl LM is 49.49. We leave to future work the intersection of a LM for the CoNLL environment and more generally, whether these patterns hold in the presence of additional monolingual data.
trained on NUCLE and Lang-8, with parameter vectors averaged over multiple runs, with a Wikipedia LM is 45.95 and adding a Common Crawl LM is 49.49. We leave to future work the intersection of a LM for the CoNLL environment and more generally, whether these patterns hold in the presence of additional monolingual data.
|Yuan and Briscoe (2016)||CLC||39.90|
|Xie et al. (2016)||NUCLE, Lang-8, Common Crawl LM||40.56|
|Ji et al. (2017)||NUCLE, Lang-8, CLC||41.53|
Our experiments demonstrate that on a large, professionally annotated dataset, a sequence-to-sequence character-based model of diffs can lead to considerable effectiveness gains over a state-of-the-art SMT system with task-specific features, ceteris paribus. Furthermore, in the crowd-sourced environment of the CoNLL data, in which there are comparatively few professionally annotated sentences in training, modeling diffs enables a means of tuning that improves the effectiveness of sequence-to-sequence models for the task.
Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 1901–1911, Austin, Texas. Association for Computational Linguistics.
Proceedings of the Twenty-Fifth International Joint Conference on Artificial Intelligence, IJCAI’16, pages 2768–2774. AAAI Press.
Proceedings of the 13th European Workshop on Natural Language Generation, ENLG ’11, pages 242–249, Stroudsburg, PA, USA. Association for Computational Linguistics.
We provide additional replication details for our experiments here. Our code and related materials are available at the following url: https://github.com/allenschmaltz/grammar.
The training and tuning sizes of the AESW dataset are those after dropping sentences exceeding 126 tokens on the source or target side (in source sequences or target sequences with diff annotation tags) from the raw AESW dataset. All evaluation metrics on the development and test set are on the data without filtering based on sentence lengths.
As part of preprocessing, the sentences from the AESW XML are converted to Penn Treebank-style tokenization. Case is maintained and digits are not replaced with holder symbols for the sequence-to-sequence models. For the SMT models, the truecasing111111Here, the truecase language model is created from the training sequences (or where applicable, the target with diffs). and tokenization pipeline of the publicly available code is used. For consistency, all model output and all reference files are converted to cased Moses-style tokenization prior to evaluation.
For the Char model, the -normalized gradients were constrained to be (instead of with the other models), and our learning rate schedule started the learning rate at 0.5 (instead of 1 for the other models) for stable training. The maximum sequence length of 421 was used for models given character sequences, which was equivalent to the maximum sequence length of 126 used for models given word sequences. The maximum sequence lengths were increased by 1 for the models with the +dom features. The training and tuning set sizes cited in Section 3 are the number of sentences from the raw dataset after dropping sentences exceeding these maximum sequence lengths.
In practice, we were able to train each of the purely character-based models (e.g., the Char+Bi+dom model) with a single NVIDIA Quadro P6000 GPU with 24 GB of memory in about 3 weeks with a batch size of 12.
For the sequence-to-sequence models, the closed vocabularies were restricted to the 50,000 most common tokens, and a single special token was used for all remaining low frequency tokens. An token generated in the target sentence by the Word and CharCNN models was replaced with the source token associated with the maximum attention weight. The “open” vocabularies were only limited to the space of characters seen in training.
For the phrase-based machine translation baseline model from the work of Junczys-Dowmunt and Grundkiewicz (2016), for dense features, we used the stateless edit distance features and the stateful Operation Sequence Model (OSM) of Durrani et al. (2013)121212The OSM features use the SRI Language Modeling Toolkit (SRILM) (Stolcke, 2002). . Since for our controlled data experiments we removed the language model features associated with external data, we did not use the word-class language model feature, so for the sparse features, we used the set of edit operations on “words with left/right context of maximum length 1 on words” (set “E0C10” from the original paper), instead of those dependent on word classes.
The training and tuning splits for the phrase-based machine translation models were the same as for the sequence-to-sequence models. For tuning, we used Batch-Mira, setting the background corpus decay rate to 0.001, as in previous work. As in previous work, we repeated the tuning process multiple times (in this case, 5 times) and averaged the final weight vectors.
The sequence-to-sequence models were decoded with a beam size of 10.
Decoding of the SMT models used the same approach of Junczys-Dowmunt and Grundkiewicz (2016) (i.e., the open-source Moses decoder run with the cube pruning search algorithm).
In our experiments, we do not include additional paragraph context features, since the underlying AESW data appears to have been collected such that nearly all paragraphs (including those containing a single sentence) contain at least one error; thus, modeling paragraph information provides additional signal that seems unlikely to reflect real-world environments.
For training, we used the copy of the Lang-8 corpus distributed in the repo for the code of Junczys-Dowmunt and Grundkiewicz (2016): https://github.com/grammatical/baselines-emnlp2016. We filtered the Lang-8 data to remove duplicates and target sentences containing emoticon text, informal colloquial words (e.g., “haha”, “lol”, “yay”), and non-ascii characters. Target sentences not starting with a capital letter were dropped, as were target sentences not ending in a period, question mark, exclamation mark, or quotation mark. (Target sentences ending in a parenthesis were dropped as they often indicate informal additional comments from the editor.) In the combined NUCLE and Lang-8 training set, source sentences longer than 79 tokens and target sentences longer than 100 tokens were dropped. This resulted in a training set with 1,470,992 sentences. Diffs were created using the Python class difflib.SequenceMatcher.
For tuning on the dev set131313Previous work, such as Junczys-Dowmunt and Grundkiewicz (2016), also used the CoNLL-2013 set for tuning., a coarse grid search between 0 and 1.0 was used to set the four bias parameters associated with each diff tag. (Training was performed without re-weighting.) The bias parameter (in this case 0.7) yielding the highest score on the decoded dev set was chosen for use in evaluation of the final test set. The scores across the tuning runs on the dev set for the Word+Bi model are shown in Table 6.
For future comparisons to our work on the CoNLL-2014 shared task data, we recommend using the preprocessing scripts provided in our code repo (https://github.com/allenschmaltz/grammar).
The seven columns of Table 2 appearing in the main text are Micro scores for the errors within each frequency grouping. There are a total of 39,916 replacement changes. The replacements are grouped in regard to the changes within the opening and closing deletion tags and subsequent opening and closing insertion tags, as follows: (1) whether the replacement involves (on the deletion and/or insertion side) a single punctuation symbol (comma, colon, period, hyphen, apostrophe, quotation mark, semicolon, exclamation, question mark); (2) whether the replacement involves (on the deletion and/or insertion side) a single article (a, an, the); (3) non-article, non-punctuation grouped errors with frequency greater than 100 in the gold training data; (4) non-article, non-punctuation grouped errors with frequency less than or equal to 100 and greater than or equal to 5; (5) non-article, non-punctuation grouped errors with frequency less than 5 and greater than or equal to 2; (6) non-article, non-punctuation grouped errors with frequency equal to 1; (7) non-article, non-punctuation grouped errors that never occurred in the training data. Note that the large number of unique instances occurring for the “punctuation” and “articles” classes are a result of the large number of errors that can occur on the non-article, non-punctuation side of the replacement. The Micro scores are calculated by treating each individual error (rather than the agglomerated classes here) as binary classifications.