converging

P3.py

@@ -16,9 +16,8 @@
 
 
 import datasets
-import glob
 import json
-import os
+import urllib
 from collections import defaultdict
 import tensorflow as tf
 
@@ -27,7 +26,7 @@ _CITATION = """\
 TODO"""
 
 _DESCRIPTION = """\
-P3 (Pubic Pool of Prompts)is a collection of prompted English datasets covering a diverse set of NLP tasks. A prompt is the combination of an input template and a target template. The templates are functions mapping a data example into natural language for the input and target sequences. For example, in the case of an NLI dataset, the data example would include fields for *Premise, Hypothesis, Label*. An input template would be *If {Premise} is true, is it also true that {Hypothesis}?*, whereas a target template can be defined with the label choices *Choices[label]*. Here *Choices* is prompt-specific metadata that consists of the options *yes, maybe, no* corresponding to *label* being entailment (0), neutral (1) or contradiction (2).
+P3 (Public Pool of Prompts)is a collection of prompted English datasets covering a diverse set of NLP tasks. A prompt is the combination of an input template and a target template. The templates are functions mapping a data example into natural language for the input and target sequences. For example, in the case of an NLI dataset, the data example would include fields for *Premise, Hypothesis, Label*. An input template would be *If {Premise} is true, is it also true that {Hypothesis}?*, whereas a target template can be defined with the label choices *Choices[label]*. Here *Choices* is prompt-specific metadata that consists of the options *yes, maybe, no* corresponding to *label* being entailment (0), neutral (1) or contradiction (2).
 
 Prompts are collected using [Promptsource](https://github.com/bigscience-workshop/promptsource), an interface to interactively write prompts on datasets, and collect prompt-specific metadata such as evaluation metrics. As of October 13th, there are 2'000 prompts collected for 270+ data(sub)sets. The collection of prompts is publicly available on [Promptsource](https://github.com/bigscience-workshop/promptsource).
 
@@ -38,53 +37,11 @@ _LICENSE = "Apache License 2.0"
 
 _HOMEPAGE = "https://github.com/bigscience-workshop/promptsource"
 
-_DATA_PATH = "data"
-
-
-# def load_cached_task(cache_dir, split):
-#     # TODO(Victor): this info.*.json is actually done twice... -> factorize
-#     with tf.io.gfile.GFile(os.path.join(cache_dir, f"info.{split}.json")) as f:
-#         split_info = json.load(f)
-#         features = split_info["features"]
-
-#     # Use `FixedLenSequenceFeature` for sequences with variable length.
-#     def _feature_config(shape, dtype):
-#         if dtype in ("int32", "bool"):
-#             # int32 and bool are stored as int64 in the tf.train.Example protobuf.
-#             dtype = "int64"
-#         if shape and shape[0] is None:
-#             return tf.io.FixedLenSequenceFeature(
-#                 shape[1:], dtype, allow_missing=True
-#             )
-#         return tf.io.FixedLenFeature(shape, dtype)
-
-#     feature_description = {
-#         feat: _feature_config(**desc) for feat, desc in features.items()
-#     }
-
-#     tfrecords = os.path.join(
-#         cache_dir, f"{split}.tfrecord-*-of-*{split_info['num_shards']}"
-#     )
-#     ds = tf.data.TFRecordDataset(tf.io.gfile.glob(tfrecords))
-#     ds = ds.map(
-#         lambda pb: tf.io.parse_single_example(pb, feature_description),
-#         num_parallel_calls=tf.data.experimental.AUTOTUNE
-#     )
-#     # Cast features back to the types from the info JSON since some features
-#     # must be cast for storage (e.g., in32 is stored as int64).
-#     ds = ds.map(
-#         lambda x: {k: tf.cast(v, features[k]["dtype"]) for k, v in x.items()},
-#         num_parallel_calls=tf.data.experimental.AUTOTUNE
-#     )
-#     return ds
-
-def load_cached_task(features_file, tfrecord):
-    # # TODO(Victor): this info.*.json is actually done twice... -> factorize
-    # with tf.io.gfile.GFile(os.path.join(cache_dir, f"info.{split}.json")) as f:
-    with tf.io.gfile.GFile(features_file) as f:
-        split_info = json.load(f)
-        features = split_info["features"]
+_DATA_PATH = "/home/hf/P3/data"
+_HUB_PATH = "https://huggingface.co/datasets/bigscience/P3/raw/main"
 
+
+def load_cached_task(features_dict, tfrecord):
     # Use `FixedLenSequenceFeature` for sequences with variable length.
     def _feature_config(shape, dtype):
         if dtype in ("int32", "bool"):
@@ -97,81 +54,88 @@ def load_cached_task(features_file, tfrecord):
         return tf.io.FixedLenFeature(shape, dtype)
 
     feature_description = {
-        feat: _feature_config(**desc) for feat, desc in features.items()
+        feat: _feature_config(**desc) for feat, desc in features_dict.items()
     }
 
-    ds = tf.data.TFRecordDataset(tf.io.gfile.glob([tfrecord]))
+    ds = tf.data.TFRecordDataset(tf.io.gfile.glob([tfrecord])) #TODO handle multiple shards
     ds = ds.map(
         lambda pb: tf.io.parse_single_example(pb, feature_description),
         num_parallel_calls=tf.data.experimental.AUTOTUNE
     )
     # Cast features back to the types from the info JSON since some features
-    # must be cast for storage (e.g., in32 is stored as int64).
+    # must be cast for storage (e.g., int32 is stored as int64).
     ds = ds.map(
-        lambda x: {k: tf.cast(v, features[k]["dtype"]) for k, v in x.items()},
+        lambda x: {k: tf.cast(v, features_dict[k]["dtype"]) for k, v in x.items()},
         num_parallel_calls=tf.data.experimental.AUTOTUNE
     )
     return ds
 
 
-def find_task_splits_and_features():
-    """Find the available tasks under ./data and their available splits and features."""
-    task_and_their_splits = defaultdict(dict)
-    for stats in glob.glob(f"{_DATA_PATH}/*/stats.*.json"):
-        folder_path = os.path.dirname(stats)
-        task_name = folder_path.split("/")[-1]
-        split_name = os.path.basename(stats).split(".")[1]
+def read_from_url(url):
+    # TODO: there might be a better way to handle these downloads (especially regarding caching).
+    # TODO: Ultimately, we should rely on the cache if internet is not available.
+    try:
+        content = urllib.request.urlopen(url, timeout=10.0)
+    except urllib.error.URLError as e:
+        raise ConnectionError(e)
+    return content.read().decode("utf-8")
 
-        if not os.path.exists(f"{folder_path}/COMPLETED"):
-            continue
 
-        with open(stats, "r") as f:
-            split_stats = json.load(f)
-            nb_examples = split_stats["examples"]
+def find_task_splits_and_features_dict():
+    """Get the task available (list was pre-computed by `print_data_split_sizes.py`), and get the features for each task."""
+    task_splits_and_features = defaultdict(dict)
+
+    data = read_from_url(f"{_HUB_PATH}/data_split_sizes.csv")
+    data = [t.strip() for t in data.splitlines()]
+    data = data[1:]
+    data = [t.split("|") for t in data]
+    data = [(t[0], json.loads(t[1])) for t in data]
+
+    for task_name, split_sizes in data:
+        if "adversarial_qa" not in task_name: #TODO remove
+            continue
 
-        if nb_examples > 0:
-            with open(os.path.join(folder_path, f"info.{split_name}.json")) as f:
-                split_info = json.load(f)
-                features = split_info["features"]
-                assert split_info["num_shards"] == 1
+        for split_name in split_sizes.keys():
+            split_info = json.loads(
+                read_from_url(
+                    f"{_HUB_PATH}/data/{task_name}/info.{split_name}.json"
+                )
+            )
+            features_dict = split_info["features"]
+            assert split_info["num_shards"] == 1 #TODO -> change to multiple shards
 
-            # All splits under the same task have the same features dictionary (and thus the same features list)
-            if task_and_their_splits[task_name] == {}:
-                task_and_their_splits[task_name] = {
+            if not task_splits_and_features[task_name]:
+                task_splits_and_features[task_name] = {
                     "splits": [],
-                    "features": [],
+                    "features_dict": features_dict,
                 }
+            task_splits_and_features[task_name]["splits"].append(split_name)
+            assert features_dict == task_splits_and_features[task_name]["features_dict"]
 
-            task_and_their_splits[task_name]["splits"].append(split_name)
-            if task_and_their_splits[task_name]["features"] == []:
-                task_and_their_splits[task_name]["features"] = sorted(list(features.keys()))
-            else:
-                assert task_and_their_splits[task_name]["features"] == sorted(list(features.keys()))
-    return task_and_their_splits
+    return task_splits_and_features
 
 
-_TASK_SPLITS_AND_FEATURES = find_task_splits_and_features()
+_TASK_SPLITS_AND_FEATURES_DICT = find_task_splits_and_features_dict()
 _URLs = {
     task_name: {
         split_name: {
             "tfrecord": f"{_DATA_PATH}/{task_name}/{split_name}.tfrecord-00000-of-00001",
-            "features_file": f"{_DATA_PATH}/{task_name}/info.{split_name}.json",
         }
-        for split_name in splits_and_features["splits"]
+        for split_name in splits_and_features_dict["splits"]
     }
-    for task_name, splits_and_features in _TASK_SPLITS_AND_FEATURES.items()
+    for task_name, splits_and_features_dict in _TASK_SPLITS_AND_FEATURES_DICT.items()
 }
 
 
 class P3Config(datasets.BuilderConfig):
     """BuilderConfig for P3."""
 
-    def __init__(self, splits, features, score_eval, **kwargs):
+    def __init__(self, splits, features_dict, score_eval, **kwargs):
         """BuilderConfig for P3.
 
         Args:
           splits: `List[str]`, the lists of splits which are available for this task
