Datasets:

GEM
/

wiki_lingua

	# 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.
	"""WikiLingua: A benchmark dataset for multilingual abstractive summarization."""

	import os
	import glob
	import pickle
	import datasets


	_CITATION = """\
	@article{ladhak-wiki-2020,
	title = {WikiLingua: A New Benchmark Dataset for Multilingual Abstractive Summarization},
	authors = {Faisal Ladhak, Esin Durmus, Claire Cardie and Kathleen McKeown},
	journal = {arXiv preprint arXiv:2010.03093},
	year = {2020},
	url = {https://arxiv.org/abs/2010.03093}
	}
	"""

	_DESCRIPTION = """\
	WikiLingua is a large-scale multilingual dataset for the evaluation of
	crosslingual abstractive summarization systems. The dataset includes ~770k
	article and summary pairs in 18 languages from WikiHow. The gold-standard
	article-summary alignments across languages was done by aligning the images
	that are used to describe each how-to step in an article.
	"""

	_HOMEPAGE = "https://github.com/esdurmus/Wikilingua"

	_LICENSE = "CC BY-NC-SA 3.0"

	_URL = "wikilingua_cleaned.tar.gz"

	VERSION = datasets.Version("2.0.0")

	valid_language_codes = {
	"ar",
	"cs",
	"de",
	"en",
	"es",
	"fr",
	"hi",
	"id",
	"it",
	"ja",
	"ko",
	"nl",
	"pt",
	"ru",
	"th",
	"tr",
	"vi",
	"zh",
	}

	valid_config_names = (
	# multilingual
	list(valid_language_codes)
	+ [
	# crosslingual / bridge
	f"{src}_{tgt}"
	for src in valid_language_codes
	for tgt in valid_language_codes
	if src != tgt
	]
	# load all multilingual / all crosslingual
	+ ["multilingual", "crosslingual"]
	)


	class WikilinguaModes:
	MULTILINGUAL = "multilingual" # L -> L
	CROSSLINGUAL = "crosslingual" # L1 -> L1, L2 -> L2, L1 -> L2, L2 -> L1
	BRIDGE = "bridge" # L -> en, en -> L, L -> L


	class WikilinguaConfig(datasets.BuilderConfig):
	"""BuilderConfig for WikiLingua."""

	def __init__(self, name, **kwargs):
	"""
	Args:
	name (string): configuration name that indicates task setup and languages.

	1. multilingual - <lang>
	2. crosslingual - <lang1>_<lang2>
	3. english as bridge - en_<lang>
	4. load all multilingual - multilingual
	5. load all crosslingual - crosslingual

	lang refers to the respective two-letter language code.
	note that the order of lang1/lang2 does not matter;
	for language pair (L1, L2), we load L1 <-> L2 and L1 -> L1, L2 -> L2.
	"""
	if name not in valid_config_names:
	raise ValueError(
	f"Expected config name to be one of: {', '.join(valid_config_names)}"
	)

	eles = name.split("_")

	if name in (WikilinguaModes.MULTILINGUAL, WikilinguaModes.CROSSLINGUAL):
	self.mode = name
	self.source_lang = None
	self.target_lang = None
	description = f"Wikilingua summarization data ({self.mode}; all instances)"
	else:
	if len(eles) == 1:
	mode = WikilinguaModes.MULTILINGUAL
	source_lang, target_lang = name, name
	elif len(eles) == 2:
	source_lang, target_lang = eles
	if source_lang == "en" or target_lang == "en":
	mode = WikilinguaModes.BRIDGE
	else:
	mode = WikilinguaModes.CROSSLINGUAL
	self.source_lang = source_lang
	self.target_lang = target_lang
	self.mode = mode
	description = (
	f"Wikilingua summarisation data ({mode}; {source_lang}, {target_lang})"
	)
	self.languages = set([self.source_lang, self.target_lang])

	super().__init__(
	name=name,
	description=description,
	**kwargs,
	)


	class WikiLingua(datasets.GeneratorBasedBuilder):
	"""WikiLingua: A benchmark dataset for multilingual abstractive summarization."""

	BUILDER_CONFIG_CLASS = WikilinguaConfig

	BUILDER_CONFIGS = [
	WikilinguaConfig(
	name=config_name,
	version=VERSION,
	)
	for config_name in valid_config_names
	]

	DEFAULT_CONFIG_NAME = "en"

	def _info(self):
	return datasets.DatasetInfo(
	description=_DESCRIPTION,
	features=datasets.Features(
	{
	"gem_id": datasets.Value("string"),
	"gem_parent_id": datasets.Value("string"),
	"source_language": datasets.Value("string"),
	"target_language": datasets.Value("string"),
	"source": datasets.Value("string"),
	"target": datasets.Value("string"),
	"references": [datasets.Value("string")],
	}
	),
	supervised_keys=None,
	homepage=_HOMEPAGE,
	license=_LICENSE,
	citation=_CITATION,
	)

	def _split_generators(self, dl_manager):
	"""Returns SplitGenerators."""

	dl_dir = dl_manager.download_and_extract(_URL)
	data_dir = os.path.join(dl_dir, "cleaned")

	return [
	datasets.SplitGenerator(
	name=datasets.Split.TRAIN,
	gen_kwargs={
	"filepaths": glob.glob(
	os.path.join(data_dir, f"wikilingua_*.train.pk")
	)
	},
	),
	datasets.SplitGenerator(
	name=datasets.Split.VALIDATION,
	gen_kwargs={
	"filepaths": glob.glob(
	os.path.join(data_dir, f"wikilingua_*lingual.val.pk")
	)
	},
	),
	datasets.SplitGenerator(
	name=datasets.Split.TEST,
	gen_kwargs={
	"filepaths": glob.glob(
	os.path.join(data_dir, f"wikilingua_*lingual.test.pk")
	)
	},
	),
	datasets.SplitGenerator(
	name=f"sampled_{datasets.Split.VALIDATION}",
	gen_kwargs={
	"filepaths": glob.glob(
	os.path.join(data_dir, f"wikilingua_*_sampled.val.pk")
	)
	},
	),
	datasets.SplitGenerator(
	name=f"sampled_{datasets.Split.TEST}",
	gen_kwargs={
	"filepaths": glob.glob(
	os.path.join(data_dir, f"wikilingua_*_sampled.test.pk")
	)
	},
	),
	]

	def _generate_examples(self, filepaths):
	"""Yields examples."""
	for filepath in filepaths:
	if (
	self.config.name == WikilinguaModes.MULTILINGUAL
	and WikilinguaModes.CROSSLINGUAL in filepath
	) or (
	self.config.name == WikilinguaModes.CROSSLINGUAL
	and WikilinguaModes.MULTILINGUAL in filepath
	):
	yield from []
	else:

	with open(filepath, "rb") as f:
	data = pickle.load(f)

	for d in data:
	idx = d["id"].replace(".", "-")
	src = d["document"].strip()
	tgt = d["summary"].strip()
	src_lang = d["source"]
	tgt_lang = d["target"]

	# if loading specific language pair, filter for those
	if any(self.config.languages):
	if not (
	src_lang in self.config.languages
	and tgt_lang in self.config.languages
	):
	continue

	# in bridge, we are inerested in L <-> en and L -> L, but not en -> en
	if self.config.mode == WikilinguaModes.BRIDGE:
	if src_lang == "en" and tgt_lang == "en":
	continue

	yield idx, {
	"gem_id": idx,
	"gem_parent_id": idx,
	"source_language": src_lang,
	"target_language": tgt_lang,
	"source": src,
	"target": tgt,
	"references": [tgt],
	}