Upload data

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/nucle3.2.sgml filter=lfs diff=lfs merge=lfs -text

CoNLL-preproc-README

@@ -0,0 +1,224 @@
+====================================================
+
+CoNLL-2014 Shared Task: Grammatical Error Correction
+
+Description of Preprocessed NUCLE Data Set
+
+7 April 2014  Version 3.2
+====================================================
+
+
+1. General
+==========
+
+This README file describes a preprocessed version of the NUS Corpus of
+Learner English (NUCLE). For information about NUCLE, please refer to
+the NUCLE README file.  For information about the CoNLL-2014 shared
+task, please refer to the shared task website.
+
+The preprocessed data set, following earlier CoNLL shared tasks,
+provides syntactic information for the raw texts in NUCLE.  For each
+sentence, the part of speech tags, dependency parse tree, and
+constituent parse tree are encoded in a column format.
+
+In NUCLE, annotations are made at the character level, which means
+both the start offset and the end offset of an error annotation are
+character positions in the corresponding paragraph.  In this
+preprocessed version, annotations are made at the token level, which
+means the start offset and the end offset are indexes of tokens in the
+corresponding sentence.
+
+This README is updated on 4 August 2014.
+
+
+2. Files
+========
+
+Two files are to be generated:
+
+  conll14st-preprocessed.conll
+  conll14st-preprocessed.conll.ann
+
+conll14st-preprocessed.conll contains the preprocessed data in
+CoNLL-style column format. This file is not included in this
+distribution due to the size.
+
+conll14st-preprocessed.conll.ann contains token-level annotations.
+
+
+3. Preprocessing systems
+========================
+
+The NUCLE corpus is preprocessed with the following steps to generate
+this preprocessed data set:
+
+  a). sentence splitting, using nltk punkt [1].
+      Note: the version used to generate the files is before the fixing
+            of issue 514
+  b). word tokenization, using nltk word_tokenize [1].
+  c). POS tags, dependency parse trees, and constituent parse trees,
+      using the Stanford parser [2].
+  d). projecting character-level annotation to token-level annotation.
+
+Results from (a-c) are in conll14st-preprocessed.conll. The projected
+annotations (d) are included in conll14st-preprocessed.conll.ann.
+
+
+4. Data format
+==============
+
+Here is an example sentence in conll14st-preprocessed.conll:
+
+	NID	PID	SID TOKENID	TOKEN	POS	DPHEAD	DPREL	SYNT
+
+	829     1       2       0       This    DT      1       det     (ROOT(S(NP*
+	829     1       2       1       will    NN      7       nsubj   *)
+	829     1       2       2       ,       ,       -       -       *
+	829     1       2       3       if      IN      4       mark    (SBAR*
+	829     1       2       4       not     RB      7       dep     (FRAG*
+	829     1       2       5       already RB      4       dep     (ADVP*)))
+	829     1       2       6       ,       ,       -       -       *
+	829     1       2       7       caused  VBD     -1      root    (VP*
+	829     1       2       8       problems        NNS     7       dobj    (NP*)
+	829     1       2       9       as      IN      11      mark    (SBAR*
+	829     1       2       10      there   EX      11      expl    (S(NP*)
+	829     1       2       11      are     VBP     7       advcl   (VP*
+	829     1       2       12      very    RB      13      advmod  (NP(NP(ADJP*
+	829     1       2       13      limited VBN     14      amod    *)
+	829     1       2       14      spaces  NNS     11      nsubj   *)
+	829     1       2       15      for     IN      14      prep    (PP*
+	829     1       2       16      us      PRP     15      pobj    (NP*)))))))
+	829     1       2       17      .       .       -       -       *))
+
+
+The columns represent the following:
+
+	Column	Type		Description
+
+	0	NID		Document id of the sentence, equals to "nid" in NUCLE.
+	1	PID		Paragraph index of the sentence, according to the paragraphing in NUCLE (<p></p>).
+	2	SID		Sentence index in paragraph, each sentence has its own index starting from 0.
+	3	TOKENID		Token index in the sentence, starting from 0.
+	4	TOKEN		Word/token.
+	5	POS		Part of speech tag.
+	6	DPHEAD		Index of parent in dependency tree.
+	7	DPREL		Dependency relation with parent.
+	8	SYNT		Constituent tree. The constituent tree can be recovered as follows:
+				(a) Replacing "*" in this column with a string "(pos word)",
+				    where pos is the value of column 5, word is the value of column 4.  
+				(b) Concatenating all the strings in (a) gives 
+				    the bracketing structure of the constituent parse tree. 
+
+------------------------------------------------------------------------
+
+Here is the corresponding token-level annotation for the above
+sentence (in conll14st-preprocessed.conll.ann):
+
+	<ANNOTATION>
+	<MISTAKE nid="829" pid="1" sid="2" start_token="7" end_token="8">
+	<TYPE>Vform</TYPE>
+	<CORRECTION>cause</CORRECTION>
+	</MISTAKE>
+	<MISTAKE nid="829" pid="1" sid="2" start_token="14" end_token="15">
+	<TYPE>Nn</TYPE>
+	<CORRECTION>space</CORRECTION>
+	</MISTAKE>
+	<MISTAKE nid="829" pid="1" sid="2" start_token="11" end_token="12">
+	<TYPE>SVA</TYPE>
+	<CORRECTION>is</CORRECTION>
+	</MISTAKE>
+	</ANNOTATION>
+
+The tags represent the following:
+	
+	Tag			Description
+
+	<ANNOTATION>		Each <ANNOTATION></ANNOTATION> section identifies annotations for one sentence.
+
+	<MISTAKE>		Identifies an error annotation, with the following attributes:
+				nid:  Document id of the sentence, equals to the NID column (column 0) in .conll file
+				pid:  Paragraph index of the sentence, equals to the PID column in .conll file
+				sid:  Sentence index in paragraph, equals to the SID column in .conll file
+				start_token: The token index (TOKENID column in .conll file) which is the start of annotation. 
+				end_token:  The token index which is the end of the annotation. 
+
+	<TYPE>			Error tag (refer to the NUCLE corpus README file for the complete list of error tags).
+
+	<CORRECTION>		Correction, replacing tokens in the interval [start_token, end_token) with the 
+                                correction string will result in a corrected sentence.
+
+------------------------------------------------------------------------
+
+How to map a sentence to its annotation?
+
+In conll14st-preprocessed.conll, different sentences are separated by
+empty lines, and <ANNOTATION></ANNOTATION> sections are also separated
+by empty lines in conll14st-preprocessed.conll.ann.  A sentence maps
+to one <ANNOTATION></ANNOTATION> section, with the same nid, pid, and
+sid.  If a sentence has no annotation, there is no
+<ANNOTATION></ANNOTATION> section for it.  The order of the
+<ANNOTATION></ANNOTATION> sections is the same as the order of
+sentences in the preprocesed file.
+
+
+5. Updates included in version 2.1
+==================================
+
+The error categories Wcip and Rloc have been mapped to Prep, Wci,
+ArtOrDet, and Rloc-, to facilitate the detection and correction of
+preposition errors and article/determiner errors. See the NUCLE README
+file for details on how the mapping was done.
+
+50 overlapping error annotations involving the 5 error tags ArtOrDet,
+Prep, Nn, Vform, and SVA have been modified such that they do not
+overlap in the revised error annotations.
+
+Some minor mistakes in error annotations have been corrected.
+
+This was done for the CoNLL-2013 Shared Task.
+
+
+6. Updates included in version 3.0
+==================================
+
+The overlapping error annotations of the remaining error tags have
+been modified such that they do not overlap in the revised error
+annotations.
+
+Some minor mistakes in error annotations have been corrected.
+
+
+7. Updates included in version 3.1
+==================================
+
+Duplicate error annotations, each having the same span and correction
+string but different error type, are removed to keep only one of
+those.
+
+Previously, annotations spanning to the end of the paragraph was
+detected as cross-sentence and therefore not included in the
+preprocessed format. This has been fixed such that they are included
+in the preprocessed format.
+
+Some minor mistakes in error annotations have been corrected.
+
+
+8. Updates included in version 3.2
+==================================
+
+The preprocessing script has been fixed such that gold edits that
+insert empty string are not included in the token-level gold edit and
+scorer answer files.
+
+
+9. References
+=============
+
+[1] Steven Bird, Ewan Klein, and Edward Loper. 2009. Natural Language
+Processing with Python. O'Reilly Media Inc. http://nltk.org/
+
+[2] Dan Klein and Christopher D. Manning. 2003. Accurate Unlexicalized
+Parsing.  Proceedings of the 41st Annual Meeting of the Association for
+Computational Linguistics, pp. 423-430.  
+Stanford parser version 2.0.1.
+http://nlp.stanford.edu/software/stanford-parser-2012-03-09.tgz

