klue.py

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

"""KLUE (Korean Language Understanding Evaluation) benchmark."""


import csv
import json
import textwrap

import datasets


_KLUE_CITATION = """\
@misc{park2021klue,
      title={KLUE: Korean Language Understanding Evaluation},
      author={Sungjoon Park and Jihyung Moon and Sungdong Kim and Won Ik Cho and Jiyoon Han and Jangwon Park and Chisung Song and Junseong Kim and Yongsook Song and Taehwan Oh and Joohong Lee and Juhyun Oh and Sungwon Lyu and Younghoon Jeong and Inkwon Lee and Sangwoo Seo and Dongjun Lee and Hyunwoo Kim and Myeonghwa Lee and Seongbo Jang and Seungwon Do and Sunkyoung Kim and Kyungtae Lim and Jongwon Lee and Kyumin Park and Jamin Shin and Seonghyun Kim and Lucy Park and Alice Oh and Jungwoo Ha and Kyunghyun Cho},
      year={2021},
      eprint={2105.09680},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}
"""

_KLUE_DESCRIPTION = """\
KLUE (Korean Language Understanding Evaluation)
Korean Language Understanding Evaluation (KLUE) benchmark is a series of datasets to evaluate natural language
understanding capability of Korean language models. KLUE consists of 8 diverse and representative tasks, which are accessible
to anyone without any restrictions. With ethical considerations in mind, we deliberately design annotation guidelines to obtain
unambiguous annotations for all datasets. Futhermore, we build an evaluation system and carefully choose evaluations metrics
for every task, thus establishing fair comparison across Korean language models.
"""

_DATA_URLs = {
    "ynat": "http://klue-benchmark.com.s3.amazonaws.com/app/Competitions/000066/data/ynat-v1.tar.gz",
    "sts": "http://klue-benchmark.com.s3.amazonaws.com/app/Competitions/000067/data/klue-sts-v1.tar.gz",
    "nli": "http://klue-benchmark.com.s3.amazonaws.com/app/Competitions/000068/data/klue-nli-v1.tar.gz",
    "ner": "http://klue-benchmark.com.s3.amazonaws.com/app/Competitions/000069/data/klue-ner-v1.tar.gz",
    "re": "http://klue-benchmark.com.s3.amazonaws.com/app/Competitions/000070/data/klue-re-v1.tar.gz",
    "dp": "http://klue-benchmark.com.s3.amazonaws.com/app/Competitions/000071/data/klue-dp-v1.tar.gz",
    "mrc": "http://klue-benchmark.com.s3.amazonaws.com/app/Competitions/000072/data/klue-mrc-v1.tar.gz",
    "wos": "http://klue-benchmark.com.s3.amazonaws.com/app/Competitions/000073/data/wos-v1.tar.gz",
}

_DESCRIPTION_URLs = {
    "ynat": "https://klue-benchmark.com/tasks/66/overview/description",
    "sts": "https://klue-benchmark.com/tasks/67/overview/description",
    "nli": "https://klue-benchmark.com/tasks/68/overview/description",
    "ner": "https://klue-benchmark.com/tasks/69/overview/description",
    "re": "https://klue-benchmark.com/tasks/70/overview/description",
    "dp": "https://klue-benchmark.com/tasks/71/overview/description",
    "mrc": "https://klue-benchmark.com/tasks/72/overview/description",
    "wos": "https://klue-benchmark.com/tasks/73/overview/description",
}

_LICENSE = "CC-BY-SA-4.0"


class KlueConfig(datasets.BuilderConfig):
    """BuilderConfig for KLUE."""

    def __init__(
        self,
        features,
        data_url,
        url,
        file_map,
        **kwargs,
    ):
        """BuilderConfig for KLUE."""

        super(KlueConfig, self).__init__(version=datasets.Version("1.0.0", ""), **kwargs)
        self.features = features
        self.data_url = data_url
        self.url = url
        self.file_map = file_map


