kbp37.py

# coding=utf-8
# Copyright 2022 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.

"""The KBP37 dataset for English Relation Classification"""

import datasets

_CITATION = """\
@article{DBLP:journals/corr/ZhangW15a,
  author    = {Dongxu Zhang and
               Dong Wang},
  title     = {Relation Classification via Recurrent Neural Network},
  journal   = {CoRR},
  volume    = {abs/1508.01006},
  year      = {2015},
  url       = {http://arxiv.org/abs/1508.01006},
  eprinttype = {arXiv},
  eprint    = {1508.01006},
  timestamp = {Fri, 04 Nov 2022 18:37:50 +0100},
  biburl    = {https://dblp.org/rec/journals/corr/ZhangW15a.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}
"""

_DESCRIPTION = """\
KBP37 is a revision of MIML-RE annotation dataset, provided by Gabor Angeli et al. (2014). They use both the 2010 and 
2013 KBP official document collections, as well as a July 2013 dump of Wikipedia as the text corpus for annotation. 
There are 33811 sentences been annotated. Zhang and Wang made several refinements:
1. They add direction to the relation names, e.g. '`per:employee_of`' is split into  '`per:employee of(e1,e2)`'
and '`per:employee of(e2,e1)`'. They also replace '`org:parents`' with '`org:subsidiaries`' and replace
'`org:member of’ with '`org:member`' (by their reverse directions).
2. They discard low frequency relations such that both directions of each relation occur more than 100 times in the 
dataset.

KBP37 contains 18 directional relations and an additional '`no_relation`' relation, resulting in 37 relation classes.
"""

_HOMEPAGE = ""

_LICENSE = ""


# The HuggingFace dataset library don't host the datasets but only point to the original files
# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
_URLs = {
    "train": "https://raw.githubusercontent.com/zhangdongxu/kbp37/master/train.txt",
    "validation": "https://raw.githubusercontent.com/zhangdongxu/kbp37/master/dev.txt",
    "test": "https://raw.githubusercontent.com/zhangdongxu/kbp37/master/test.txt"
}

_VERSION = datasets.Version("1.0.0")

_CLASS_LABELS = [
    "no_relation",
    "org:alternate_names(e1,e2)",
    "org:alternate_names(e2,e1)",
    "org:city_of_headquarters(e1,e2)",
    "org:city_of_headquarters(e2,e1)",
    "org:country_of_headquarters(e1,e2)",
    "org:country_of_headquarters(e2,e1)",
    "org:founded(e1,e2)",
    "org:founded(e2,e1)",
    "org:founded_by(e1,e2)",
    "org:founded_by(e2,e1)",
    "org:members(e1,e2)",
    "org:members(e2,e1)",
    "org:stateorprovince_of_headquarters(e1,e2)",
    "org:stateorprovince_of_headquarters(e2,e1)",
    "org:subsidiaries(e1,e2)",
    "org:subsidiaries(e2,e1)",
    "org:top_members/employees(e1,e2)",
    "org:top_members/employees(e2,e1)",
    "per:alternate_names(e1,e2)",
    "per:alternate_names(e2,e1)",
    "per:cities_of_residence(e1,e2)",
    "per:cities_of_residence(e2,e1)",
    "per:countries_of_residence(e1,e2)",
    "per:countries_of_residence(e2,e1)",
    "per:country_of_birth(e1,e2)",
    "per:country_of_birth(e2,e1)",
    "per:employee_of(e1,e2)",
    "per:employee_of(e2,e1)",
    "per:origin(e1,e2)",
    "per:origin(e2,e1)",
    "per:spouse(e1,e2)",
    "per:spouse(e2,e1)",
    "per:stateorprovinces_of_residence(e1,e2)",
    "per:stateorprovinces_of_residence(e2,e1)",
    "per:title(e1,e2)",
    "per:title(e2,e1)"
]


