Upstream/2 write a predictor class to mimic the gec model

.github/workflows/python-test.yml

@@ -0,0 +1,36 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Python test
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8"]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e .
+    - name: Unit Testing
+      run: |
+        pytest -v tests
+    - name: Regression Testing
+      run: |
+        python regression_tests/test_gector_roberta.py
+        python regression_tests/test_regression_data_predictor.py

.gitignore

@@ -132,4 +132,7 @@ dmypy.json
 # PyCharm
 .idea
 
-*.sh
+*.sh
+
+# pytorch weights files
+*.th

README.md

@@ -9,10 +9,16 @@ This repository provides code for training and testing state-of-the-art models f
 It is mainly based on `AllenNLP` and `transformers`.
 ## Installation
 The following command installs all necessary packages:
-```.bash
-pip install -r requirements.txt
+```bash
+conda create --name <Environment_name> python=3.8
+conda activate <Environment_name> 
+pip install -e .
 ```
-The project was tested using Python 3.7.
+The project was tested using Python 3.8.
+
+## Unit tests
+After activating the conda environment, simply run the code below: 
+`pytest -v tests`
 
 ## Datasets
 All the public GEC datasets used in the paper can be downloaded from [here](https://www.cl.cam.ac.uk/research/nl/bea2019st/#data).<br>

environment.yml

@@ -0,0 +1,13 @@
+name: gector
+dependencies:
+  - python=3.8
+  - pytorch=1.10.0
+  - python-Levenshtein
+  - transformers
+  - scikit-learn
+  - sentencepiece
+  - overrides=4.1.2
+  - numpy
+  - pip:
+    - allennlp==0.9.0
+

gector/bert_token_embedder.py

@@ -221,7 +221,7 @@ def forward(
             return util.uncombine_initial_dims(selected_embeddings, offsets.size())
 
 
-# @TokenEmbedder.register("bert-pretrained")
+@TokenEmbedder.register("gec-bert-pretrained")
 class PretrainedBertEmbedder(BertEmbedder):
 
     """

gector/datareader.py

@@ -6,7 +6,12 @@
 
 from allennlp.common.file_utils import cached_path
 from allennlp.data.dataset_readers.dataset_reader import DatasetReader
-from allennlp.data.fields import TextField, SequenceLabelField, MetadataField, Field
+from allennlp.data.fields import (
+    TextField,
+    SequenceLabelField,
+    MetadataField,
+    Field,
+)
 from allennlp.data.instance import Instance
 from allennlp.data.token_indexers import TokenIndexer, SingleIdTokenIndexer
 from allennlp.data.tokenizers import Token
@@ -37,23 +42,28 @@ class Seq2LabelsDatasetReader(DatasetReader):
         are pre-tokenised in the data file.
     max_len: if set than will truncate long sentences
     """
+
     # fix broken sentences mostly in Lang8
-    BROKEN_SENTENCES_REGEXP = re.compile(r'\.[a-zA-RT-Z]')
-
-    def __init__(self,
-                 token_indexers: Dict[str, TokenIndexer] = None,
-                 delimeters: dict = SEQ_DELIMETERS,
-                 skip_correct: bool = False,
-                 skip_complex: int = 0,
-                 lazy: bool = False,
-                 max_len: int = None,
-                 test_mode: bool = False,
-                 tag_strategy: str = "keep_one",
-                 tn_prob: float = 0,
-                 tp_prob: float = 0,
-                 broken_dot_strategy: str = "keep") -> None:
+    BROKEN_SENTENCES_REGEXP = re.compile(r"\.[a-zA-RT-Z]")
+
+    def __init__(
+        self,
+        token_indexers: Dict[str, TokenIndexer] = None,
+        delimeters: dict = SEQ_DELIMETERS,
+        skip_correct: bool = False,
+        skip_complex: int = 0,
+        lazy: bool = False,
+        max_len: int = None,
+        test_mode: bool = False,
+        tag_strategy: str = "keep_one",
+        tn_prob: float = 0,
+        tp_prob: float = 0,
+        broken_dot_strategy: str = "keep",
+    ) -> None:
         super().__init__(lazy)
-        self._token_indexers = token_indexers or {'tokens': SingleIdTokenIndexer()}
+        self._token_indexers = token_indexers or {
+            "tokens": SingleIdTokenIndexer()
+        }
         self._delimeters = delimeters
         self._max_len = max_len
         self._skip_correct = skip_correct
@@ -69,16 +79,23 @@ def _read(self, file_path):
         # if `file_path` is a URL, redirect to the cache
         file_path = cached_path(file_path)
         with open(file_path, "r") as data_file:
-            logger.info("Reading instances from lines in file at: %s", file_path)
+            logger.info(
+                "Reading instances from lines in file at: %s", file_path
+            )
             for line in data_file:
                 line = line.strip("\n")
                 # skip blank and broken lines
-                if not line or (not self._test_mode and self._broken_dot_strategy == 'skip'
-                                and self.BROKEN_SENTENCES_REGEXP.search(line) is not None):
+                if not line or (
+                    not self._test_mode
+                    and self._broken_dot_strategy == "skip"
+                    and self.BROKEN_SENTENCES_REGEXP.search(line) is not None
+                ):
                     continue
 
-                tokens_and_tags = [pair.rsplit(self._delimeters['labels'], 1)
-                                   for pair in line.split(self._delimeters['tokens'])]
+                tokens_and_tags = [
+                    pair.rsplit(self._delimeters["labels"], 1)
+                    for pair in line.split(self._delimeters["tokens"])
+                ]
                 try:
                     tokens = [Token(token) for token, tag in tokens_and_tags]
                     tags = [tag for token, tag in tokens_and_tags]
@@ -91,14 +108,14 @@ def _read(self, file_path):
 
                 words = [x.text for x in tokens]
                 if self._max_len is not None:
-                    tokens = tokens[:self._max_len]
-                    tags = None if tags is None else tags[:self._max_len]
+                    tokens = tokens[: self._max_len]
+                    tags = None if tags is None else tags[: self._max_len]
                 instance = self.text_to_instance(tokens, tags, words)
                 if instance:
                     yield instance
 
     def extract_tags(self, tags: List[str]):
-        op_del = self._delimeters['operations']
+        op_del = self._delimeters["operations"]
 
         labels = [x.split(op_del) for x in tags]
 
@@ -117,18 +134,28 @@ def extract_tags(self, tags: List[str]):
         else:
             raise Exception("Incorrect tag strategy")
 
-        detect_tags = ["CORRECT" if label == "$KEEP" else "INCORRECT" for label in labels]
+        detect_tags = [
+            "CORRECT" if label == "$KEEP" else "INCORRECT" for label in labels
+        ]
         return labels, detect_tags, comlex_flag_dict
 
-    def text_to_instance(self, tokens: List[Token], tags: List[str] = None,
-                         words: List[str] = None) -> Instance:  # type: ignore
+    def text_to_instance(
+        self,
+        tokens: List[Token],
+        tags: List[str] = None,
+        words: List[str] = None,
+    ) -> Instance:  # type: ignore
         """
         We take `pre-tokenized` input here, because we don't have a tokenizer in this class.
         """
         # pylint: disable=arguments-differ
         fields: Dict[str, Field] = {}
-        sequence = TextField(tokens, self._token_indexers)
+        # Set size of tokens to _max_len + 1 since $START token is being added
+        sequence = TextField(tokens[: self._max_len + 1], self._token_indexers)
         fields["tokens"] = sequence
+        # If words has not been explicitly passed in, create it from tokens.
+        if words is None:
+            words = [token.text for token in tokens]
         fields["metadata"] = MetadataField({"words": words})
         if tags is not None:
             labels, detect_tags, complex_flag_dict = self.extract_tags(tags)
@@ -144,8 +171,10 @@ def text_to_instance(self, tokens: List[Token], tags: List[str] = None,
                 if rnd > self._tp_prob:
                     return None
 
-            fields["labels"] = SequenceLabelField(labels, sequence,
-                                                  label_namespace="labels")
-            fields["d_tags"] = SequenceLabelField(detect_tags, sequence,
-                                                  label_namespace="d_tags")
+            fields["labels"] = SequenceLabelField(
+                labels, sequence, label_namespace="labels"
+            )
+            fields["d_tags"] = SequenceLabelField(
+                detect_tags, sequence, label_namespace="d_tags"
+            )
         return Instance(fields)