-          features: `List[str]`, the list of features for this task
+          features_dict: `dict`, the dict of features for this task
           score_eval: `bool`, whether this is task formulated as a rank classification problem
           **kwargs: keyword arguments forwarded to super.
         """
@@ -179,7 +143,7 @@ class P3Config(datasets.BuilderConfig):
         # 0.1 initial commit
         super(P3Config, self).__init__(version=datasets.Version("0.1.0"), **kwargs)
         self.splits = splits
-        self.features = features
+        self.features_dict = features_dict
         self.score_eval = score_eval
 
 
@@ -189,11 +153,11 @@ class P3(datasets.GeneratorBasedBuilder):
     BUILDER_CONFIGS = [
         P3Config(
             name=task_name,
-            splits=splits_and_features["splits"],
-            features=splits_and_features["features"],
+            splits=splits_and_features_dict["splits"],
+            features_dict=splits_and_features_dict["features_dict"],
             score_eval=task_name.endswith("score_eval")
         )
-        for task_name, splits_and_features in _TASK_SPLITS_AND_FEATURES.items()
+        for task_name, splits_and_features_dict in _TASK_SPLITS_AND_FEATURES_DICT.items()
     ]
 
     def _info(self):
@@ -211,7 +175,7 @@ class P3(datasets.GeneratorBasedBuilder):
         }
 
         features = {}
-        for feat_name in self.config.features:
+        for feat_name in self.config.features_dict.keys():
             features[feat_name] = _FEAT_MAPPING[feat_name]
 
         return datasets.DatasetInfo(
@@ -233,7 +197,6 @@ class P3(datasets.GeneratorBasedBuilder):
                 datasets.SplitGenerator(
                     name=datasets.Split.TRAIN,
                     gen_kwargs={
-                        "features_file": data_dir[task_name][split_name]["features_file"],
                         "tfrecord": data_dir[task_name][split_name]["tfrecord"],
                     }
                 )
@@ -244,7 +207,6 @@ class P3(datasets.GeneratorBasedBuilder):
                 datasets.SplitGenerator(
                     name=datasets.Split.VALIDATION,
                     gen_kwargs={
-                        "features_file": data_dir[task_name][split_name]["features_file"],
                         "tfrecord": data_dir[task_name][split_name]["tfrecord"],
                     }
                 )
@@ -255,7 +217,6 @@ class P3(datasets.GeneratorBasedBuilder):
                 datasets.SplitGenerator(
                     name=datasets.Split.TEST,
                     gen_kwargs={
-                        "features_file": data_dir[task_name][split_name]["features_file"],
                         "tfrecord": data_dir[task_name][split_name]["tfrecord"],
                     }
                 )
@@ -267,7 +228,6 @@ class P3(datasets.GeneratorBasedBuilder):
                 datasets.SplitGenerator(
                     name=datasets.Split(special_split_name),
                     gen_kwargs={
-                        "features_file": data_dir[task_name][special_split_name]["features_file"],
                         "tfrecord": data_dir[task_name][special_split_name]["tfrecord"],
                     }
                 )
@@ -275,7 +235,7 @@ class P3(datasets.GeneratorBasedBuilder):
         return split_generators
 
 
-    def _generate_examples(self, features_file, tfrecord):
+    def _generate_examples(self, tfrecord):
         """This function returns the examples in the raw (text) form."""
         _FEAT_MAPPING_FUNCTIONS = {
             "answer_choices": lambda x: [choice.decode("utf-8") for choice in x],
@@ -289,7 +249,9 @@ class P3(datasets.GeneratorBasedBuilder):
         }
 
         key = 0
-        ds = load_cached_task(features_file, tfrecord)
+        features_dict = self.config.features_dict
+        ds = load_cached_task(features_dict, tfrecord)
+
         for ex in ds.as_numpy_iterator():
             ex_dict = {}
             for feat_name, feat_value in ex.items():

print_data_split_sizes.py

@@ -0,0 +1,30 @@
+import glob
+import json
+import os
+
+from collections import defaultdict
+
+_DATA_PATH = "data"
+
+data_split_sizes = defaultdict(dict)
+
+for stats in glob.glob(f"{_DATA_PATH}/*/stats.*.json"):
+    folder_path = os.path.dirname(stats)
+    task_name = folder_path.split("/")[-1]
+    split_name = os.path.basename(stats).split(".")[1]
+
+    if not os.path.exists(f"{folder_path}/COMPLETED"):
+        continue
+
+    with open(stats, "r") as f:
+        split_stats = json.load(f)
+        nb_examples = split_stats["examples"]
+
+    if nb_examples > 0:
+        data_split_sizes[task_name][split_name] = nb_examples
+
+with open("data_split_sizes.csv", "w", encoding="utf=8") as f:
+    f.write("Data(sub)set|Number of examples per splits\n")
+    for task_name in sorted(list(data_split_sizes.keys())):
+        split_sizes_dict = json.dumps(data_split_sizes[task_name])
+        f.write(f"{task_name}|{split_sizes_dict}\n")