README

@@ -0,0 +1,261 @@
+NUCLE Release 3.3
+24 Jan 2019
+
+This README file describes the NUS Corpus of Learner English (NUCLE).
+It was collected in a collaboration project between the National
+University of Singapore (NUS) Natural Language Processing (NLP) Group
+led by Prof. Hwee Tou Ng and the NUS Centre for English Language
+Communication (CELC) led by Prof. Siew Mei Wu. The work was carried
+out as part of the PhD thesis research of Daniel Dahlmeier at the NUS
+NLP Group.
+
+The corpus is distributed under the standard NUS licensing agreement
+available when downloading the corpus. Any questions regarding NUCLE
+should be directed to Hwee Tou Ng at: nght@comp.nus.edu.sg
+
+If you are using the NUCLE corpus in your work, please include a
+citation of the following paper:
+
+Daniel Dahlmeier, Hwee Tou Ng, and Siew Mei Wu (2013). Building a
+Large Annotated Corpus of Learner English: The NUS Corpus of Learner
+English. Proceedings of the Eighth Workshop on Innovative Use of NLP
+for Building Educational Applications (BEA 2013). (pp. 22 --
+31). Atlanta, Georgia, USA.
+
+
+1. About
+========
+
+NUCLE is a corpus of learner English. It consists of about 1,400
+essays written by university students at the National University of
+Singapore on a wide range of topics, such as environmental pollution,
+healthcare, etc. It contains over one million words which are
+completely annotated with error categories and corrections. All
+annotations have been performed by professional English instructors at
+the NUS CELC.
+
+
+2. Data Format 
+==============
+
+The corpus is distributed in a simple SGML format.  All annotations
+come in a "stand-off" format. The start position and end position of
+an annotation are given by paragraph and character offsets.
+Paragraphs are enclosed in <P>...</P> tags. Paragraphs and characters
+are counted starting from zero. Each annotation includes the following
+fields: the error category, the correction, and optionally a
+comment. If the correction replaces the original text at the given
+location, it should fix the grammatical error.
+
+Example:
+
+<DOC nid="840">
+<TEXT>
+<P>
+Engineering design process can be defined as a process ...
+</P>
+<P>
+Firstly, engineering design ...
+</P>
+...
+</TEXT>
+<ANNOTATION teacher_id="173">
+<MISTAKE start_par="0" start_off="0" end_par="0" end_off="26">
+<TYPE>ArtOrDet</TYPE>
+<CORRECTION>The engineering design process</CORRECTION>
+</MISTAKE>
+...
+</ANNOTATION>
+</DOC>
+<DOC nid="862">
+...
+
+
+Below is a complete list of the error categories in NUCLE release 2.0:
+
+ERROR TAG    ERROR CATEGORY
+---------------------------
+Vt	     Verb tense
+Vm	     Verb modal
+V0	     Missing verb
+Vform	     Verb form
+SVA	     Subject-verb-agreement
+ArtOrDet     Article or Determiner
+Nn	     Noun number
+Npos	     Noun possesive
+Pform	     Pronoun form
+Pref	     Pronoun reference
+Wcip	     Wrong collocation/idiom/preposition
+Wa	     Acronyms
+Wform	     Word form
+Wtone	     Tone
+Srun	     Runons, comma splice
+Smod	     Dangling modifier
+Spar	     Parallelism
+Sfrag	     Fragment
+Ssub	     Subordinate clause
+WOinc	     Incorrect sentence form
+WOadv	     Adverb/adjective position
+Trans	     Link word/phrases
+Mec	     Punctuation, capitalization, spelling, typos
+Rloc	     Local redundancy
+Cit	     Citation
+Others	     Other errors
+Um	     Unclear meaning (cannot be corrected)
+
+
+3. Updates included in version 2.1
+==================================
+
+The major change made in version 2.1 is to map the error categories
+Wcip and Rloc to Prep, Wci, ArtOrDet, and Rloc-.
+
+In the original NUCLE corpus, there is not an explicit preposition
+error category. Instead, preposition errors are part of the Wcip
+(Wrong collocation/idiom/preposition) and Rloc (local redundancy)
+error categories. In addition, redundant article or determiner errors
+are part of the Rloc error category.
+
+To facilitate the detection and correction of preposition errors and
+article/determiner errors, we perform mapping of error categories in
+the original NUCLE corpus. The mapping relies on POS tags, constituent
+parse trees, and error annotations at the token level.
+
+(a) Conditions to change from the error category Wcip or Rloc to Prep:
+
+This applies to replacing a preposition by another preposition, or
+deleting a preposition. The string to be replaced is one word w with
+POS tag IN or TO, the parent of w is a PP in the constituent parse
+tree, and the replacement is either a preposition or the empty string.
+
+(b) Conditions to change from the error category Wcip to Prep:
+
+This applies to inserting a preposition. The replacement is a
+preposition (one word only) and the immediately following word is
+tagged as VBG or is the first word of a noun phrase (NP).
+
+(c) Conditions to change from the error category Rloc to ArtOrDet:
+
+The single word has POS tag DT and the replacement is the empty
+string.
+
+The remaining unaffected "Wcip" errors are assigned the new error
+category "Wci" and the remaining unaffected "Rloc" errors are assigned
+the new error category "Rloc-".
+
+List of 36 Prepositions:
+
+about along among around as at beside besides between by down during
+except for from in inside into of off on onto outside over through to
+toward towards under underneath until up upon with within without
+
+Below is a complete list of 28 error categories in NUCLE release 2.1:
+
+ERROR TAG    ERROR CATEGORY
+---------------------------
+Vt	     Verb tense
+Vm	     Verb modal
+V0	     Missing verb
+Vform	     Verb form
+SVA	     Subject-verb-agreement
+ArtOrDet     Article or Determiner
+Nn	     Noun number
+Npos	     Noun possesive
+Pform	     Pronoun form
+Pref	     Pronoun reference
+Prep         Preposition
+Wci	     Wrong collocation/idiom
+Wa	     Acronyms
+Wform	     Word form
+Wtone	     Tone
+Srun	     Runons, comma splice
+Smod	     Dangling modifier
+Spar	     Parallelism
+Sfrag	     Fragment
+Ssub	     Subordinate clause
+WOinc	     Incorrect sentence form
+WOadv	     Adverb/adjective position
+Trans	     Link word/phrases
+Mec	     Punctuation, capitalization, spelling, typos
+Rloc-	     Local redundancy
+Cit	     Citation
+Others	     Other errors
+Um	     Unclear meaning (cannot be corrected)
+
+
+3. Updates included in version 2.2
+==================================
+
+- Fixed the bug on expanding an error annotation involving part of a
+token to the full token.
+
+- Other miscellaneous corrections were made.
+
+
+4. Updates included in version 2.3
+==================================
+
+- Fixed the bug involving tokenization of punctuation symbols in the
+correction string.
+
+- Fixed the tokenization example in the README file of the M^2 scorer
+to reflect the real tokenization to be used and removed irrelevant
+codes from the scorer package.
+
+
+5. Updates included in version 3.0
+==================================
+
+- Resolved overlapping annotations in the NUCLE corpus to make them
+  non-overlapping.
+
+- Corrected some minor mistakes in error annotations.
+
+
+6. Updates included in version 3.1
+==================================
+
+- Removed duplicate annotations in the NUCLE corpus with the same span
+  and correction string but different error type so as to keep only one of
+  those annotations. This fix only affects 0.1% of all annotations.
+
+- Fixed end-of-paragraph annotations so that the end offset of such
+  annotations is the last character position in the paragraph. This fix
+  only affects 0.7% of all annotations.
+
+- Corrected some minor mistakes in error annotations.
+
+- Inclusion of the CoNLL-2013 test data, with all the known problems
+  described above fixed. Participating teams in the CoNLL-2014 shared
+  task can make use of the CoNLL-2013 test data in training and
+  developing their systems if they wish to do so.
+
+- Fixed a minor bug in the M2 scorer that caused duplicate insertion
+  edits to receive high scores.
+
+
+7. Updates included in version 3.2
+==================================
+
+- Fixed the preprocessing script such that a gold edit that inserts an
+  empty string is not included in the token-level gold edit and scorer
+  answer files.
+
+- Removed one edit that inserted an empty string from the CoNLL-2014
+  test data. Also removed such instances from the NUCLE training data.
+
+- Fixed a bug in the M2 scorer arising from scoring against gold edits
+  from multiple annotators. Specifically, the bug sometimes caused
+  incorrect scores to be reported when scoring against the gold edits
+  of subsequent annotators (other than the first annotator).
+
+- Fixed a bug in the M2 scorer that caused erroneous scores to be
+  reported when dealing with insertion edits followed by deletion edits
+  (or vice versa).
+
+
+8. Updates included in version 3.3
+==================================
+
+- Added a subdirectory "bea2019" to contain the ERRANT typed NUCLE M2
+  file for the BEA 2019 shared task on grammatical error correction.

