Update data loader for v2

wiki_lingua.py

@@ -15,6 +15,9 @@
 """WikiLingua: A benchmark dataset for multilingual abstractive summarization."""
 
 import os
+import glob
+import pickle
+import re
 import datasets
 
 
@@ -40,100 +43,105 @@ _HOMEPAGE = "https://github.com/esdurmus/Wikilingua"
 
 _LICENSE = "CC BY-NC-SA 3.0"
 
-# TODO update script with new splits
-_URLs = {
-    "wiki_lingua_es_en_v0": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua.zip",
-    },
-    "wiki_lingua_ru_en_v0": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua.zip",
-    },
-    "wiki_lingua_tr_en_v0": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua.zip",
-    },
-    "wiki_lingua_vi_en_v0": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua.zip",
-    },
-    "wiki_lingua_arabic_ar": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/arabic.zip",
-    },
-    "wiki_lingua_chinese_zh": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/chinese.zip",
-    },
-    "wiki_lingua_czech_cs": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/czech.zip",
-    },
-    "wiki_lingua_dutch_nl": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/dutch.zip",
-    },
-    "wiki_lingua_english_en": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/english.zip",
-    },
-    "wiki_lingua_french_fr": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/french.zip",
-    },
-    "wiki_lingua_german_de": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/german.zip",
-    },
-    "wiki_lingua_hindi_hi": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/hindi.zip",
-    },
-    "wiki_lingua_indonesian_id": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/indonesian.zip",
-    },
-    "wiki_lingua_italian_it": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/italian.zip",
-    },
-    "wiki_lingua_japanese_ja": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/japanese.zip",
-    },
-    "wiki_lingua_korean_ko": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/korean.zip",
-    },
-    "wiki_lingua_portuguese_pt": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/portuguese.zip",
-    },
-    "wiki_lingua_russian_ru": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/russian.zip",
-    },
-    "wiki_lingua_spanish_es": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/spanish.zip",
-    },
-    "wiki_lingua_thai_th": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/thai.zip",
-    },
-    "wiki_lingua_turkish_tr": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/turkish.zip",
-    },
-    "wiki_lingua_vietnamese_vi": {
-        "data": "https://storage.googleapis.com/huggingface-nlp/datasets/gem/gem_wikilingua_full/vietnamese.zip",
-    },
+_URL = "./wikilingua_GEM_v2.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",
 }
 
-VERSION = datasets.Version("1.1.0")
+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("_")
-        is_v0 = "v0" in name
-        if is_v0:
-            source_lang, target_lang = eles[-3], eles[-2]
+
+        if name in (WikilinguaModes.MULTILINGUAL, WikilinguaModes.CROSSLINGUAL):
+            self.mode = name
+            self.source_lang = None
+            self.target_lang = None
+            description = f"Wikilingua summarisation data ({self.mode};  all instances)"
         else:
-            target_lang = eles[-1]
-            source_lang = target_lang
+            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=f"Wikilingua summarisation data ({source_lang} to {target_lang})",
+            description=description,
             **kwargs,
         )
-        self.is_v0 = is_v0
-        self.source_lang = source_lang
-        self.target_lang = target_lang
 
 
 class WikiLingua(datasets.GeneratorBasedBuilder):
@@ -143,41 +151,27 @@ class WikiLingua(datasets.GeneratorBasedBuilder):
 
     BUILDER_CONFIGS = [
         WikilinguaConfig(
-            name=lang,
+            name=config_name,
             version=VERSION,
         )
-        for lang in _URLs
+        for config_name in valid_config_names
     ]
 
-    DEFAULT_CONFIG_NAME = "wiki_lingua_es_en_v0"
+    DEFAULT_CONFIG_NAME = "en"
 
     def _info(self):
-        if self.config.is_v0:
-            features = datasets.Features(
-                {
-                    "gem_id": datasets.Value("string"),
-                    "gem_parent_id": datasets.Value("string"),
-                    "source": datasets.Value("string"),
-                    "target": datasets.Value("string"),
-                    "references": [datasets.Value("string")],
-                }
-            )
-        else:
-            lang = self.config.source_lang
-            features = datasets.Features(
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
                 {
                     "gem_id": datasets.Value("string"),
                     "gem_parent_id": datasets.Value("string"),
-                    "source_aligned": datasets.Translation(languages=[lang, "en"]),
-                    "target_aligned": datasets.Translation(languages=[lang, "en"]),
+                    "source_language": datasets.Value("string"),
+                    "target_language": datasets.Value("string"),
                     "source": datasets.Value("string"),
                     "target": datasets.Value("string"),
-                    "references": [datasets.Value("string")],
                 }
-            )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
+            ),
             supervised_keys=None,
             homepage=_HOMEPAGE,
             license=_LICENSE,
@@ -186,109 +180,87 @@ class WikiLingua(datasets.GeneratorBasedBuilder):
 
     def _split_generators(self, dl_manager):
         """Returns SplitGenerators."""
