Streaming support

P3.py

@@ -14,10 +14,14 @@
 # limitations under the License.
 """P3 (Public Pool of Prompts)"""
 
+import os
+
+import google.protobuf as _protobuf
 
 import datasets
-import tensorflow as tf
 
+from ._tfrecord_example_pb2 import SequenceExample
+from .io_utils import iterate_tfrecord_file, parse_tfrecord_sequence_example
 from .tasks_splits_and_features import _TASK_SPLITS_AND_FEATURES_DICT
 
 
@@ -44,44 +48,14 @@ _HOMEPAGE = "https://github.com/bigscience-workshop/promptsource"
 
 _DATA_PATH = "data"
 
-
 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(tfrecord)
-    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
-
-
 _URLs = {
     task_name: {
         split_name: [
-            f"{_DATA_PATH}/{task_name}/{split_name}.tfrecord-00000-of-00001",  # TODO -> handle multiple shards
+            os.path.join(
+                _DATA_PATH, task_name, split_name + ".tfrecord-00000-of-00001"
+            ),  # TODO -> handle multiple shards
         ]
         for split_name in splits_and_features_dict["splits"]
     }
@@ -117,7 +91,7 @@ class P3(datasets.GeneratorBasedBuilder):
             name=task_name,
             splits=splits_and_features_dict["splits"],
             features_dict=splits_and_features_dict["features_dict"],
-            score_eval=task_name.endswith("score_eval")
+            score_eval=task_name.endswith("score_eval"),
         )
         for task_name, splits_and_features_dict in _TASK_SPLITS_AND_FEATURES_DICT.items()
     ]
@@ -136,10 +110,7 @@ class P3(datasets.GeneratorBasedBuilder):
             "is_correct": datasets.Value("bool"),
         }
 
-        features = {}
-        for feat_name in self.config.features_dict.keys():
-            features[feat_name] = _FEAT_MAPPING[feat_name]
-
+        features = {feat_name: _FEAT_MAPPING[feat_name] for feat_name in self.config.features_dict.keys()}
         return datasets.DatasetInfo(
             description=_DESCRIPTION,
             features=datasets.Features(features),
@@ -158,8 +129,8 @@ class P3(datasets.GeneratorBasedBuilder):
                 datasets.SplitGenerator(
                     name=datasets.Split.TRAIN,
                     gen_kwargs={
-                        "tfrecord": data_dir[split_name],
-                    }
+                        "tfrecord_files": data_dir[split_name],
+                    },
                 )
             )
         if "validation" in self.config.splits:
@@ -168,8 +139,8 @@ class P3(datasets.GeneratorBasedBuilder):
                 datasets.SplitGenerator(
                     name=datasets.Split.VALIDATION,
                     gen_kwargs={
-                        "tfrecord": data_dir[split_name],
-                    }
+                        "tfrecord_files": data_dir[split_name],
+                    },
                 )
             )
         if "test" in self.config.splits:
@@ -178,8 +149,8 @@ class P3(datasets.GeneratorBasedBuilder):
                 datasets.SplitGenerator(
                     name=datasets.Split.TEST,
                     gen_kwargs={
-                        "tfrecord": data_dir[split_name],
-                    }
+                        "tfrecord_files": data_dir[split_name],
+                    },
                 )
             )
         # Handle splits that are not train, validation or test
@@ -190,32 +161,42 @@ class P3(datasets.GeneratorBasedBuilder):
                     name=datasets.Split(special_split_name),
                     gen_kwargs={
                         "tfrecord": data_dir[special_split_name],
-                    }
+                    },
                 )
             )
         return split_generators
 
-
-    def _generate_examples(self, tfrecord):
+    def _generate_examples(self, tfrecord_files):
         """This function returns the examples in the raw (text) form."""