README.md

@@ -0,0 +1,193 @@
+# NUCLE Release 3.3
+**24 Jan 2019**
+
+This page describes the **NUS Corpus of Learner English (NUCLE)**.
+It was collected in a collaboration project between the National University of Singapore (NUS) Natural Language Processing (NLP) Group led by Prof. Hwee Tou Ng and the NUS Centre for English Language Communication (CELC) led by Prof. Siew Mei Wu. The work was carried out as part of the PhD thesis research of Daniel Dahlmeier at the NUS NLP Group.
+
+The corpus is distributed under the standard NUS licensing agreement available when downloading the corpus.
+
+Any questions regarding NUCLE should be directed to Hwee Tou Ng at: `nght@nus.edu.sg`.
+
+If you use the NUCLE corpus in your work, please cite the following paper:
+
+> Daniel Dahlmeier, Hwee Tou Ng, and Siew Mei Wu (2013). *Building a Large Annotated Corpus of Learner English: The NUS Corpus of Learner English.*
+> Proceedings of the Eighth Workshop on Innovative Use of NLP for Building Educational Applications (BEA 2013), pp. 22–31. Atlanta, Georgia, USA.
+
+---
+
+## 1. About
+
+NUCLE is a corpus of learner English. It consists of about 1,400 essays written by university students at the National University of Singapore on a wide range of topics, such as environmental pollution, healthcare, etc. It contains over one million words which are completely annotated with error categories and corrections. All annotations have been performed by professional English instructors at the NUS CELC.
+
+---
+
+## 2. Data Format
+
+The corpus is distributed in a simple SGML format.  All annotations come in a "stand-off" format. The start position and end position of an annotation are given by paragraph and character offsets. Paragraphs are enclosed in `<P>...</P>` tags. Paragraphs and characters are counted starting from zero. Each annotation includes the following fields: the error category, the correction, and optionally a comment. If the correction replaces the original text at the given location, it should fix the grammatical error.
+
+### Example
+
+```sgml
+<DOC nid="840">
+<TEXT>
+<P>
+Engineering design process can be defined as a process ...
+</P>
+<P>
+Firstly, engineering design ...
+</P>
+...
+</TEXT>
+<ANNOTATION teacher_id="173">
+<MISTAKE start_par="0" start_off="0" end_par="0" end_off="26">
+<TYPE>ArtOrDet</TYPE>
+<CORRECTION>The engineering design process</CORRECTION>
+</MISTAKE>
+...
+</ANNOTATION>
+</DOC>
+<DOC nid="862">
+...
+```
+
+### Error categories in NUCLE release 2.0:
+
+| ERROR TAG | ERROR CATEGORY                                         |
+|-----------|---------------------------------------------------------|
+| Vt        | Verb tense |
+| Vm        | Verb modal |
+| V0        | Missing verb |
+| Vform     | Verb form |
+| SVA       | Subject–verb agreement |
+| ArtOrDet  | Article or Determiner |
+| Nn        | Noun number |
+| Npos      | Noun possessive |
+| Pform     | Pronoun form |
+| Pref      | Pronoun reference |
+| Wcip      | Wrong collocation/idiom/preposition |
+| Wa        | Acronyms |
+| Wform     | Word form |
+| Wtone     | Tone |
+| Srun      | Run-ons, comma splice |
+| Smod      | Dangling modifier |
+| Spar      | Parallelism |
+| Sfrag     | Fragment |
+| Ssub      | Subordinate clause |
+| WOinc     | Incorrect sentence form |
+| WOadv     | Adverb/adjective position |
+| Trans     | Link word/phrases |
+| Mec       | Punctuation, capitalization, spelling, typos |
+| Rloc      | Local redundancy |
+| Cit       | Citation |
+| Others    | Other errors |
+| Um        | Unclear meaning (cannot be corrected) |
+
+---
+
+## 3. Updates in Version 2.1
+
+The major change made in version 2.1 is to map the error categories `Wcip` and `Rloc` to `Prep`, `Wci`, `ArtOrDet`, and `Rloc-`.
+
+In the original NUCLE corpus, there is not an explicit preposition error category. Instead, preposition errors are part of the Wcip (Wrong collocation/idiom/preposition) and Rloc (local redundancy) error categories. In addition, redundant article or determiner errors are part of the Rloc error category.
+
+To facilitate the detection and correction of preposition errors and article/determiner errors, we perform mapping of error categories in the original NUCLE corpus. The mapping relies on POS tags, constituent parse trees, and error annotations at the token level.
+
+### (a) Conditions to change from the error category Wcip or Rloc to Prep:
+
+This applies to replacing a preposition by another preposition, or deleting a preposition. The string to be replaced is one word w with POS tag IN or TO, the parent of w is a PP in the constituent parse tree, and the replacement is either a preposition or the empty string.
+
+### (b) Conditions to change from the error category Wcip to Prep:
+
+This applies to inserting a preposition. The replacement is a preposition (one word only) and the immediately following word is tagged as VBG or is the first word of a noun phrase (NP).
+
+### (c) Conditions to change from the error category Rloc to ArtOrDet:
+
+The single word has POS tag DT and the replacement is the empty string.
+
+The remaining unaffected `Wcip` errors are assigned the new error category `Wci` and the remaining unaffected `Rloc` errors are assigned the new error category `Rloc-`.
+
+### List of 36 Prepositions:
+
+```
+about along among around as at beside besides between by down during except for from in inside into of off on onto outside over through to toward towards under underneath until up upon with within without
+```
+
+### Error categories in NUCLE release 2.1:
+
+| ERROR TAG | ERROR CATEGORY                         |
+|-----------|-----------------------------------------|
+| Vt        | Verb tense                              |
+| Vm        | Verb modal                              |
+| V0        | Missing verb                            |
+| Vform     | Verb form                               |
+| SVA       | Subject–verb agreement                  |
+| ArtOrDet  | Article or Determiner                   |
+| Nn        | Noun number                             |
+| Npos      | Noun possessive                         |
+| Pform     | Pronoun form                            |
+| Pref      | Pronoun reference                       |
+| Prep      | Preposition                             |
+| Wci       | Wrong collocation/idiom                 |
+| Wa        | Acronyms                                |
+| Wform     | Word form                               |
+| Wtone     | Tone                                    |
+| Srun      | Run-ons, comma splice                   |
+| Smod      | Dangling modifier                       |
+| Spar      | Parallelism                             |
+| Sfrag     | Fragment                                |
+| Ssub      | Subordinate clause                      |
+| WOinc     | Incorrect sentence form                 |
+| WOadv     | Adverb/adjective position               |
+| Trans     | Link word/phrases                       |
+| Mec       | Punctuation, capitalization, spelling, typos |
+| Rloc-     | Local redundancy                        |
+| Cit       | Citation                                |
+| Others    | Other errors                            |
+| Um        | Unclear meaning (cannot be corrected)   |
+
+
+---
+
+## 4. Updates included in version 2.2
+
+- Fixed the bug on expanding an error annotation involving part of a token to the full token.
+- Other miscellaneous corrections were made.
+
+---
+
+## 5. Updates included in version 2.3
+
+- Fixed the bug involving tokenization of punctuation symbols in the correction string.
+- Fixed the tokenization example in the README file of the M^2 scorer to reflect the real tokenization to be used and removed irrelevant codes from the scorer package.
+
+---
+
+## 6. Updates included in version 3.0
+
+- Resolved overlapping annotations in the NUCLE corpus to make them non-overlapping.
+- Corrected some minor mistakes in error annotations.
+
+---
+
+## 7. Updates included in version 3.1
+
+- Removed duplicate annotations in the NUCLE corpus with the same span and correction string but different error type so as to keep only one of those annotations. This fix only affects 0.1% of all annotations.
+- Fixed end-of-paragraph annotations so that the end offset of such annotations is the last character position in the paragraph. This fix only affects 0.7% of all annotations.
+- Corrected some minor mistakes in error annotations.
+- Inclusion of the CoNLL-2013 test data, with all the known problems described above fixed. Participating teams in the CoNLL-2014 shared task can make use of the CoNLL-2013 test data in training and developing their systems if they wish to do so.
+- Fixed a minor bug in the M2 scorer that caused duplicate insertion edits to receive high scores.
+
+---
+
+## 8. Updates included in version 3.2
+
+- Fixed the preprocessing script such that a gold edit that inserts an empty string is not included in the token-level gold edit and scorer answer files.
+- Removed one edit that inserted an empty string from the CoNLL-2014 test data. Also removed such instances from the NUCLE training data.
+- Fixed a bug in the M2 scorer arising from scoring against gold edits from multiple annotators. Specifically, the bug sometimes caused incorrect scores to be reported when scoring against the gold edits of subsequent annotators (other than the first annotator).
+- Fixed a bug in the M2 scorer that caused erroneous scores to be reported when dealing with insertion edits followed by deletion edits (or vice versa).
+
+---
+
+## 9. Updates included in version 3.3
+
+- Added a subdirectory "bea2019" to contain the ERRANT typed NUCLE M2 file for the BEA 2019 shared task on grammatical error correction.