-        dl_dir = dl_manager.download_and_extract(_URLs[self.config.name])
-        if self.config.is_v0:
+        dl_dir = dl_manager.download_and_extract(_URL)
+        data_dir = os.path.join(dl_dir, "GEM_V2")
 
-            lang = self.config.source_lang
-            base_dir = os.path.join(
-                dl_dir["data"], "GEM_data_crosslingual", f"{lang}_en"
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={"filepath": data_dir, "split": "train"},
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={"filepath": data_dir, "split": "validation"},
+            ),
+        ] + [
+            datasets.SplitGenerator(
+                name=re.search("wikilingua_(.+test)", fn).group(1).replace(".", "_"),
+                gen_kwargs={"filepath": fn, "split": "test"},
             )
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "filepath": base_dir,
-                        "split": "train",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={
-                        "filepath": base_dir,
-                        "split": "val",
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "filepath": base_dir,
-                        "split": "test",
-                    },
-                ),
-            ]
-        else:
-            lang = self.config.source_lang
-            lang_name = self.config.name.split("_")[-2]
-            base_dir = os.path.join(dl_dir["data"], lang_name)
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "filepath": base_dir,
-                        "split": "train",
-                        "lang": lang,
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={
-                        "filepath": base_dir,
-                        "split": "val",
-                        "lang": lang,
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "filepath": base_dir,
-                        "split": "test",
-                        "lang": lang,
-                    },
-                ),
-            ]
-
-    def _generate_examples(self, filepath, split, lang=None):
+            for fn in glob.glob(os.path.join(data_dir, "wikilingua_*.test.pk"))
+        ]
+
+    def _generate_examples(self, filepath, split):
         """Yields examples."""
-        if self.config.is_v0:
-            source_path = os.path.join(filepath, f"{split}.src")
-            target_path = os.path.join(filepath, f"{split}.tgt")
-            with open(source_path, encoding="utf-8") as f_in:
-                with open(target_path, encoding="utf-8") as f_out:
-                    for id_, (src, tgt) in enumerate(zip(f_in, f_out)):
-                        yield id_, {
-                            "gem_id": f"{self.config.name}-{split}-{id_}",
-                            "gem_parent_id": f"{self.config.name}-{split}-{id_}",
-                            "source": src.strip(),
-                            "target": tgt.strip(),
-                            "references": [] if split == "train" else [tgt.strip()],
-                        }
+
+        if split == "test":
+            with open(filepath, "rb") as f:
+                data = pickle.load(f)
+                for d in data:
+                    idx = d["id"].replace(".", "-")
+                    yield idx, {
+                        "gem_id": idx,
+                        "gem_parent_id": idx,
+                        "source_language": d["source"],
+                        "target_language": d["target"],
+                        "source": d["document"].strip(),
+                        "target": d["summary"].strip(),
+                    }
         else:
-            source_path = os.path.join(filepath, f"{split}.src.{lang}")
-            source_path_en = os.path.join(filepath, f"{split}.src.en")
-            target_path = os.path.join(filepath, f"{split}.tgt.{lang}")
-            target_path_en = os.path.join(filepath, f"{split}.tgt.en")
-
-            with open(source_path, encoding="utf-8") as f_in_ln:
-                with open(source_path_en, encoding="utf-8") as f_in_en:
-                    with open(target_path, encoding="utf-8") as f_out_ln:
-                        with open(target_path_en, encoding="utf-8") as f_out_en:
-                            for id_, (src_ln, src_en, tgt_ln, tgt_en) in enumerate(
-                                zip(f_in_ln, f_in_en, f_out_ln, f_out_en)
+            # filter data as needed for train & validation sets
+            if split == "validation":
+                filepaths = glob.glob(os.path.join(filepath, "wikilingua_*.val.pk"))
+            else:
+                filepaths = glob.glob(os.path.join(filepath, "wikilingua_*.train.pk"))
+            for filepath in filepaths:
+                # skip files if they are irrelevant to task mode
+                if (
+                    self.config.mode == WikilinguaModes.MULTILINGUAL
+                    and "crosslingual" in filepath
+                ) or (
+                    self.config.mode == WikilinguaModes.CROSSLINGUAL
+                    and "multilingual" in filepath
+                ):
+                    yield from []
+
+                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
                             ):
-                                yield id_, {
-                                    "gem_id": f"{self.config.name}-{split}-{id_}",
-                                    "gem_parent_id": f"{self.config.name}-{split}-{id_}",
-                                    "source_aligned": {
-                                        lang: src_ln.strip(),
-                                        "en": src_en.strip(),
-                                    },
-                                    "target_aligned": {
-                                        lang: tgt_ln.strip(),
-                                        "en": tgt_en.strip(),
-                                    },
-                                    "source": src_ln.strip(),
-                                    "target": tgt_en.strip(),
-                                    "references": []
-                                    if split == "train"
-                                    else [tgt_en.strip()],
-                                }
+                                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,
+                        }