# 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 os 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): dl_dir = dl_manager.download_and_extract(self.config.data_url) dir_name = self.config.data_url.split("/")[-1].replace(".tar.gz", "") data_dir = os.path.join(dl_dir, dir_name) return [ datasets.SplitGenerator( name=datasets.Split.TRAIN, gen_kwargs={ "data_file": os.path.join(data_dir, self.config.file_map["train"]), "split": "train", }, ), datasets.SplitGenerator( name=datasets.Split.VALIDATION, gen_kwargs={ "data_file": os.path.join(data_dir, self.config.file_map["dev"]), "split": "dev", }, ), ] def _generate_examples(self, data_file, split): if self.config.name in ["ynat", "sts", "re"]: with open(data_file, encoding="UTF-8") as f: 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 if self.config.name == "nli": with open(data_file, encoding="UTF-8") as f: 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 if self.config.name == "ner": with open(data_file, encoding="UTF-8") as 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} if self.config.name == "dp": with open(data_file, encoding="UTF-8") as 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, } if self.config.name == "mrc": with open(data_file, encoding="UTF-8") as f: 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, }, } if self.config.name == "wos": with open(data_file, encoding="UTF-8") as f: 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}