Skip to content
master
Switch branches/tags
Code

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
Nov 30, 2019
Nov 30, 2019

PIE: Parallel Iterative Edit Models for Local Sequence Transduction

Fast Grammatical Error Correction using BERT

Code and Pre-trained models accompanying our paper "Parallel Iterative Edit Models for Local Sequence Transduction" (EMNLP-IJCNLP 2019)

PIE is a BERT based architecture for local sequence transduction tasks like Grammatical Error Correction. Unlike the standard approach of modeling GEC as a task of translation from "incorrect" to "correct" language, we pose GEC as local sequence editing task. We further reduce local sequence editing problem to a sequence labeling setup where we utilize BERT to non-autoregressively label input tokens with edits. We rewire the BERT architecture (without retraining) specifically for the task of sequence editing. We find that PIE models for GEC are 5 to 15 times faster than existing state of the art architectures and still maintain a competitive accuracy. For more details please check out our EMNLP-IJCNLP 2019 paper

@inproceedings{awasthi-etal-2019-parallel,
    title = "Parallel Iterative Edit Models for Local Sequence Transduction",
    author = "Awasthi, Abhijeet  and
      Sarawagi, Sunita  and
      Goyal, Rasna  and
      Ghosh, Sabyasachi  and
      Piratla, Vihari",
    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP)",
    month = nov,
    year = "2019",
    address = "Hong Kong, China",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/D19-1435",
    doi = "10.18653/v1/D19-1435",
    pages = "4259--4269",
}

Datasets

  • All the public GEC datasets used in the paper can be obtained from here
  • Synthetically created datasets (perturbed version of 1 billion word corpus) divided into 5 parts to independently train 5 different ensembles. (all the ensembles are further finetuned using the public GEC datasets mentioned above.)

Pretrained Models

  • PIE as reported in the paper
    • trained on a Synethically created GEC dataset starting with BERT's initialization
    • finetuned further on Lang8, NUCLE and FCE datasets
  • Inference using the pretrained PIE ckpt
    • Copy the pretrained checkpoint files provided above to PIE_ckpt directory
    • Your PIE_ckpt directory should contain
      • bert_config.json
      • multi_round_infer.sh
      • pie_infer.sh
      • pie_model.ckpt.data-00000-of-00001
      • pie_model.ckpt.index
      • pie_model.ckpt.meta
      • vocab.txt
    • Run: $ ./multi_round_infer.sh from PIE_ckpt directory
    • NOTE: If you are using cloud-TPUs for inference, move the PIE_ckpt directory to the cloud bucket and change the paths in pie_infer.sh and multi_round_infer.sh accordingly

Code Description

An example usage of code in described in the directory "example_scripts".

  • preprocess.sh
    • Extracts common insertions from a sample training data in the "scratch" directory
    • converts the training data in the form of incorrect tokens and aligned edits
  • pie_train.sh
    • trains a pie model using the converted training data
  • multi_round_infer.sh
    • uses a trained PIE model to obtain edits for incorrect sentences
    • does 4 rounds of iterative editing
    • uses conll-14 test sentences
  • m2_eval.sh
    • evaluates the final output using m2scorer
  • end_to_end.sh
    • describes the use of pre-processing, training, inference and evaluation scripts end to end.
  • More information in README.md inside "example_scripts"

Pre processing and Edits related

  • seq2edits_utils.py
    • contains implementation of edit-distance algorithm.
    • cost for substitution modified as per section A.1 in the paper.
    • Adapted from belambert's implimentation
  • get_edit_vocab.py : Extracts common insertions (\Sigma_a set as described in paper) from a parallel corpus
  • get_seq2edits.py : Extracts edits aligned to input tokens
  • tokenize_input.py : tokenize a file containing sentences. token_ids obtained go as input to the model.
  • opcodes.py : A class where members are all possible edit operations
  • transform_suffixes.py: Contains logic for suffix transformations
  • tokenization.py : Similar to BERT's implementation, with some GEC specific changes

PIE model (uses implementation of BERT of bert in Tensorflow)

  • word_edit_model.py: Implementation of PIE for learning from a parallel corpous of incorrect tokens and aligned edits.
    • logit factorization logic (Keep flag use_bert_more=True to enable logit factorization)
    • parallel sequence labeling
  • modeling.py : Same as in BERT's implementation
  • modified_modeling.py
    • Rewires attention mask to obtain representations of candidate appends and replacements
    • Used for logit factorization.
  • optimization.py : Same as in BERT's implementation

Post processing

  • apply_opcode.py
    • Applies inferred edits from the PIE model to the incorrect sentences.
    • Handles punctuations and spacings as per requirements of a standard dataset (INFER_MODE).
    • Contains some obvious rules for captialization etc.

Creating synthetic GEC dataset

  • errorify directory contains the scripts we used for perturbing the one-billion-word corpus

Acknowledgements

This research was partly sponsored by a Google India AI/ML Research Award and Google PhD Fellowship in Machine Learning. We gratefully acknowledge Google's TFRC program for providing us Cloud-TPUs. Thanks to Varun Patil for helping us improve the speed of pre-processing and synthetic-data generation pipelines.