bea2019/readme.txt

@@ -0,0 +1,9 @@
+This directory contains the official NUCLE training file used in the BEA2019 shared task.
+
+Specifically, nucle.train.gold.bea19.m2 is the same as the NUCLE M2 file used in the CoNLL2014 shared task, except the error types have been automatically standardised using the ERRANT framework: https://github.com/chrisjbryant/errant
+
+The official BEA19 file was generated using the following command in Python 3.5:
+
+python3 errant/m2_to_m2.py -gold <nucle.conll2014.m2> -out nucle.train.gold.bea19.m2
+
+This used spacy v1.9.0 and the en_core_web_sm-1.2.0 model.

data/nucle3.2.sgml

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8441a60060730bdc6af1e79a064c68441ecb24a66da91ea2aab0061a64a130ac
+size 12636154

scripts/README

@@ -0,0 +1,63 @@
+====================================================
+
+CoNLL-2014 Shared Task: Grammatical Error Correction
+
+Description of Data Preprocessing Scripts
+
+4 Aug 2014 Version 3.2
+====================================================
+
+
+Table of Contents
+=================
+
+  1. General
+  2. Pre-requisites
+  3. Usage
+
+1. General
+==========
+
+This README file describes the usage of scripts for preprocessing the NUCLE version 3.2 corpus.
+
+Quickstart:
+
+  a. Regenerate the preprocessed files with full syntactic information:
+     % python preprocess.py -o nucle.sgml conllFileName annFileName m2FileName
+
+  b. Get tokenized annotations without syntactic information:
+     % python preprocess.py -l nucle.sgml conllFileName annFileName m2FileName
+
+where
+       nucle.sgml  -  input SGML file
+    conllFileName  -  output file that contains pre-processed sentences in CoNLL format.
+      annFileName  -  output file that contains standoff error annotations.
+       m2FileName  -  output file that contains error annotations in the M2 scorer format.
+
+2. Pre-requisites
+=================
+
++ Python (2.6.4, other versions >= 2.6.4, < 3.0 might work but are not tested)
++ nltk (http://www.nltk.org, version 2.0b7, needed for sentence splitting and word tokenization)
++ Stanford parser (version 2.0.1, http://nlp.stanford.edu/software/stanford-parser-2012-03-09.tgz)
+
+If you only use the scripts to generate error annotations needed by the M2 scorer, Stanford parser is not required.
+Otherwise, "stanford-parser-2012-03-09" need to be in the same directory as "scripts".
+
+3. Usage
+========
+
+Preprocessing the data from single annotation
+
+Usage: python preprocess.py OPTIONS sgmlFileName conllFileName annotationFileName m2FileName
+
+Where
+  sgmlFileName       -     NUCLE SGML file
+  conllFileName      -     output file name for pre-processed sentences in CoNLL format (e.g., conll14st-preprocessed.conll).
+  annotationFileName -     output file name for error annotations (e.g., conll14st-preprocessed.conll.ann).
+  m2FileName         -     output file name in the M2 scorer format (e.g., conll14st-preprocessed.conll.m2).
+
+OPTIONS
+  -o      -   output will contain POS tags and parse tree info (i.e., the same as the released preprocessed file, runs slowly).
+  -l      -   output will NOT contain POS tags and parse tree info (runs quickly).
+

scripts/iparser.py

@@ -0,0 +1,36 @@
+# iparser.py
+#
+# Author:	Yuanbin Wu
+#           National University of Singapore (NUS)
+# Date:		12 Mar 2013
+# Version:      1.0
+# 
+# Contact:  wuyb@comp.nus.edu.sg
+#
+# This script is distributed to support the CoNLL-2013 Shared Task.
+# It is free for research and educational purposes.
+
+import os
+import sys
+
+class stanfordparser:
+
+    def __init__(self):
+        pass
+		
+    def parse_batch(self, sentenceDumpedFileName, parsingDumpedFileName):
+        
+        if os.path.exists('../stanford-parser-2012-03-09') == False:
+            print >> sys.stderr, 'can not find Stanford parser directory'
+            sys.exit(1)
+        
+        # tokenized
+        cmd = r'java -server -mx4096m -cp "../stanford-parser-2012-03-09/*:" edu.stanford.nlp.parser.lexparser.LexicalizedParser  -retainTMPSubcategories -sentences newline -tokenized -escaper edu.stanford.nlp.process.PTBEscapingProcessor  -outputFormat "wordsAndTags, penn, typedDependencies" -outputFormatOptions "basicDependencies" edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz ' + sentenceDumpedFileName
+
+        r = os.popen(cmd).read().strip().decode('utf-8')
+        f = open(parsingDumpedFileName, 'w')
+        f.write(r.encode('utf-8'))
+        f.close()
+
+        rlist = r.replace('\n\n\n', '\n\n\n\n').split('\n\n')
+        return rlist

scripts/nucle_doc.py

@@ -0,0 +1,188 @@
+# nucle_doc.py
+#
+# Author:	Yuanbin Wu
+#           National University of Singapore (NUS)
+# Date:		12 Mar 2013
+# Version:      1.0
+# 
+# Contact:  wuyb@comp.nus.edu.sg
+#
+# This script is distributed to support the CoNLL-2013 Shared Task.
+# It is free for research and educational purposes.
+
+import os
+import sys
+from nltk import word_tokenize
+
+class nucle_doc:
+    def __init__(self):
+        self.docattrs = None
+
+        self.matric = ''
+        self.email = ''
+        self.nationality = ''
+        self.firstLanguage = ''
+        self.schoolLanguage = ''
+        self.englishTests = ''
+
+        self.paragraphs = []
+        self.annotation = []
+        self.mistakes = []
+
+        self.sentences = []
+
+    def buildSentence(self, sentstr, dpnode, constituentstr, poslist, chunklist):
+        self.sentences[-1].append(nucle_sent(sentstr, dpnode, constituentstr, poslist, chunklist))
+
+    def addSentence(self, sent):
+        self.sentences[-1].append(sent)
+
+    def findMistake(self, par, pos):
+        for m in self.mistakes:
+            if par == m['start_par'] and pos >= m['start_off'] and pos < m['end_off']:
+                return m
+        return None
+
+
+class nucle_sent:
+    def __init__(self, sentstr, dpnode, constituentstr, poslist, chunklist):
+        self.sentstr = sentstr
+        self.words = word_tokenize(sentstr)
+        self.dpnodes = dpnode
+        self.constituentstr = constituentstr
+        self.constituentlist = []
+        self.poslist = poslist
+        self.chunklist = chunklist
+
+    def buildConstituentList(self):
+
+        s = self.constituentstr.strip().replace('\n', '').replace(' ', '')
+        r = []
+        i = 0
+        while i < len(s):
+            j = i
+            while j < len(s) and s[j] != ')':
+                j += 1
+            k = j
+            while k < len(s) and s[k] == ')':
+                k += 1
+            
+            nodeWholeStr = s[i:k]
+            lastLRBIndex = nodeWholeStr.rfind('(')
+            nodeStr = nodeWholeStr[:lastLRBIndex] + '*' + s[j+1:k]
+
+            r.append(nodeStr)
+            i = k
+
+        if len(r) != len(self.words):
+            print >> sys.stderr, 'Error in buiding constituent tree bits: different length with words.'
+            print >> sys.stderr, len(r), len(self.words)
+            print >> sys.stderr, ' '.join(r).encode('utf-8')
+            print >> sys.stderr, words
+            sys.exit(1)
+
+        self.constituentlist = r
+
+
+    
+    def setDpNode(self, dpnode):
+        self.dpnodes = dpnode
+
+    def setPOSList(self, poslist):
+        self.poslist = poslist
+
+    def setConstituentStr(self, constituentstr):
+        self.constituentstr = constituentstr
+
+    def setConstituentList(self, constituentlist):
+        self.constituentlist = constituentlist
+
+    def setWords(self, words):
+        self.words = words
+
+    def setChunkList(self, chunklist):
+        self.chunklist = chunklist
+
+    def getDpNode(self):
+        return self.dpnodes
+
+    def getPOSList(self):
+        return self.poslist
+
+    def getConstituentStr(self):
+        return self.constituentstr
+
+    def getConstituentList(self):
+        return self.constituentlist 
+
+    def getWords(self):
+        return self.words
+    
+    def getChunkList(self):
+        return self.chunklist
+
+    def getConllFormat(self, doc, paragraphIndex, sentIndex):
+
+        table = []
+
+        dpnodes = self.getDpNode()
+        poslist = self.getPOSList()
+        #chunklist = self.getChunkList()
+        words = self.getWords()
+        constituentlist = self.getConstituentList()
+
+        if len(poslist) == 0:
+            hasParseInfo = 0
+        else:
+            hasParseInfo = 1
+
+        if len(words) != len(poslist) and len(poslist) != 0:
+            print >> sys.stderr, 'Error in buiding Conll Format: different length stanford parser postags and words.'
+            print >> sys.stderr, 'len words:', len(words), words
+            print >> sys.stderr, 'len poslist:', len(poslist), poslist
+            sys.exit(1)
+
+        for wdindex in xrange(len(words)):
+
+            word = words[wdindex]
+
+            row = []
+            row.append(doc.docattrs[0][1])        #docinfo
+            row.append(paragraphIndex)          #paragraph index
+            row.append(sentIndex)           #paragraph index
+            row.append(wdindex)             #word index
+            row.append(word)                #word
+
+            #row.append(chunknode.label)     #chunk
+            if hasParseInfo == 1:
+
+                posword = poslist[wdindex]
+                splitp = posword.rfind('/')
+                pos = posword[splitp+1 : ].strip()
+
+                #chunknode = chunklist[wdindex]
+
+                constituentnode = constituentlist[wdindex]
+                
+                dpnode = None
+                for d in dpnodes:
+                    if d.index == wdindex:
+                        dpnode = d
+                        break
+
+                row.append(pos)                 #POS
+                if dpnode == None:
+                    row.append('-')
+                    row.append('-')
+                else:
+                    row.append(dpnode.parent_index) #dp parent
+                    row.append(dpnode.grammarrole)  #dp label
+                row.append(constituentnode)         #constituent 
+
+            table.append(row)
+
+        return table
+
+
+
+

scripts/nuclesgmlparser.py

@@ -0,0 +1,168 @@
+# nuclesgmlparser.py
+#
+# Author:	Yuanbin Wu
+#           National University of Singapore (NUS)
+# Date:		12 Mar 2013
+# Version:      1.0
+# 
+# Contact:  wuyb@comp.nus.edu.sg
+#
+# This script is distributed to support the CoNLL-2013 Shared Task.
+# It is free for research and educational purposes.
+
+from sgmllib import SGMLParser
+from nucle_doc import nucle_doc
+
+
+class nuclesgmlparser(SGMLParser):
+    def __init__(self):
+        SGMLParser.__init__(self)
+        self.docs = []
+
+    def reset(self):
+        self.docs = []
+        self.data = []
+        SGMLParser.reset(self)
+
+    def unknow_starttag(self, tag, attrs):
+        pass
+
+    def unknow_endtag(self):
+        pass
+
+    def start_doc(self, attrs):
+        self.docs.append(nucle_doc())
+        self.docs[-1].docattrs = attrs
+
+    def end_doc(self):
+        pass
+
+    def start_matric(self, attrs):
+        pass
+
+    def end_matric(self):
+        self.docs[-1].matric = ''.join(self.data)
+        self.data = []
+        pass
+
+    def start_email(self, attrs):
+        pass
+
+    def end_email(self):
+        self.docs[-1].email = ''.join(self.data)
+        self.data = []
+        pass
+
+    def start_nationality(self, attrs):
+        pass
+
+    def end_nationality(self):
+        self.docs[-1].nationality = ''.join(self.data)
+        self.data = []
+        pass
+
+    def start_first_language(self, attrs):
+        pass
+
+    def end_first_language(self):
+        self.docs[-1].firstLanguage = ''.join(self.data)
+        self.data = []
+        pass
+
+    def start_school_language(self, attrs):
+        pass
+
+    def end_school_language(self):
+        self.docs[-1].schoolLanguage = ''.join(self.data)
+        self.data = []
+        pass
+
+    def start_english_tests(self, attrs):
+        pass
+
+    def end_english_tests(self):
+        self.docs[-1].englishTests = ''.join(self.data)
+        self.data = []
+        pass
+
+
+    def start_text(self, attrs):
+        pass
+    
+    def end_text(self):
+        pass
+
+    def start_title(self, attrs):
+        pass
+
+    def end_title(self):
+        self.docs[-1].paragraphs.append(''.join(self.data))
+        self.data = []
+        pass
+
+
+    def start_p(self, attrs):
+        pass
+
+    def end_p(self):
+        self.docs[-1].paragraphs.append(''.join(self.data))
+        self.data = []
+        pass
+
+
+    def start_annotation(self, attrs):
+        self.docs[-1].annotation.append(attrs)
+
+    def end_annotation(self):
+        pass
+
+    def start_mistake(self, attrs):
+        d = {}
+        for t in attrs:
+            d[t[0]] = int(t[1])
+        self.docs[-1].mistakes.append(d)
+        pass 
+
+    def end_mistake(self):
+        pass 
+
+    def start_type(self, attrs):
+        pass
+
+    def end_type(self):
+        self.docs[-1].mistakes[-1]['type'] = ''.join(self.data)
+        self.data = []
+
+    def start_correction(self, attrs):
+        pass
+
+    def end_correction(self):
+        self.docs[-1].mistakes[-1]['correction'] = ''.join(self.data)
+        self.data = []
+
+    def start_comment(self, attrs):
+        pass
+
+    def end_comment(self):
+        self.docs[-1].mistakes[-1]['comment'] = ''.join( self.data)
+        self.data = []
+
+
+    def handle_charref(self, ref):
+        self.data.append('&' + ref)
+
+    def handle_entityref(self, ref):
+        self.data.append('&' + ref)
+
+    def handle_data(self, text):
+        if  text.strip() == '':
+            self.data.append('')
+            return
+        else:
+            if text.startswith('\n'):
+                text = text[1:]
+            if text.endswith('\n'):
+                text = text[:-1]
+            self.data.append(text)
+
+

scripts/parser_feature.py

@@ -0,0 +1,80 @@
+# parser_feature.py
+#
+# Author:	Yuanbin Wu
+#           National University of Singapore (NUS)
+# Date:		12 Mar 2013
+# Version:      1.0
+# 
+# Contact:  wuyb@comp.nus.edu.sg
+#
+# This script is distributed to support the CoNLL-2013 Shared Task.
+# It is free for research and educational purposes.
+
+
+
+import iparser
+
+class stanpartreenode:
+    def __init__(self, strnode):
+
+        if strnode == '':
+            self.grammarrole = ''
+            self.parent_index = -1
+            self.index = -1
+            self.parent_word = ''
+            self.word = ''
+            self.POS = ''
+            return
+
+        groleend = strnode.find('(')
+        self.grammarrole = strnode[ : groleend]
+        content = strnode[groleend + 1: len(strnode)-1]
+        dadAndme = content.partition(', ')
+        dad = dadAndme[0]
+        me = dadAndme[2]
+        dadsep = dad.rfind('-')
+        mesep = me.rfind('-')
+        self.parent_index = int(dad[dadsep + 1 : ]) - 1 
+        self.parent_word = dad[0 : dadsep]
+        self.index = int(me[mesep + 1 : ]) - 1
+        self.word = me[0 : mesep]
+        self.POS = '' 
+
+        
+def DependTree_Batch(sentenceDumpedFileName, parsingDumpedFileName):
+
+    sparser = iparser.stanfordparser()
+    results = sparser.parse_batch(sentenceDumpedFileName, parsingDumpedFileName)
+    nodeslist = []
+
+    k = 0
+    while k < len(results):
+        PoSlist = results[k].split(' ')
+        constituentstr = results[k+1]
+        table = results[k+2].split('\n')
+        nodes = []
+        for i in range(0, len(table)):
+            nodes.append( stanpartreenode(table[i]) )
+        nodeslist.append((nodes, constituentstr, PoSlist))
+        k += 3
+    return nodeslist
+
+def DependTree_Batch_Parsefile(parsingDumpedFileName):
+
+    f = open(parsingDumpedFileName, 'r')
+    results = f.read().decode('utf-8').replace('\n\n\n', '\n\n\n\n').split('\n\n')
+    f.close()
+    nodeslist = []
+
+    k = 0
+    while k < len(results):
+        PoSlist = results[k].split(' ')
+        constituentstr = results[k+1]
+        table = results[k+2].split('\n')
+
+        nodes = []
+        for i in range(0, len(table)):
+            nodes.append( stanpartreenode(table[i]) )
+        nodeslist.append((nodes, constituentstr, PoSlist))
+        k += 3
+    return nodeslist

scripts/preprocess.py

@@ -0,0 +1,509 @@
+#!/usr/bin/python
+
+# preprocess.py
+#
+# Author:	Yuanbin Wu
+#           National University of Singapore (NUS)
+# Date:		12 Mar 2013
+# Version:      1.0
+# 
+# Contact:  wuyb@comp.nus.edu.sg
+#
+# This script is distributed to support the CoNLL-2013 Shared Task.
+# It is free for research and educational purposes.
+#
+# Usage:   python preprocess.py OPTIONS sgmlFileName conllFileName annotationFileName m2FileName
+# Options:
+#         -o    generate conllFile, annotationFile, m2File from sgmlFile, with parser info. 
+#         -l    generate conllFile, annotationFile, m2File from sgmlFile, without parser info.
+
+
+import parser_feature
+from nuclesgmlparser import nuclesgmlparser
+from nucle_doc import *
+import nltk.data
+from nltk import word_tokenize
+import cPickle as pickle
+import re
+import sys
+import os
+import getopt
+
+class PreProcessor:
+
+    def __init__(self):
+
+        self.sentenceTokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
+        self.sentenceDumpedFile = 'sentence_file'
+        self.docsDumpedFileName = 'docs'
+        self.parsingDumpedFileName = 'parse_file'
+
+    def readNUCLE(self, fn):
+
+        f = open(fn, 'r')
+        parser = nuclesgmlparser()
+        filestr = f.read()
+        filestr = filestr.decode('utf-8')
+        
+        #Fix Reference tag
+        p = re.compile(r'(<REFERENCE>\n<P>\n.*\n)<P>')
+        filestr = p.sub(r'\1</P>', filestr)
+
+        parser.feed(filestr)
+        f.close()
+        parser.close()
+
+        return parser.docs
+
+
+    def sentenceSplit(self, docs):
+
+        for doc in docs:
+            for par in doc.paragraphs:
+                doc.sentences.append([])
+                for s in self.sentenceTokenizer.tokenize(par):
+                    doc.buildSentence(s, [], '', [], [])
+        return docs
+ 
+
+    def featureGeneration(self, docs, option):
+
+        # build parsing feature
+        # the sentence for parsing is dump to self.sentenceDumpedFile
+        f = open(self.sentenceDumpedFile, 'w')
+
+        for doc in docs:
+            for par in doc.paragraphs:
+                doc.sentences.append([])
+                for s in self.sentenceTokenizer.tokenize(par):
+                    sent = nucle_sent(s, [], '', [], [])
+                    doc.addSentence(sent)
+                    tokenizedSentStr = ' '.join(sent.getWords()) + '\n'
+
+                    f.write(tokenizedSentStr.encode('utf-8'))
+        f.close()
+
+        if option == 0:
+            nodelist = parser_feature.DependTree_Batch(self.sentenceDumpedFile, self.parsingDumpedFileName)
+        elif option == 1 :
+            nodelist = parser_feature.DependTree_Batch_Parsefile(self.parsingDumpedFileName)
+        else:
+            return
+
+        i = 0
+        for doc in docs:
+            for slist in doc.sentences:
+                for s in slist:
+                    if s.sentstr.strip() == '':
+                        continue
+
+                    s.setDpNode(nodelist[i][0])
+                    s.setConstituentStr(nodelist[i][1])
+                    s.setPOSList(nodelist[i][2])
+                    s.buildConstituentList()
+
+                    i += 1
+
+        f = file(self.docsDumpedFileName,'w')
+        pickle.dump(docs, f)
+        f.close()
+        return docs
+
+
+    def conllFileGeneration(self, docs, conllFileName, annotationFileName, m2FileName):
+        
+        fcolumn = open(conllFileName, 'w')
+        fannotation = open(annotationFileName, 'w')
+        fm2 = open(m2FileName, 'w')
+
+        for doc in docs:
+            for slistIndex in xrange(len(doc.sentences)):
+                slist = doc.sentences[slistIndex]
+                for sentid in xrange(len(slist)):
+
+                    sent = slist[sentid]
+
+                    # annotation string list
+                    annotationList = []
+
+                    # m2 format annotation string list
+                    m2AnnotationList = []
+
+                    # build colums
+                    table = sent.getConllFormat(doc, slistIndex, sentid)
+                    tokenizedSentStr = ' '.join(sent.getWords())
+
+                    #Add annotation info
+                    sentoffset = doc.paragraphs[slistIndex].index(sent.sentstr)
+                    for m in doc.mistakes:
+
+                        if m['start_par'] != slistIndex or \
+                           m['start_par'] != m['end_par'] or \
+                           m['start_off'] < sentoffset or \
+                           m['start_off'] >= sentoffset + len(sent.sentstr) or \
+                           m['end_off'] <sentoffset or \
+                           m['end_off'] > sentoffset + len(sent.sentstr):
+                            continue
+
+                        wordsoffset = 0
+                        wdstart = 0
+
+                        startInWord = 0
+                        headText = ''
+                        endInWord = 0
+                        tailText = ''
+
+                        words = sent.getWords()
+                        while wdstart < len(words):
+
+                            word = words[wdstart]
+                            nextstart = sent.sentstr.find(word, wordsoffset)
+
+                            if nextstart == -1:
+                                # may not find word, due to relpacement
+                                print >> sys.stderr, "Warning in building conll format: can not find word"
+                                print >> sys.stderr, word.encode('utf-8')
+                                wordsoffset += 1
+                            else:
+                                wordsoffset = nextstart
+
+                            if wordsoffset >= m['start_off']-sentoffset:
+                                break
+                            elif wordsoffset + len(word) > m['start_off']-sentoffset:
+                                # annotation starts at the middle of a word
+                                startInWord = 1
+                                headText = sent.sentstr[wordsoffset: m['start_off']-sentoffset]
+                                break
+
+                            wordsoffset += len(word) 
+                            wdstart += 1
+
+                        if wdstart == len(words):
+                            print >> sys.stderr, 'Warning in building conll format: start_off overflow'
+                            print >> sys.stderr, m, sent.sentstr.encode('utf-8')
+                            continue
+
+
+                        wdend = wdstart
+                        while wdend < len(words):
+
+                            word = words[wdend]
+                            
+                            nextstart = sent.sentstr.find(word, wordsoffset)
+
+                            if nextstart == -1:
+                                print >> sys.stderr, "Warning in building conll format: can not find word"
+                                print >> sys.stderr, word.encode('utf-8')
+                                wordsoffset += 1
+                            else:
+                                wordsoffset = nextstart
+
+                            if wordsoffset >= m['end_off']-sentoffset:
+                                # annotation ends at the middle of a word
+                                if wordsoffset - len(words[wdend-1]) - 1 < m['end_off']-sentoffset: 
+                                    endInWord = 1
+                                    tailText = sent.sentstr[m['end_off']-sentoffset : wordsoffset].strip()
+                                break
+
+                            wordsoffset += len(word) 
+                            wdend += 1
+                       
+
+                        correctionTokenizedStr = self.tokenizeCorrectionStr(headText + m['correction'] + tailText, wdstart, wdend, words)
+                        
+                        #Shrink the correction string, wdstart, wdend
+                        correctionTokenizedStr, wdstart, wdend = self.shrinkCorrectionStr(correctionTokenizedStr, wdstart, wdend, words)
+                        if wdstart == wdend and len(correctionTokenizedStr) == 0:
+                            continue
+
+                        # build annotation string for .conll.ann file
+                        annotationStr  = '<MISTAKE '
+                        annotationStr += 'nid="' + table[0][0] + '" '          #nid
+                        annotationStr += 'pid="' + str(table[0][1]) + '" '       #start_par
+                        annotationStr += 'sid="' + str(sentid) + '" '                   #sentence id
+                        annotationStr += 'start_token="' + str(wdstart) + '" '          #start_token
+                        annotationStr += 'end_token="' + str(wdend) + '">\n'            #end_token
+                        annotationStr += '<TYPE>' + m['type'] + '</TYPE>\n'
+                        annotationStr += '<CORRECTION>' + correctionTokenizedStr + '</CORRECTION>\n'
+                        annotationStr += '</MISTAKE>\n'
+
+                        annotationList.append(annotationStr)
+
+                        # build annotation string for .conll.m2 file
+                        m2AnnotationStr  = 'A '
+                        m2AnnotationStr +=  str(wdstart) + ' '
+                        m2AnnotationStr +=  str(wdend) + '|||'
+                        m2AnnotationStr +=  m['type'] + '|||'
+                        m2AnnotationStr +=  correctionTokenizedStr.replace('\n', '')  + '|||'
+                        m2AnnotationStr +=  'REQUIRED|||-NONE-|||0\n'
+
+                        m2AnnotationList.append(m2AnnotationStr)
+
+
+
+                    # write .conll file
+                    for row in table:
+                        output = ''
+                        for record in row:
+                            if type(record) == type(1):
+                                output = output + str(record) + '\t'
+                            else:
+                                output = output + record + '\t'
+                        fcolumn.write((output.strip() + '\n').encode('utf-8'))
+                    fcolumn.write(('\n').encode('utf-8'))
+
+                    # write .conll.ann file
+                    if len(annotationList) != 0:
+                        annotationSent = '<ANNOTATION>\n' + ''.join(annotationList) + '</ANNOTATION>\n'
+                        fannotation.write((annotationSent + '\n').encode('utf-8'))
+
+                    # write .conll.m2 file
+                    m2AnnotationSent = 'S ' + tokenizedSentStr + '\n'
+                    m2AnnotationSent += ''.join(m2AnnotationList) + '\n'
+                    fm2.write(m2AnnotationSent.encode('utf-8'))
+                    
+        fcolumn.close()
+        fannotation.close()
+        fm2.close()
+
+
+    def tokenizeCorrectionStr(self, correctionStr, wdstart, wdend, words):
+
+        correctionTokenizedStr = ''
+        pseudoSent = correctionStr
+
+        if wdstart != 0:
+            pseudoSent = words[wdstart-1] + ' ' + pseudoSent 
+
+        if wdend < len(words) - 1:
+            pseudoSent = pseudoSent + ' ' + words[wdend]
+        elif wdend == len(words) - 1:
+            pseudoSent = pseudoSent + words[wdend]
+
+
+        pseudoWordsList = []
+        sentList = self.sentenceTokenizer.tokenize(pseudoSent)
+        for sent in sentList:
+            pseudoWordsList += word_tokenize(sent)
+
+        start = 0
+        if wdstart != 0:
+            s = ''
+            for i in xrange(len(pseudoWordsList)):
+                s += pseudoWordsList[i]
+                if s == words[wdstart-1]:
+                    start = i + 1
+                    break
+            if start == 0:
+                print >> sys.stderr, 'Can not find words[wdstart-1]'
+ 
+        else:
+            start = 0
+
+        end = len(pseudoWordsList)
+        if wdend != len(words):
+
+            s = ''
+            for i in xrange(len(pseudoWordsList)):
+                s = pseudoWordsList[len(pseudoWordsList) - i - 1] + s
+                if s == words[wdend]:
+                    end = len(pseudoWordsList) - i - 1
+                    break
+            if end == len(pseudoWordsList):
+                print >> sys.stderr, 'Can not find words[wdend]'
+
+        else:
+            end = len(pseudoWordsList)
+
+        correctionTokenizedStr = ' '.join(pseudoWordsList[start:end])
+
+        return correctionTokenizedStr
+
+
+    def shrinkCorrectionStr(self, correctionTokenizedStr, wdstart, wdend, words):
+
+        correctionWords = correctionTokenizedStr.split(' ')
+        originalWords = words[wdstart: wdend]
+        wdstartNew = wdstart
+        wdendNew = wdend
+        cstart = 0
+        cend = len(correctionWords)
+
+        i = 0
+        while i < len(originalWords) and i < len(correctionWords):
+            if correctionWords[i] == originalWords[i]:
+                i += 1
+                wdstartNew = i + wdstart
+                cstart = i
+            else:
+                break
+
+        i = 1
+        while i <= len(originalWords) - cstart and i <= len(correctionWords) - cstart:
+            if correctionWords[len(correctionWords)-i] == originalWords[len(originalWords)-i]:
+                wdendNew = wdend - i
+                cend = len(correctionWords) - i
+                i += 1
+            else:
+                break
+
+        return ' '.join(correctionWords[cstart:cend]), wdstartNew, wdendNew
+
+
+        
+
+def usage_debug():
+
+    u = '\nUsage: python preprocess.py options \n\n'
+    u += '-g sgmlFileName -d useDumpedFile\n'
+    u += '   generate sentence features and dump the results \n'
+    u += '   sgmlFileName: the nucle sgml files \n'
+    u += '   useDumpedFile = 0, don\'t use dumped files, will parse nucle sgml file (Default) \n'
+    u += '   useDumpedFile = 1, reuse previous dumped parse files \n\n'
+    u += '-c conllFileName annotationFileName m2FileName \n' 
+    u += '   generate conllFile, annotationFile, m2File \n\n'
+    u += '-l sgmlFileName conllFileName annotationFileName m2FileName \n' 
+    u += '   generate conllFile, annotationFile, m2FileName from sgmlFile, without parser info.\n'
+    print u
+
+def usage_release():
+    u = '\nUsage: python preprocess.py OPTIONS sgmlFileName conllFileName annotationFileName m2FileName \n\n'
+    u += '-o    generate conllFile, annotationFile, m2File from sgmlFile, with parser info.\n' 
+    u += '-l    generate conllFile, annotationFile, m2File from sgmlFile, without parser info.\n'   
+    print u
+
+
+
+if __name__ == '__main__':
+
+    ppr = PreProcessor()
+    debug = False
+    try:
+        if debug == True:
+            opts, args = getopt.getopt(sys.argv[1:],'g:d:c:l:h')
+        else:
+            opts, args = getopt.getopt(sys.argv[1:],'l:o:h')
+    except getopt.GetoptError:
+
+        if debug == True:
+            usage_debug()
+        else: 
+            usage_release()
+        sys.exit(2)
+   
+    option = {}
+    option['-g'] = 0
+    option['-c'] = 0
+    option['-l'] = 0
+    option['-o'] = 0
+    option['useDumpedFile'] = 0
+    option['sgmlFileName'] = None
+    option['conllFileName'] = None
+    option['annotationFileName'] = None
+    option['m2FileName'] = None
+
+
+    for opt, arg in opts:
+        if opt == '-g':
+            if os.path.isfile(arg) == False:
+                print >> sys.stderr, 'can not find sgml file'
+                sys.exit(2)
+            else:
+                option['sgmlFileName'] = arg
+                option['-g'] = 1
+
+        elif opt == '-d':
+            if arg not in ('1', '0'):
+                print >> sys.stderr, '-d option should be 0 or 1'
+                sys.exit(2)
+            else:
+                option['useDumpedFile'] = int(arg)
+
+        elif opt == '-c':
+            if len(args) != 2:
+                print >> sys.stderr, '-c option need 3 args'
+                sys.exit(2)
+            else:
+                option['conllFileName'] = arg
+                option['annotationFileName'] = args[0]
+                option['m2FileName'] = args[1]
+                option['-c'] = 1
+
+        elif opt == '-l':
+            if len(args) != 3:
+                print >> sys.stderr, '-l option need 4 args'
+                sys.exit(2)
+            else:
+                if os.path.isfile(arg) == False:
+                    print >> sys.stderr, 'can not find sgml file'
+                    sys.exit(2)
+                else:
+                    option['sgmlFileName'] = arg
+
+                option['conllFileName'] = args[0]
+                option['annotationFileName'] = args[1]
+                option['m2FileName'] = args[2]
+                option['-l'] = 1
+
+
+        elif opt == '-o':
+            if len(args) != 3:
+                print >> sys.stderr, '-o option need 4 args'
+                sys.exit(2)
+            else:
+                if os.path.isfile(arg) == False:
+                    print >> sys.stderr, 'can not find sgml file'
+                    sys.exit(2)
+                else:
+                    option['sgmlFileName'] = arg
+
+                option['conllFileName'] = args[0]
+                option['annotationFileName'] = args[1]
+                option['m2FileName'] = args[2]
+                option['useDumpedFile'] = 0
+                option['-o'] = 1
+
+        elif opt == '-h':
+            if debug == True:
+                usage_debug()
+            else:
+                usage_release()
+            sys.exit()
+
+
+    if option['-g'] + option['-c'] + option['-l'] + option['-o']  > 1:
+        print >> sys.stderr, 'only one option among -g, -c, -l, -o is allowed'
+        sys.exit(2)
+    elif option['-g'] + option['-c'] + option['-l'] + option['-o'] == 0:
+        print >> sys.stderr, 'no option given'
+        sys.exit(2)
+    
+           
+    if option['-g'] == 1:
+        docs = ppr.readNUCLE(option['sgmlFileName'])
+        ppr.featureGeneration(docs, option['useDumpedFile'])
+
+    elif option['-c']  == 1:
+        if os.path.isfile(ppr.docsDumpedFileName) == False:
+            print >> sys.stderr, '-c option needs dumped \'docs\' file. Please use -g option first. '
+            sys.exit(2)
+        f = file(ppr.docsDumpedFileName, 'r')
+        docs = pickle.load(f)
+        f.close()
+
+        ppr.conllFileGeneration(docs, option['conllFileName'], option['annotationFileName'], option['m2FileName'])
+
+    elif option['-l'] == 1:
+        docs = ppr.sentenceSplit(ppr.readNUCLE(option['sgmlFileName']))
+        ppr.conllFileGeneration(docs, option['conllFileName'], option['annotationFileName'], option['m2FileName'])
+
+    elif option['-o'] == 1:
+
+        docs = ppr.readNUCLE(option['sgmlFileName'])
+        docs = ppr.featureGeneration(docs, 0)
+        ppr.conllFileGeneration(docs, option['conllFileName'], option['annotationFileName'], option['m2FileName'])
+
+        os.remove(ppr.sentenceDumpedFile)
+        os.remove(ppr.docsDumpedFileName)
+        os.remove(ppr.parsingDumpedFileName)
+