-        _FEAT_MAPPING_FUNCTIONS = {
+        _POST_PROC_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"),
+            "inputs_pretokenized": lambda x: x[0].decode("utf-8"),
             "targets": lambda x: x.tolist(),
-            "targets_pretokenized": lambda x: x.decode("utf-8"),
+            "targets_pretokenized": lambda x: x[0].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
+        def _prepare_col_spec(shape, dtype):
+            if dtype in ("int32", "bool"):
+                # int32 and bool are stored as int64 in the tf.train.Example protobuf.
+                dtype = "int64"
+            elif dtype == "string":
+                dtype = "str"
+            if shape and shape[0] is None:
+                shape = (-1, *shape[1:])
+            return (shape, dtype)
+
+        spec = {k: _prepare_col_spec(**v) for k, v in self.config.features_dict.items()}
+        idx = 0
+        for tfrecord_file in tfrecord_files:
+            with open(tfrecord_file, "rb") as f:
+                for example_bytes in iterate_tfrecord_file(f):
+                    example = SequenceExample()
+                    example.ParseFromString(example_bytes)
+                    example = parse_tfrecord_sequence_example(example, spec)
+                    example = {k: _POST_PROC_FUNCTIONS[k](v) for k, v in example.items()}
+                    yield idx, example
+                    idx += 1

_tfrecord_example_pb2.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50e227d1c6e389901c2ec71b36b8d73b0b7711b14c42962a837f01c197056f2c
+size 21378

io_utils.py

@@ -0,0 +1,166 @@
+# Code copied from: https://github.com/pytorch/data/blob/d9bbbecf64d0149795dc65ba390b50bc9e176e95/torchdata/datapipes/iter/util/tfrecordloader.py
+
+import struct
+from functools import partial
+from io import BufferedIOBase
+from typing import Any, Dict, Iterator, List, NamedTuple, Optional, Tuple, Union, cast
+
+import numpy as np
+
+
+try:
+    from math import prod
+except ImportError:
+    import operator
+    from functools import reduce
+
+    def prod(xs):
+        return reduce(operator.mul, xs, 1)
+
+
+U = Union[bytes, bytearray, str]
+TFRecordFeatureSpec = Tuple[Tuple[int, ...], Union[str, np.dtype]]
+TFRecordExampleSpec = Dict[str, TFRecordFeatureSpec]
+
+#  Note, reccursive types not supported by mypy at the moment
+# TODO(640): uncomment as soon as it becomes supported
+#  https://github.com/python/mypy/issues/731
+#  BinaryData = Union[str, List['BinaryData']]
+TFRecordBinaryData = Union[str, List[str], List[List[str]], List[List[List[Any]]]]
+TFRecordExampleFeature = Union[np.ndarray, List[np.ndarray], TFRecordBinaryData]
+TFRecordExample = Dict[str, TFRecordExampleFeature]
+
+
+class SequenceExampleSpec(NamedTuple):
+    context: TFRecordExampleSpec
+    feature_lists: TFRecordExampleSpec
+
+
+def iterate_tfrecord_file(data: BufferedIOBase) -> Iterator[memoryview]:
+    length_bytes = bytearray(8)
+    crc_bytes = bytearray(4)
+    data_bytes = bytearray(1024)
+
+    while True:
+        bytes_read = data.readinto(length_bytes)
+        if bytes_read == 0:
+            break
+        elif bytes_read != 8:
+            raise RuntimeError("Invalid tfrecord file: failed to read the record size.")
+        if data.readinto(crc_bytes) != 4:
+            raise RuntimeError("Invalid tfrecord file: failed to read the start token.")
+        (length,) = struct.unpack("<Q", length_bytes)
+        if length > len(data_bytes):
+            data_bytes = data_bytes.zfill(int(length * 1.5))
+        data_bytes_view = memoryview(data_bytes)[:length]
+        if data.readinto(data_bytes_view) != length:
+            raise RuntimeError("Invalid tfrecord file: failed to read the record.")
+        if data.readinto(crc_bytes) != 4:
+            raise RuntimeError("Invalid tfrecord file: failed to read the end token.")
+
+        # TODO(641): check CRC
+        yield data_bytes_view
+
+
+def process_feature(feature) -> np.ndarray:
+    # NOTE: We assume that each key in the example has only one field
+    # (either "bytes_list", "float_list", or "int64_list")!
+    field = feature.ListFields()[0]
+    inferred_typename, value = field[0].name, field[1].value
+    if inferred_typename == "bytes_list":
+        pass
+    elif inferred_typename == "float_list":
+        value = np.array(value, dtype=np.float32)
+    elif inferred_typename == "int64_list":
+        value = np.array(value, dtype=np.int64)
+    return value
+
+
+def _reshape_list(value, shape):
+    # Flatten list
+    flat_list = []
+
+    def flatten(value):
+        if isinstance(value, (str, bytes)):
+            flat_list.append(value)
+        else:
+            for x in value:
+                flatten(x)
+
+    flatten(value)
+
+    # Compute correct shape
+    common_divisor = prod(x for x in shape if x != -1)
+    if sum(1 for x in shape if x == -1) > 1:
+        raise RuntimeError("Shape can contain at most one dynamic dimension (-1).")
+    if len(flat_list) % max(common_divisor, 1) != 0:
+        raise RuntimeError(f"Cannot reshape {len(flat_list)} values into shape {shape}")
+    shape = [x if x != -1 else (len(flat_list) // common_divisor) for x in shape]
+
+    # Reshape list into the correct shape
+    def _reshape(value, shape):
+        if len(shape) == 0:
+            assert len(value) == 1
+            return value[0]
+        elif len(shape) == 1:  # To make the reccursion faster
+            assert len(value) == shape[0]
+            return value
+        dim_size = len(value) // shape[0]
+        return [_reshape(value[i * dim_size : (i + 1) * dim_size], shape[1:]) for i in range(dim_size)]
+
+    return _reshape(flat_list, shape)
+
+
+def _apply_feature_spec(value, feature_spec):
+    if isinstance(value, np.ndarray):
+        if feature_spec is not None:
+            shape, dtype = feature_spec
+            if isinstance(dtype, (str, np.dtype)):
+                if shape:
+                    value = value.reshape(shape)
+                value = value.astype(dtype)
+            elif shape:
+                # Manual list reshape
+                value = _reshape_list(value, shape)
+    return value
+
+
+def _parse_tfrecord_features(features, spec: Optional[TFRecordExampleSpec]) -> Dict[str, np.ndarray]:
+    result = {}
+    features = features.feature
+    for key in features.keys():
+        if spec is not None and key not in spec:
+            continue
+        feature_spec = None if spec is None else spec[key]
+        feature = features[key]
+        result[key] = _apply_feature_spec(process_feature(feature), feature_spec)
+    return result
+
+
+def parse_tfrecord_sequence_example(example, spec: Optional[TFRecordExampleSpec]) -> TFRecordExample:
+    # Parse context features
+    result = cast(TFRecordExample, _parse_tfrecord_features(example.context, spec))
+
+    # Parse feature lists
+    feature_lists_keys = None if spec is None else set(spec.keys()) - set(result.keys())
+    features = example.feature_lists.feature_list
+    for key in features.keys():
+        if feature_lists_keys is not None and key not in feature_lists_keys:
+            continue
+        feature_spec = None if spec is None else spec[key]
+        feature = features[key].feature
+        if key in result:
+            raise RuntimeError(
+                "TFRecord example's key {key} is contained in both the context and feature lists. This is not supported."
+            )
+
+        value: Union[np.ndarray, List[Any]] = list(map(partial(process_feature), feature))
+
+        # For known numpy dtypes, we stack the list features
+        if feature_spec is not None and isinstance(feature_spec[1], (str, np.dtype)):
+            value = np.stack(cast(List[np.ndarray], value), 0)
+        value = _apply_feature_spec(value, feature_spec)
+        result[key] = value
+    if spec is not None and len(result.keys()) != len(spec.keys()):
+        raise RuntimeError(f"Example is missing some required keys: {sorted(result.keys())} != {sorted(spec.keys())}")
+    return result

print_data_split_sizes.py

@@ -1,9 +1,9 @@
 import glob
 import json
 import os
-
 from collections import defaultdict
 
+
 _DATA_PATH = "data"
 
 data_split_sizes = defaultdict(dict)