class Klue(datasets.GeneratorBasedBuilder):
    """The General Language Understanding Evaluation (GLUE) benchmark."""

    BUILDER_CONFIGS = [
        KlueConfig(
            name="ynat",
            features={
                "guid": datasets.Value("string"),
                "title": datasets.Value("string"),
                "label": datasets.features.ClassLabel(names=["IT과학", "경제", "사회", "생활문화", "세계", "스포츠", "정치"]),
                "url": datasets.Value("string"),
                "date": datasets.Value("string"),
            },
            description=textwrap.dedent(
                """\
            In topic classification (TC), the goal is to predict the topic of a given text
            snippet. We include TC in our KLUE benchmark, as inferring the topic of a text is a key
            capability that should be possessed by a language understanding system.
            Following a typical single  sentence classification task, we introduce YNAT, a Younhap
            News Agency news headlines for Topic Classification. For Korean, no dataset has been
            proposed for this task, which motivates us to construct the first Korean topic
            classification benchmark. In this task, given a news headline, a text classifier must
            predict a topic which is one of politics, economy, society, culture, world, IT/science,
            and sports. Macro-F1 score is used to evaluate a system."""
            ),
            data_url=_DATA_URLs["ynat"],
            url=_DESCRIPTION_URLs["ynat"],
            file_map={
                "train": "ynat-v1_train.json",
                "dev": "ynat-v1_dev.json",
            },
        ),
        KlueConfig(
            name="sts",
            features={
                "guid": datasets.Value("string"),
                "source": datasets.Value("string"),
                "sentence1": datasets.Value("string"),
                "sentence2": datasets.Value("string"),
                "labels": {
                    "label": datasets.Value("float64"),
                    "real-label": datasets.Value("float64"),
                    "binary-label": datasets.ClassLabel(names=["negative", "positive"]),
                },
            },
            description=textwrap.dedent(
                """\
            STS is a task which aims to predict the semantic similarity of two input sentences as
            a real value between 0 and 5. Note that we furthure binarized the prediction scores
            into two classes with a threshold score 3.0 (paraphrased or not) and evaluated with
            a classification metric.
            """
            ),
            data_url=_DATA_URLs["sts"],
            url=_DESCRIPTION_URLs["sts"],
            file_map={
                "train": "klue-sts-v1_train.json",
                "dev": "klue-sts-v1_dev.json",
            },
        ),
        KlueConfig(
            name="nli",
            features={
                "guid": datasets.Value("string"),
                "source": datasets.Value("string"),
                "premise": datasets.Value("string"),
                "hypothesis": datasets.Value("string"),
                "label": datasets.ClassLabel(names=["entailment", "neutral", "contradiction"]),
            },
            description=textwrap.dedent(
                """\
            NLI is a task to infer the relationship between a hypothesis sentence and a premise
            sentence. Given the premise, the model determines if the hypothesis is true (entailment),
            false (contradiction), or undetermined (neutral).
            """
            ),
            data_url=_DATA_URLs["nli"],
            url=_DESCRIPTION_URLs["nli"],
            file_map={
                "train": "klue-nli-v1_train.json",
                "dev": "klue-nli-v1_dev.json",
            },
        ),
        KlueConfig(
            name="ner",
            features={
                "sentence": datasets.Value("string"),
                "tokens": datasets.Sequence(datasets.Value("string")),
                "ner_tags": datasets.Sequence(
                    datasets.ClassLabel(
                        names=[
                            "B-DT",
                            "I-DT",
                            "B-LC",
                            "I-LC",
                            "B-OG",
                            "I-OG",
                            "B-PS",
                            "I-PS",
                            "B-QT",
                            "I-QT",
                            "B-TI",
                            "I-TI",
                            "O",
                        ]
                    )
                ),
            },
            description=textwrap.dedent(
                """\
            NER is a task to detect the boundaries of named entities in unstructured text and to
            classify the types. A named entity can be of one of predefined entity types such as
            person, location, organization, time expressions, quantities and monetary values.
            """
            ),
            data_url=_DATA_URLs["ner"],
            url=_DESCRIPTION_URLs["ner"],
            file_map={
                "train": "klue-ner-v1_train.tsv",
                "dev": "klue-ner-v1_dev.tsv",
            },
        ),
        KlueConfig(
            name="re",
            features={
                "guid": datasets.Value("string"),
                "sentence": datasets.Value("string"),
                "subject_entity": {
                    "word": datasets.Value("string"),
                    "start_idx": datasets.Value("int32"),
                    "end_idx": datasets.Value("int32"),
                    "type": datasets.Value("string"),
                },
                "object_entity": {
                    "word": datasets.Value("string"),
                    "start_idx": datasets.Value("int32"),
                    "end_idx": datasets.Value("int32"),
                    "type": datasets.Value("string"),
                },
                "label": datasets.ClassLabel(
                    names=[
                        "no_relation",
                        "org:dissolved",
                        "org:founded",
                        "org:place_of_headquarters",
                        "org:alternate_names",
                        "org:member_of",
                        "org:members",
                        "org:political/religious_affiliation",
                        "org:product",
                        "org:founded_by",
                        "org:top_members/employees",
                        "org:number_of_employees/members",
                        "per:date_of_birth",
                        "per:date_of_death",
                        "per:place_of_birth",
                        "per:place_of_death",
                        "per:place_of_residence",
                        "per:origin",
                        "per:employee_of",
                        "per:schools_attended",
                        "per:alternate_names",
                        "per:parents",
                        "per:children",
                        "per:siblings",
                        "per:spouse",
                        "per:other_family",
                        "per:colleagues",
                        "per:product",
                        "per:religion",
                        "per:title",
                    ]
                ),
                "source": datasets.Value("string"),
            },
            description=textwrap.dedent(
                """\
            RE is a task to identify semantic relations between entity pairs in a text. The relation
            is defined between an entity pair consisting of subject entity and object entity.
            The goal is then to pick an appropriate relationship between these two entities.
            """
            ),
            data_url=_DATA_URLs["re"],
            url=_DESCRIPTION_URLs["re"],
            file_map={
                "train": "klue-re-v1_train.json",
                "dev": "klue-re-v1_dev.json",
            },
        ),
        KlueConfig(
            name="dp",
            features={
                "sentence": datasets.Value("string"),
                "index": [datasets.Value("int32")],
                "word_form": [datasets.Value("string")],
                "lemma": [datasets.Value("string")],
                "pos": [datasets.Value("string")],
                "head": [datasets.Value("int32")],
                "deprel": [datasets.Value("string")],
            },
            description=textwrap.dedent(
                """\
            DP is a task that aims at finding relational information among words.
            The goal is to predict a graph structure and a dependency label of an input sentence
            based on the dependency grammar.
            """
            ),
            data_url=_DATA_URLs["dp"],
            url=_DESCRIPTION_URLs["dp"],
            file_map={
                "train": "klue-dp-v1_train.tsv",
                "dev": "klue-dp-v1_dev.tsv",
            },
        ),
        KlueConfig(
            name="mrc",
            features={
                "title": datasets.Value("string"),
                "context": datasets.Value("string"),
                "news_category": datasets.Value("string"),
                "source": datasets.Value("string"),
                "guid": datasets.Value("string"),
                "is_impossible": datasets.Value("bool"),
                "question_type": datasets.Value("int32"),
                "question": datasets.Value("string"),
                "answers": datasets.features.Sequence(
                    {
                        "answer_start": datasets.Value("int32"),
                        "text": datasets.Value("string"),
                    },
                ),
            },
            description=textwrap.dedent(
                """\
            MRC is a task of evaluating model that can answer a question about a given text
            passage. Specifically, we formulate the task as a span prediction task, where the
            answer is a text segment (coined as spans) in the passage.
            """
            ),
            data_url=_DATA_URLs["mrc"],
            url=_DESCRIPTION_URLs["mrc"],
            file_map={
                "train": "klue-mrc-v1_train.json",
                "dev": "klue-mrc-v1_dev.json",
            },
        ),
        KlueConfig(
            name="wos",
            features={
                "guid": datasets.Value("string"),
                "domains": [datasets.Value("string")],
                "dialogue": [
                    {
                        "role": datasets.Value("string"),
                        "text": datasets.Value("string"),
                        "state": [datasets.Value("string")],
                    }
                ],
            },
            description=textwrap.dedent(
                """\
            DST is a task to predict slot and value pairs (dialogue states) from a task-oriented
            dialogue. The potential pairs are predefined by a given task schema and knowledge
            base (KB).
            """
            ),
            data_url=_DATA_URLs["wos"],
            url=_DESCRIPTION_URLs["wos"],
            file_map={
                "train": "wos-v1_train.json",
                "dev": "wos-v1_dev.json",
            },
        ),
    ]

    def _info(self):
        return datasets.DatasetInfo(
            description=_KLUE_DESCRIPTION,
            features=datasets.Features(self.config.features),
            homepage=self.config.url,
            citation=_KLUE_CITATION,
            license=_LICENSE,
        )

    def _split_generators(self, dl_manager):
        archive = dl_manager.download(self.config.data_url)
        dir_name = self.config.data_url.split("/")[-1].replace(".tar.gz", "")
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "data_file": dir_name + "/" + self.config.file_map["train"],
                    "files": dl_manager.iter_archive(archive),
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "data_file": dir_name + "/" + self.config.file_map["dev"],
                    "files": dl_manager.iter_archive(archive),
                },
            ),
        ]

    def _generate_examples(self, data_file, files):
        if self.config.name in ["ynat", "sts", "re"]:
            for path, f in files:
                if path == data_file:
                    f = json.load(f)
                    for id_, row in enumerate(f):
                        features = {key: row[key] for key in row if key in self.config.features}
                        yield id_, features
                    break

        if self.config.name == "nli":
            for path, f in files:
                if path == data_file:
                    f = json.load(f)
                    for id_, row in enumerate(f):
                        # In train file, "source" is written as "genre"
                        features = {
                            "guid": row["guid"],
                            "source": row["source"] if "source" in row else row["genre"],
                            "premise": row["premise"],
                            "hypothesis": row["hypothesis"],
                            "label": row["gold_label"],
                        }
                        yield id_, features
                    break

        if self.config.name == "ner":
            for path, f in files:
                if path == data_file:
                    f = (line.decode("utf-8") for line in f)
                    reader = csv.reader(f, delimiter="\t", quoting=csv.QUOTE_NONE)
                    for _ in range(5):  # skip headers
                        next(reader)
                    id_ = -1
                    for row in reader:
                        if row:
                            if row[0].startswith("##"):
                                id_ += 1
                                tokens, ner_tags = [], []
                                sentence = row[1]
                            else:
                                tokens.append(row[0])
                                ner_tags.append(row[1])
                        else:  # new line
                            assert len(tokens) == len(ner_tags)
                            yield id_, {"sentence": sentence, "tokens": tokens, "ner_tags": ner_tags}
                    break

        if self.config.name == "dp":
            for path, f in files:
                if path == data_file:
                    f = (line.decode("utf-8") for line in f)
                    reader = csv.reader(f, delimiter="\t", quoting=csv.QUOTE_NONE)
                    for _ in range(5):  # skip headers
                        next(reader)
                    id_ = -1
                    for row in reader:
                        if row:
                            if row[0].startswith("##"):
                                id_ += 1
                                index = []
                                word_form = []
                                lemma = []
                                pos = []
                                head = []
                                deprel = []
                                sentence = row[1]
                            else:
                                index.append(row[0])
                                word_form.append(row[1])
                                lemma.append(row[2])
                                pos.append(row[3])
                                head.append(row[4])
                                deprel.append(row[5])
                        else:  # new line
                            assert len(index) == len(word_form) == len(lemma) == len(pos) == len(head) == len(deprel)
                            yield id_, {
                                "sentence": sentence,
                                "index": index,
                                "word_form": word_form,
                                "lemma": lemma,
                                "pos": pos,
                                "head": head,
                                "deprel": deprel,
                            }
                    break

        if self.config.name == "mrc":
            for path, f in files:
                if path == data_file:
                    f = json.load(f)
                    id_ = -1
                    for example in f["data"]:
                        title = example.get("title", "")
                        news_category = example.get("news_category", "")
                        source = example["source"]
                        for paragraph in example["paragraphs"]:
                            context = paragraph["context"].strip()
                            for qa in paragraph["qas"]:
                                guid = qa["guid"]
                                question_type = qa["question_type"]
                                is_impossible = qa["is_impossible"]
                                question = qa["question"].strip()

                                if "plausible_answers" in qa:
                                    qa["answers"].extend(qa["plausible_answers"])
                                answer_starts = [answer["answer_start"] for answer in qa["answers"]]
                                answers = [answer["text"].strip() for answer in qa["answers"]]
                                id_ += 1

                                yield id_, {
                                    "guid": guid,
                                    "title": title,
                                    "context": context,
                                    "news_category": news_category,
                                    "source": source,
                                    "question_type": question_type,
                                    "is_impossible": is_impossible,
                                    "question": question,
                                    "answers": {
                                        "answer_start": answer_starts,
                                        "text": answers,
                                    },
                                }
                    break

        if self.config.name == "wos":
            for path, f in files:
                if path == data_file:
                    f = json.load(f)
                    for id_, row in enumerate(f):
                        guid = row["guid"]
                        domains = row["domains"]
                        dialogue = row["dialogue"]
                        for utterance in dialogue:
                            if "state" not in utterance:
                                utterance["state"] = []
                        yield id_, {"guid": guid, "domains": domains, "dialogue": dialogue}
                    break