P3.py

# coding=utf-8
# Copyright 2020 BigScience Contributors.
#
# 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.
"""P3 (Public Pool of Prompts)"""


import datasets
import json
import urllib
from collections import defaultdict
import tensorflow as tf


_CITATION = """\
TODO"""

_DESCRIPTION = """\
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).

To train [T0*](https://huggingface.co/bigscience/T0pp), we used a subset of the prompts available in Promptsource (see details [here](https://huggingface.co/bigscience/T0pp#training-data)). However, some of the prompts use `random.choice`, a method that selects uniformly at random an option in a list of valid possibilities. For reproducibility purposes, we release the collection of prompted examples used to train T0*. **The data available here are the materialized version of the prompted datasets used in [Multi-task enables task zero-shot generalization](TODO) which represent only a subset datasets for which there is at least one prompt on Promptsource.**
"""

_LICENSE = "Apache License 2.0"

_HOMEPAGE = "https://github.com/bigscience-workshop/promptsource"

_DATA_PATH = "data"
_HUB_PATH = "https://huggingface.co/datasets/bigscience/P3/raw/main"


logger = datasets.logging.get_logger(__name__)


def load_cached_task(features_dict, tfrecord):
    # 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_dict.items()
    }

    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., int32 is stored as int64).
    ds = ds.map(
        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 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)
        logger.info(f"Downloaded {url}")
    except urllib.error.URLError as e:
        raise ConnectionError(e)
    return content.read().decode("utf-8")


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_split_sizes = read_from_url(f"{_HUB_PATH}/data_split_sizes.csv")
    data_split_sizes = [t.strip() for t in data_split_sizes.splitlines()]
    data_split_sizes = data_split_sizes[1:]
    data_split_sizes = [t.split("|") for t in data_split_sizes]
    data_split_sizes = [(t[0], json.loads(t[1])) for t in data_split_sizes]

    for task_name, split_sizes in data_split_sizes:
        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 -> handle multiple shards

            if not task_splits_and_features[task_name]:
                task_splits_and_features[task_name] = {
                    "splits": [],
                    "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"]

    return 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", # TODO -> handle multiple shards
        }
        for split_name in splits_and_features_dict["splits"]
    }
    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_dict, score_eval, **kwargs):
        """BuilderConfig for P3.

        Args:
          splits: `List[str]`, the lists of splits which are available 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.
        """
        # Version history:
        # 0.1 initial commit
        super(P3Config, self).__init__(version=datasets.Version("0.1.0"), **kwargs)
        self.splits = splits
        self.features_dict = features_dict
        self.score_eval = score_eval


class P3(datasets.GeneratorBasedBuilder):
    """Subset of P3 used in `Multitask Prompted Training Enables Zero-Shot Task Generalization`"""

    BUILDER_CONFIGS = [
        P3Config(
            name=task_name,
            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_dict in _TASK_SPLITS_AND_FEATURES_DICT.items()
    ]

    def _info(self):
        # All features available are: 'inputs', 'inputs_pretokenized', 'targets',
        # 'targets_pretokenized', 'idx', 'is_correct', 'weight', and 'answer_choices'
        _FEAT_MAPPING = {
            "answer_choices": datasets.Sequence(datasets.Value("string")),
            "inputs": datasets.Sequence(datasets.Value("int32")),
            "inputs_pretokenized": datasets.Value("string"),
            "targets": datasets.Sequence(datasets.Value("int32")),
            "targets_pretokenized": datasets.Value("string"),
            "idx": datasets.Sequence(datasets.Value("int32")),
            "weight": datasets.Value("float32"),
            "is_correct": datasets.Value("bool"),
        }

        features = {}
        for feat_name in self.config.features_dict.keys():
            features[feat_name] = _FEAT_MAPPING[feat_name]

        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=datasets.Features(features),
            supervised_keys=None,
            homepage=_HOMEPAGE,
            citation=_CITATION,
            license=_LICENSE,
        )

    def _split_generators(self, dl_manager):
        split_generators = []
        data_dir = dl_manager.download_and_extract(_URLs)
        task_name = self.config.name
        if "train" in self.config.splits:
            split_name = "train"
            split_generators.append(
                datasets.SplitGenerator(
                    name=datasets.Split.TRAIN,
                    gen_kwargs={
                        "tfrecord": data_dir[task_name][split_name]["tfrecord"],
                    }
                )
            )
        if "validation" in self.config.splits:
            split_name = "validation"
            split_generators.append(
                datasets.SplitGenerator(
                    name=datasets.Split.VALIDATION,
                    gen_kwargs={
                        "tfrecord": data_dir[task_name][split_name]["tfrecord"],
                    }
                )
            )
        if "test" in self.config.splits:
            split_name = "test"
            split_generators.append(
                datasets.SplitGenerator(
                    name=datasets.Split.TEST,
                    gen_kwargs={
                        "tfrecord": data_dir[task_name][split_name]["tfrecord"],
                    }
                )
            )
        # Handle splits that are not train, validation or test
        special_splits = set(self.config.splits) - set(["train", "validation", "test"])
        for special_split_name in special_splits:
            split_generators.append(
                datasets.SplitGenerator(
                    name=datasets.Split(special_split_name),
                    gen_kwargs={
                        "tfrecord": data_dir[task_name][special_split_name]["tfrecord"],
                    }
                )
            )
        return split_generators


    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],
            "inputs": lambda x: x.tolist(),
            "inputs_pretokenized": lambda x: x.decode("utf-8"),
            "targets": lambda x: x.tolist(),
            "targets_pretokenized": lambda x: x.decode("utf-8"),
            "idx": lambda x: x.tolist(),
            "weight": lambda x: float(x),
            "is_correct": lambda x: x,
        }

        key = 0
        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():
                ex_dict[feat_name] = _FEAT_MAPPING_FUNCTIONS[feat_name](feat_value)
            yield key, ex_dict
            key += 1