simple is working but not properly tested

Stab-Gurevych-Essays.py

@@ -0,0 +1,464 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# TODO: Address all TODOs and remove all explanatory comments
+"""TODO: Add a description here."""
+
+
+import csv
+import json
+import os
+import re
+import tempfile
+import urllib
+import requests
+from pathlib import Path
+from zipfile import ZipFile
+
+import datasets
+
+# TODO: Add BibTeX citation
+# Find for instance the citation on arxiv or on the dataset repo/website
+_CITATION = """\
+@InProceedings{huggingface:dataset,
+title = {A great new dataset},
+author={huggingface, Inc.
+},
+year={2020}
+}
+"""
+
+# TODO: Add description of the dataset here
+# You can copy an official description
+_DESCRIPTION = """\
+This dataset contains 402 argumentative essays from non-native
+"""
+
+# TODO: Add a link to an official homepage for the dataset here
+_HOMEPAGE = ""
+
+# TODO: Add the licence for the dataset here if you can find it
+_LICENSE = ""
+
+# TODO: Add link to the official dataset URLs here
+# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
+# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
+_URLS = {
+    "tu_darmstadt": "https://tudatalib.ulb.tu-darmstadt.de/bitstream/handle/tudatalib/2422/ArgumentAnnotatedEssays-2.0.zip?sequence=1&isAllowed=y",
+}
+
+
+# TODO: Name of the dataset usually matches the script name with CamelCase instead of snake_case
+class NewDataset(datasets.GeneratorBasedBuilder):
+    """TODO: Short description of my dataset."""
+
+    VERSION = datasets.Version("1.1.0")
+
+    temp_dir = tempfile.TemporaryDirectory()
+
+    # This is an example of a dataset with multiple configurations.
+    # If you don't want/need to define several sub-sets in your dataset,
+    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
+
+    # If you need to make complex sub-parts in the datasets with configurable options
+    # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
+    # BUILDER_CONFIG_CLASS = MyBuilderConfig
+
+    # You will be able to load one or the other configurations in the following list with
+    # data = datasets.load_dataset('my_dataset', 'first_domain')
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(
+            name="full_labels",
+            version=VERSION,
+            description="get all the data conveyed by the labels, O, B-Claim, I-Claim, etc.",
+        ),
+        datasets.BuilderConfig(
+            name="spans",
+            version=VERSION,
+            description="get the spans, O, B-Span, I-Span.",
+        ),
+        datasets.BuilderConfig(
+            name="simple",
+            version=VERSION,
+            description="get the labels without B/I, O, MajorClaim, Claim, Premise",
+        ),
+        datasets.BuilderConfig(
+            name="sep_tok",
+            version=VERSION,
+            description="get the labels without B/I, meaning O, Claim, Premise"
+            + ", etc.\n insert seperator tokens <s> ... </s>",
+        ),
+        datasets.BuilderConfig(
+            name="sep_tok_full_labels",
+            version=VERSION,
+            description="get the labels with B/I, meaning O, I-Claim, I-Premise"
+            + ", etc.\n insert seperator tokens <s> ... </s>",
+        ),
+    ]
+
+    DEFAULT_CONFIG_NAME = "full_labels"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+
+    def _info(self):
+        # This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
+        if (
+            self.config.name == "full_labels"
+        ):  # This is the name of the configuration selected in BUILDER_CONFIGS above
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("int16"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "ner_tags": datasets.Sequence(
+                        datasets.ClassLabel(
+                            names=[
+                                "O",
+                                "B-MajorClaim",
+                                "I-MajorClaim",
+                                "B-Claim",
+                                "I-Claim",
+                                "B-Premise",
+                                "I-Premise",
+                            ]
+                        )
+                    ),
+                    "text": datasets.Value("string"),
+                    "span_begins": datasets.Sequence(datasets.Value("int16")),
+                    "span_ends": datasets.Sequence(datasets.Value("int16")),
+                }
+            )
+        elif (
+            self.config.name == "spans"
+        ):  # This is an example to show how to have different features for "first_domain" and "second_domain"
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("int16"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "ner_tags": datasets.Sequence(
+                        datasets.ClassLabel(
+                            names=[
+                                "O",
+                                "B",
+                                "I",
+                            ]
+                        )
+                    ),
+                    "text": datasets.Value("string"),
+                    "span_begins": datasets.Sequence(datasets.Value("int16")),
+                    "span_ends": datasets.Sequence(datasets.Value("int16")),
+                }
+            )
+        elif (
+            self.config.name == "simple"
+        ):  # This is an example to show how to have different features for "first_domain" and "second_domain"
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("int16"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "ner_tags": datasets.Sequence(
+                        datasets.ClassLabel(
+                            names=[
+                                "O",
+                                "X_placeholder_X",
+                                "MajorClaim",
+                                "Claim",
+                                "Premise",
+                            ]
+                        )
+                    ),
+                    "text": datasets.Value("string"),
+                    "span_begins": datasets.Sequence(datasets.Value("int16")),
+                    "span_ends": datasets.Sequence(datasets.Value("int16")),
+                }
+            )
+        elif self.config.name == "sep_tok":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("int16"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "ner_tags": datasets.Sequence(
+                        datasets.ClassLabel(
+                            names=[
+                                "O",
+                                "X_placeholder_X",
+                                "MajorClaim",
+                                "Claim",
+                                "Premise",
+                            ]
+                        )
+                    ),
+                    "text": datasets.Value("string"),
+                    "span_begins": datasets.Sequence(datasets.Value("int16")),
+                    "span_ends": datasets.Sequence(datasets.Value("int16")),
+                }
+            )
+        elif self.config.name == "sep_tok_full_labels":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("int16"),
+                    "tokens": datasets.Sequence(datasets.Value("string")),
+                    "ner_tags": datasets.Sequence(
+                        datasets.ClassLabel(
+                            names=[
+                                "O",
+                                "B-MajorClaim",
+                                "I-MajorClaim",
+                                "B-Claim",
+                                "I-Claim",
+                                "B-Premise",
+                                "I-Premise",
+                            ]
+                        )
+                    ),
+                    "text": datasets.Value("string"),
+                    "span_begins": datasets.Sequence(datasets.Value("int16")),
+                    "span_ends": datasets.Sequence(datasets.Value("int16")),
+                }
+            )
+
+        return datasets.DatasetInfo(
+            # This is the description that will appear on the datasets page.
+            description=_DESCRIPTION,
+            # This defines the different columns of the dataset and their types
+            features=features,  # Here we define them above because they are different between the two configurations
+            # If there's a common (input, target) tuple from the features, uncomment supervised_keys line below and
+            # specify them. They'll be used if as_supervised=True in builder.as_dataset.
+            # supervised_keys=("sentence", "label"),
+            # Homepage of the dataset for documentation
+            homepage=_HOMEPAGE,
+            # License for the dataset if available
+            license=_LICENSE,
+            # Citation for the dataset
+            citation=_CITATION,
+        )
+
+    def __load_data(self):
+        # set up paths
+        save_dir = Path(self.temp_dir.name)
+        save_file = Path("essays.zip")
+
+        # get url to data
+        url = _URLS["tu_darmstadt"]
+        # download data
+        r = requests.get(url, stream=True)
+        # save data to temporary dir
+        with open(save_dir / save_file, 'wb') as fd:
+            for chunk in r.iter_content(chunk_size=128):
+                fd.write(chunk)
+        # recursively unzip files
+        for glob_path in save_dir.rglob("*.zip"):
+            with ZipFile(glob_path, 'r') as zip_ref:
+                zip_ref.extractall(glob_path.parent)
+        return save_dir
+
+    def __range_generator(self, train=0.8, test=0.2):
+        """
+        returns three range objects to access the list of essays
+        these are the train, test, and validate range, where the size of the
+        validation range is dictated by the other two ranges
+        """
+        # START RANGE AT 1!!!
+        return (
+            range(1, int(403 * train)),  # train
+            range(int(403 * train), int(403 * (train + test))),  # test
+            range(int(403 * (train + test)), 403),  # validate
+        )
+
+    def _split_generators(self, _):
+        data_dir = self.__load_data()
+
+        # this dataset will return a "train" split only, allowing for
+        # 5-fold cross-validation
+        train, test, validate = self.__range_generator(0.7, 0.2)
+        # essays = self._get_essay_list()
+
+        if len(validate) > 0 and len(test) > 0:
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "data_dir": data_dir,
+                        "id_range": train,
+                    },
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "data_dir": data_dir,
+                        "id_range": validate,
+                    },
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "data_dir": data_dir,
+                        "id_range": test,
+                    },
+                ),
+            ]
+        elif len(test) > 0:
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "data_dir": data_dir,
+                        "id_range": train,
+                    },
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "data_dir": data_dir,
+                        "id_range": test,
+                    },
+                ),
+            ]
+        elif len(validate) > 0:
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "data_dir": data_dir,
+                        "id_range": train,
+                    },
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "data_dir": data_dir,
+                        "id_range": validate,
+                    },
+                ),
+            ]
+        else:
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "data_dir": data_dir,
+                        "id_range": train,
+                    },
+                ),
+            ]
+
+    def _get_essay(self, id: int, data_dir: Path):
+        return data_dir.joinpath(f"essay{str(id).rjust(3, '0')}.txt").read_text(), data_dir.joinpath(f"essay{str(id).rjust(3, '0')}.ann").read_text()
+
+    def _parse_raw_ann(self, raw_ann: str):
+        raw_anns = raw_ann.split("\n")
+        clean_anns = []
+        for cur_raw_ann in raw_anns:
+            matches = re.match(r".+\t(.+) (.+) (.+)\t(.+)", cur_raw_ann)
+            if matches is not None:
+                clean_anns.append(
+                        (matches.group(1), int(matches.group(2)), int(matches.group(3)), matches.group(4))
+                    )
+        # sorting spans by start before returningbefore returning
+        return sorted(clean_anns, key=lambda x: x[1])
+
+    def _tokenise(self, text, clean_anns):
+        # find spans
+        previous_end = 0
+        spans = []
+        # for every span, add the not span that is before it
+        for clean_ann in clean_anns:
+            spans.append(("O", text[previous_end:clean_ann[1]]))
+            spans.append((clean_ann[0], text[clean_ann[1]:clean_ann[2]]))
+            # if were picking up the wrong text...
+            if spans[-1][1] != clean_ann[3]: 
+                print(spans[-1][1])
+                input(clean_ann[3])
+            previous_end = clean_ann[2]
+        # add whatever is left over to not spans
+        spans.append(("O", text[previous_end:]))
+
+        tokens = []
+        labels = []
+        # tokenise spans
+        for span in spans:
+            span_tokens = span[1].split()
+            label = span[0]
+            if self.config.name == "simple":
+                # with simple, the token is already correct
+                pass
+            elif self.config.name == "sep_tok":
+                # with sep_tok, the token is correct, but a sep top needs to be inserted
+                pass
+                # TODO: make sure to include the sep tok!!!
+            elif self.config.name == "spans":
+                if label != "O":
+                    label = "I"
+                    # TODO: make sure to iclude the B and the I
+            elif self.config.name == "full_labels":
+                # TODO: ensure I and B
+                pass
+            elif self.config.name == "sep_tok_full_labels":
+                # TODO: ensure I and B
+                # TODO: make sure to include the sep tok!!!
+                pass
+            labels.append([label] * len(span_tokens))
+            tokens.append(span_tokens)
+
+        # flatten list of lists of labels before return
+        labels = [ label for inner_list in labels for label in inner_list ]
+        return tokens, labels
+
+    def _process_essay(self, id, data_dir: Path):
+        # TODO: get the logic in here. everything else it taken care of i think
+        text, raw_ann = self._get_essay(id, data_dir)
+        clean_anns = self._parse_raw_ann(raw_ann)
+        tokens, labels = self._tokenise(text, clean_anns)
+
+
+        # id = self._get_id(essay)
+        # # input(id)
+        # tokens = self._get_tokens(essay)
+        # # input(tokens)
+        # label_dict = self._get_label_dict(essay)
+        # # input(label_dict)
+        # tokens, labels, begins, ends = self._match_tokens(tokens, label_dict)
+        # # input(tokens)
+        # # input(labels)
+        # text = self._get_text(essay)
+
+        # id = 1 
+        # tokens = ["1"]
+        # labels = [1]
+        # text = "a"
+        # begins = [1]
+        # ends = [2]
+        return {
+            "id": id,
+            "tokens": tokens,
+            "ner_tags": labels,
+            "text": text,
+            "span_begins": [ann[1] for ann in clean_anns],
+            "span_ends": [ann[2] for ann in clean_anns],
+        }
+
+    # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
+    def _generate_examples(self, data_dir: Path, id_range: list):
+        # This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
+        # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
+
+        data_dir = data_dir.joinpath("ArgumentAnnotatedEssays-2.0", "brat-project-final")
+
+        for id in id_range:
+            # input(data[id])
+            yield id, self._process_essay(id, data_dir)