Datasets:

Tasks:
Other
Modalities:
Text
Formats:
parquet
Languages:
English
ArXiv:
Libraries:
Datasets
Dask
License:
P3 / io_utils.py
mariosasko's picture
Streaming support (#11)
1e02208
raw
history blame
6.28 kB
# 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