class KBP37(datasets.GeneratorBasedBuilder):
    """KBP37 is a relation extraction dataset"""

    BUILDER_CONFIGS = [
        datasets.BuilderConfig(
            name="kbp37", version=_VERSION, description="The KBP37 dataset."
        ),
        datasets.BuilderConfig(
            name="kbp37_formatted", version=_VERSION, description="The formatted KBP37 dataset."
        )
    ]

    DEFAULT_CONFIG_NAME = "kbp37"  # type: ignore

    def _info(self):
        if self.config.name == "kbp37_formatted":
            features = datasets.Features(
                {
                    "id": datasets.Value("string"),
                    "token": datasets.Sequence(datasets.Value("string")),
                    "e1_start": datasets.Value("int32"),
                    "e1_end": datasets.Value("int32"),
                    "e2_start": datasets.Value("int32"),
                    "e2_end": datasets.Value("int32"),
                    "relation": datasets.ClassLabel(names=_CLASS_LABELS),
                }
            )
        else:
            features = datasets.Features(
                {
                    "id": datasets.Value("string"),
                    "sentence": datasets.Value("string"),
                    "relation": datasets.ClassLabel(names=_CLASS_LABELS),
                }
            )

        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,
            # specify them here. They'll be used if as_supervised=True in
            # builder.as_dataset.
            supervised_keys=None,
            # Homepage of the dataset for documentation
            homepage=_HOMEPAGE,
            # License for the dataset if available
            license=_LICENSE,
            # Citation for the dataset
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        """Returns SplitGenerators."""
        # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name

        # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLs
        # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
        # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive

        downloaded_files = dl_manager.download_and_extract(_URLs)

        return [datasets.SplitGenerator(name=i, gen_kwargs={"filepath": downloaded_files[str(i)]})
                for i in [datasets.Split.TRAIN, datasets.Split.VALIDATION, datasets.Split.TEST]]

    def _generate_examples(self, filepath):
        """Yields examples."""
        # This method will receive as arguments the `gen_kwargs` defined in the previous `_split_generators` method.
        # It is in charge of opening the given file and yielding (key, example) tuples from the dataset
        # The key is not important, it's more here for legacy reason (legacy from tfds)

        with open(filepath, encoding="utf-8") as f:
            data = []
            example_line = None
            for idx, line in enumerate(f.readlines()):
                line_no = idx % 4  # first line contains example, second line relation, third and fourth lines are \n
                if line_no == 0:
                    example_line = line.strip().split("\t")
                elif line_no == 1:
                    data.append({"example": example_line, "relation": line.strip()})
            for example in data:
                id_ = example["example"][0]
                text = example["example"][1]
                assert text[:2] == "\" " and text[-2:] == " \""
                text = text[2:-2]
                relation = example["relation"]

                if self.config.name == "kbp37_formatted":
                    text = text.replace("<e1>", " <e1> ")
                    text = text.replace("<e2>", " <e2> ")
                    text = text.replace("</e1>", " </e1> ")
                    text = text.replace("</e2>", " </e2> ")
                    text = text.strip().replace(r"\s\s+", r"\s")
                    tokens = text.split()
                    e1_start = tokens.index("<e1>")
                    e2_start = tokens.index("<e2>")
                    if e1_start < e2_start:
                        tokens.pop(e1_start)
                        e1_end = tokens.index("</e1>")
                        tokens.pop(e1_end)
                        e2_start = tokens.index("<e2>")
                        tokens.pop(e2_start)
                        e2_end = tokens.index("</e2>")
                        tokens.pop(e2_end)

                    # some examples, like train/1276 are invalid (empty head/tail), and
                    # yield non-sensical examples without this check
                    if e1_end > e1_start and e2_end > e2_start:
                        yield int(id_), {
                            "id": id_,
                            "token": tokens,
                            "e1_start": e1_start,
                            "e1_end": e1_end,
                            "e2_start": e2_start,
                            "e2_end": e2_end,
                            "relation": relation,
                        }
                else:
                    yield int(id_), {
                        "id": id_,
                        "sentence": text,
                        "relation": relation,
                    }