Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+rlds_builder/Real_Data/Real_Data/real_data/1.0.0/real_data-train.tfrecord-00000-of-00004 filter=lfs diff=lfs merge=lfs -text
+rlds_builder/Real_Data/Real_Data/real_data/1.0.0/real_data-train.tfrecord-00001-of-00004 filter=lfs diff=lfs merge=lfs -text
+rlds_builder/Real_Data/Real_Data/real_data/1.0.0/real_data-train.tfrecord-00002-of-00004 filter=lfs diff=lfs merge=lfs -text
+rlds_builder/Real_Data/Real_Data/real_data/1.0.0/real_data-train.tfrecord-00003-of-00004 filter=lfs diff=lfs merge=lfs -text

rlds_builder/Real_Data/CITATIONS.bib

@@ -0,0 +1 @@
+// TODO(example_dataset): BibTeX citation

rlds_builder/Real_Data/Real_Data/real_data/1.0.0/dataset_info.json

@@ -0,0 +1,23 @@
+{
+  "citation": "// TODO(example_dataset): BibTeX citation",
+  "fileFormat": "tfrecord",
+  "moduleName": "Real_Data.Real_Data_dataset_builder",
+  "name": "real_data",
+  "releaseNotes": {
+    "1.0.0": "Initial release."
+  },
+  "splits": [
+    {
+      "filepathTemplate": "{DATASET}-{SPLIT}.{FILEFORMAT}-{SHARD_X_OF_Y}",
+      "name": "train",
+      "numBytes": "477887299",
+      "shardLengths": [
+        "38",
+        "37",
+        "37",
+        "38"
+      ]
+    }
+  ],
+  "version": "1.0.0"
+}

rlds_builder/Real_Data/Real_Data/real_data/1.0.0/dataset_statistics_a9dbd4ee3dcfde17e90cbcdad0aed828455451659e0761bd7ad79e36836077d4.json

@@ -0,0 +1 @@
+{"action": {"mean": [-0.00021713033493142575, 3.951489816245157e-06, -6.244335236260667e-05, 0.024315927177667618, -0.024200621992349625, 0.0001426006929250434, -0.1762954145669937], "std": [0.005905783269554377, 0.010097788646817207, 0.005760197062045336, 0.9473578929901123, 0.9439426064491272, 0.028618143871426582, 0.9843310117721558], "max": [0.0263775996863842, 0.02954130433499813, 0.02553696744143963, 4.978769779205322, 5.3642754554748535, 0.4048313796520233, 1.0], "min": [-0.029638897627592087, -0.029703686013817787, -0.024002285674214363, -4.92792272567749, -5.274268627166748, -0.44714170694351196, -1.0], "q01": [-0.018638468496501446, -0.0258210021071136, -0.012519038049504161, -4.446948285102844, -4.433915729522705, -0.08356364756822586, -1.0], "q99": [0.017138871438801287, 0.025166765898466083, 0.02048220705240963, 4.4373928689956665, 4.42347291469574, 0.08423277527093823, 1.0]}, "proprio": {"mean": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], "std": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], "max": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], "min": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], "q01": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], "q99": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]}, "num_transitions": 20148, "num_trajectories": 150}

rlds_builder/Real_Data/Real_Data/real_data/1.0.0/features.json

@@ -0,0 +1,168 @@
+{
+    "pythonClassName": "tensorflow_datasets.core.features.features_dict.FeaturesDict",
+    "featuresDict": {
+        "features": {
+            "episode_metadata": {
+                "pythonClassName": "tensorflow_datasets.core.features.features_dict.FeaturesDict",
+                "featuresDict": {
+                    "features": {
+                        "file_path": {
+                            "pythonClassName": "tensorflow_datasets.core.features.text_feature.Text",
+                            "text": {},
+                            "description": "Path to the original data file."
+                        }
+                    }
+                }
+            },
+            "steps": {
+                "pythonClassName": "tensorflow_datasets.core.features.dataset_feature.Dataset",
+                "sequence": {
+                    "feature": {
+                        "pythonClassName": "tensorflow_datasets.core.features.features_dict.FeaturesDict",
+                        "featuresDict": {
+                            "features": {
+                                "is_first": {
+                                    "pythonClassName": "tensorflow_datasets.core.features.scalar.Scalar",
+                                    "tensor": {
+                                        "shape": {},
+                                        "dtype": "bool",
+                                        "encoding": "none"
+                                    },
+                                    "description": "True on first step of the episode."
+                                },
+                                "action": {
+                                    "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+                                    "tensor": {
+                                        "shape": {
+                                            "dimensions": [
+                                                "7"
+                                            ]
+                                        },
+                                        "dtype": "float32",
+                                        "encoding": "none"
+                                    },
+                                    "description": "Robot EEF action."
+                                },
+                                "is_last": {
+                                    "pythonClassName": "tensorflow_datasets.core.features.scalar.Scalar",
+                                    "tensor": {
+                                        "shape": {},
+                                        "dtype": "bool",
+                                        "encoding": "none"
+                                    },
+                                    "description": "True on last step of the episode."
+                                },
+                                "is_terminal": {
+                                    "pythonClassName": "tensorflow_datasets.core.features.scalar.Scalar",
+                                    "tensor": {
+                                        "shape": {},
+                                        "dtype": "bool",
+                                        "encoding": "none"
+                                    },
+                                    "description": "True on last step of the episode if it is a terminal step, True for demos."
+                                },
+                                "language_instruction": {
+                                    "pythonClassName": "tensorflow_datasets.core.features.text_feature.Text",
+                                    "text": {},
+                                    "description": "Language Instruction."
+                                },
+                                "discount": {
+                                    "pythonClassName": "tensorflow_datasets.core.features.scalar.Scalar",
+                                    "tensor": {
+                                        "shape": {},
+                                        "dtype": "float32",
+                                        "encoding": "none"
+                                    },
+                                    "description": "Discount if provided, default to 1."
+                                },
+                                "observation": {
+                                    "pythonClassName": "tensorflow_datasets.core.features.features_dict.FeaturesDict",
+                                    "featuresDict": {
+                                        "features": {
+                                            "joint_state": {
+                                                "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+                                                "tensor": {
+                                                    "shape": {
+                                                        "dimensions": [
+                                                            "7"
+                                                        ]
+                                                    },
+                                                    "dtype": "float32",
+                                                    "encoding": "none"
+                                                },
+                                                "description": "Robot joint angles."
+                                            },
+                                            "state": {
+                                                "pythonClassName": "tensorflow_datasets.core.features.tensor_feature.Tensor",
+                                                "tensor": {
+                                                    "shape": {
+                                                        "dimensions": [
+                                                            "8"
+                                                        ]
+                                                    },
+                                                    "dtype": "float32",
+                                                    "encoding": "none"
+                                                },
+                                                "description": "Robot EEF state (6D pose, 2D gripper)."
+                                            },
+                                            "image": {
+                                                "pythonClassName": "tensorflow_datasets.core.features.image_feature.Image",
+                                                "image": {
+                                                    "shape": {
+                                                        "dimensions": [
+                                                            "256",
+                                                            "256",
+                                                            "3"
+                                                        ]
+                                                    },
+                                                    "dtype": "uint8",
+                                                    "encodingFormat": "jpeg"
+                                                },
+                                                "description": "Main camera RGB observation."
+                                            },
+                                            "image_reasoning": {
+                                                "pythonClassName": "tensorflow_datasets.core.features.text_feature.Text",
+                                                "text": {},
+                                                "description": "scene objects as dictionary of bbox and seg index in Main camera."
+                                            },
+                                            "image_seg": {
+                                                "pythonClassName": "tensorflow_datasets.core.features.image_feature.Image",
+                                                "image": {
+                                                    "shape": {
+                                                        "dimensions": [
+                                                            "256",
+                                                            "256",
+                                                            "1"
+                                                        ]
+                                                    },
+                                                    "dtype": "uint8",
+                                                    "encodingFormat": "png"
+                                                },
+                                                "description": "Main camera segmentation observation."
+                                            }
+                                        }
+                                    }
+                                },
+                                "reward": {
+                                    "pythonClassName": "tensorflow_datasets.core.features.scalar.Scalar",
+                                    "tensor": {
+                                        "shape": {},
+                                        "dtype": "float32",
+                                        "encoding": "none"
+                                    },
+                                    "description": "Reward if provided, 1 on final step for demos."
+                                },
+                                "language_instruction_nouns": {
+                                    "pythonClassName": "tensorflow_datasets.core.features.text_feature.Text",
+                                    "text": {},
+                                    "description": "Language Instruction Nouns."
+                                }
+                            }
+                        }
+                    },
+                    "length": "-1"
+                }
+            }
+        }
+    }
+}

rlds_builder/Real_Data/Real_Data/real_data/1.0.0/real_data-train.tfrecord-00000-of-00004

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c2c72cd6ec1b4753008a17d1e37a979a19c69bb8115a121a36f2c30ae4ceb3d
+size 117086720

rlds_builder/Real_Data/Real_Data/real_data/1.0.0/real_data-train.tfrecord-00001-of-00004

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

rlds_builder/Real_Data/Real_Data/real_data/1.0.0/real_data-train.tfrecord-00002-of-00004

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34d2c730e7b28cc9ebb0d22169141bbe0aa427252d0966d2b21bd5f430d1fc77
+size 115451476

rlds_builder/Real_Data/Real_Data/real_data/1.0.0/real_data-train.tfrecord-00003-of-00004

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65c3a9252fbc169e3d40bce342525f3d6e123d33b6b8a2a021accb9f092d7beb
+size 125511129

rlds_builder/Real_Data/Real_Data_dataset_builder.py

@@ -0,0 +1,278 @@
+from typing import Iterator, Tuple, Any
+
+import os
+import h5py
+import glob
+import numpy as np
+import tensorflow as tf
+import tensorflow_datasets as tfds
+import sys
+import json
+from Real_Data.conversion_utils import MultiThreadedDatasetBuilder
+
+import numpy as np
+
+def xyxy_to_cxcywh(box):
+    """
+    Convert [x_min, y_min, x_max, y_max] → [cx, cy, w, h].
+    
+    Args:
+        box (list, tuple, or np.ndarray): shape (4,) or (N, 4).
+    Returns:
+        np.ndarray: same shape, but converted.
+    """
+    box = np.array(box, dtype=float)
+
+    if box.ndim == 1:  # single box
+        x_min, y_min, x_max, y_max = box
+        w = x_max - x_min
+        h = y_max - y_min
+        cx = x_min + w / 2
+        cy = y_min + h / 2
+        return np.array([cx, cy, w, h])
+    
+    elif box.ndim == 2:  # multiple boxes
+        x_min, y_min, x_max, y_max = box[:, 0], box[:, 1], box[:, 2], box[:, 3]
+        w = x_max - x_min
+        h = y_max - y_min
+        cx = x_min + w / 2
+        cy = y_min + h / 2
+        return np.stack([cx, cy, w, h], axis=-1)
+    
+    else:
+        raise ValueError("Input must be shape (4,) or (N,4)")
+
+def convert2texts(reasoning, image_size=256):
+    revised_reasoning = []
+    for datum in reasoning:
+        datum_reasoning = []
+        i = 0
+        for i in range(len(datum)):
+            item = datum[i]
+            if len(item) == 2:
+                seg_ind, bbox = item
+                bbox = xyxy_to_cxcywh((np.array(bbox))).astype(np.int32)
+                re_key_values = f'object_{seg_ind}:'+str(seg_ind)+','+str(bbox)+','+str(0)
+
+                datum_reasoning.append(re_key_values)
+        datum_reasoning = '#'.join(datum_reasoning)
+        revised_reasoning.append(datum_reasoning)
+    return revised_reasoning
+
+def _generate_examples(paths, split, ratio=1.0) -> Iterator[Tuple[str, Any]]:
+    """Yields episodes for list of data paths."""
+    # the line below needs to be *inside* generate_examples so that each worker creates it's own model
+    # creating one shared model outside this function would cause a deadlock
+
+    def _parse_example(episode_path, episode_meta_data, demo_id):
+        
+        # load raw data 
+        with h5py.File(episode_path, "r") as F:
+            if f"demo_{demo_id}" not in F['data'].keys():
+                return None # skip episode if the demo doesn't exist (e.g. due to failed demo)
+            actions = F['data'][f"demo_{demo_id}"]["actions"][()]
+            states = F['data'][f"demo_{demo_id}"]["obs"]["ee_states"][()]
+            gripper_states = F['data'][f"demo_{demo_id}"]["obs"]["gripper_states"][()]
+            joint_states = F['data'][f"demo_{demo_id}"]["obs"]["joint_states"][()]
+            images = F['data'][f"demo_{demo_id}"]["obs"]["agentview_rgb"][()]
+            wrist_images = F['data'][f"demo_{demo_id}"]["obs"]["eye_in_hand_rgb"][()]
+            depth_images = F['data'][f"demo_{demo_id}"]["obs"]["agentview_depth"][()]
+            depth_wrist_images = F['data'][f"demo_{demo_id}"]["obs"]["eye_in_hand_depth"][()]
+            seg_images = F['data'][f"demo_{demo_id}"]["obs"]["agentview_seg"][()]
+            seg_wrist_images = F['data'][f"demo_{demo_id}"]["obs"]["eye_in_hand_seg"][()]
+            
+        # compute language instruction
+        # words = raw_file_string[:-10].split("_")
+        # command = ''
+        # for w in words:
+        #     if "SCENE" in w:
+        #         command = ''
+        #         continue
+        #     command = command + w + ' '
+        # command = command[:-1]
+        
+        object_data = episode_meta_data[f"demo_{demo_id}"]
+        # print(data.keys()); 1/0
+        image_reasonings = object_data['exo_boxes']
+        image_reasonings = convert2texts(image_reasonings)
+        wrist_image_reasonings = object_data['ego_boxes']
+        wrist_image_reasonings = convert2texts(wrist_image_reasonings)
+        command_nouns = object_data['task_nouns']
+        command = object_data['task_description']
+
+        # print(command)
+        # print(command_nouns)
+        # print(image_reasonings); 1/0
+
+        command_nouns = '. '.join(command_nouns)
+        # import cv2
+        # cv2.imwrite('try_rgb.png', wrist_images[0][:,::-1])
+        # cv2.imwrite('try_depth.png', depth_wrist_images[0][:,::-1])
+        # cv2.imwrite('try_seg.png', seg_wrist_images[0][:,::-1])
+        # print(seg_images[0][:,::-1].shape)
+        # assemble episode --> here we're assuming demos so we set reward to 1 at the end
+        episode = []
+        for i in range(actions.shape[0]):
+            # print(image_reasonings[i]); 1/0
+            # print(wrist_image_reasonings[i])
+            # print(command_nouns); 1/0
+            episode.append({
+                'observation': {
+                    'image': images[i].astype(np.uint8),
+                    'image_seg': seg_images[i].astype(np.uint8), 
+                    'image_reasoning': image_reasonings[i], # object 1:@segid,@bbox#object 2:@segid,@bbox
+
+                    'state': np.asarray(np.concatenate((states[i], gripper_states[i], gripper_states[i]), axis=-1), np.float32),
+                    'joint_state': np.asarray(np.zeros(7), dtype=np.float32),
+                },
+                'action': np.asarray(actions[i], dtype=np.float32),
+                'discount': 1.0,
+                'reward': float(i == (actions.shape[0] - 1)),
+                'is_first': i == 0,
+                'is_last': i == (actions.shape[0] - 1),
+                'is_terminal': i == (actions.shape[0] - 1),
+                'language_instruction': command,
+                'language_instruction_nouns': command_nouns,
+            })
+
+        # create output data sample
+        sample = {
+            'steps': episode,
+            'episode_metadata': {
+                'file_path': episode_path
+            }
+        }
+
+        # if you want to skip an example for whatever reason, simply return None
+        return episode_path + f"_{demo_id}", sample
+
+    # get the meta data
+    meta_path = os.path.join(os.path.dirname(paths[0]), 'metainfo.json')
+    with open(meta_path, 'r') as file:
+        meta_data = json.load(file)
+
+    # for smallish datasets, use single-thread parsing
+    for sample in paths:
+        with h5py.File(sample, "r") as F:
+            sample_demo_ids = [key.replace('demo_', '') for key in F['data'].keys()]
+
+        task_name = os.path.basename(sample).split('/')[-1][:-10]
+        task_meta_data = meta_data[task_name]
+        task_meta_demo_ids = [key.replace('demo_', '') for key in task_meta_data.keys()]
+        demo_ids = list(set(sample_demo_ids) & set(task_meta_demo_ids))
+        n_demos = len(demo_ids)
+
+        idx = 0
+        tv_splitpoint = int(ratio * n_demos)
+        # train_data += tv_splitpoint
+        # val_data += n_demos - tv_splitpoint
+        # print('Train size', train_data, '--- Val size', val_data)
+
+        while idx < n_demos:
+            ret = _parse_example(sample, task_meta_data, demo_ids[idx])
+            assert(ret is not None)
+            idx += 1
+            if (split == 'train') and (idx > tv_splitpoint):
+                continue
+            elif (split == 'val') and (idx <= tv_splitpoint):
+                continue
+            yield ret
+
+
+class RealData(MultiThreadedDatasetBuilder):
+    """DatasetBuilder for example dataset."""
+
+    VERSION = tfds.core.Version('1.0.0')
+    RELEASE_NOTES = {
+      '1.0.0': 'Initial release.',
+    }
+    N_WORKERS = 2             # number of parallel workers for data conversion
+    MAX_PATHS_IN_MEMORY = 60   # number of paths converted & stored in memory before writing to disk
+                               # -> the higher the faster / more parallel conversion, adjust based on avilable RAM
+                               # note that one path may yield multiple episodes and adjust accordingly
+    PARSE_FCN = _generate_examples      # handle to parse function from file paths to RLDS episodes
+
+    def _info(self) -> tfds.core.DatasetInfo:
+        """Dataset metadata (homepage, citation,...)."""
+        return self.dataset_info_from_configs(
+            features=tfds.features.FeaturesDict({
+                'steps': tfds.features.Dataset({
+                    'observation': tfds.features.FeaturesDict({
+                        'image': tfds.features.Image(
+                            shape=(256, 256, 3),
+                            dtype=np.uint8,
+                            encoding_format='jpeg',
+                            doc='Main camera RGB observation.',
+                        ),
+
+
+                        # depths
+                        'image_seg': tfds.features.Image(
+                            shape=(256, 256, 1),
+                            dtype=np.uint8,
+                            encoding_format='png',
+                            doc='Main camera segmentation observation.',
+                        ),
+
+                        # object-centric bboxes and seg indices
+                        'image_reasoning': tfds.features.Text(
+                            doc='scene objects as dictionary of bbox and seg index in Main camera.'
+                        ),
+                        'state': tfds.features.Tensor(
+                            shape=(8,),
+                            dtype=np.float32,
+                            doc='Robot EEF state (6D pose, 2D gripper).',
+                        ),
+                        'joint_state': tfds.features.Tensor(
+                            shape=(7,),
+                            dtype=np.float32,
+                            doc='Robot joint angles.',
+                        )
+
+                    }),
+                    'action': tfds.features.Tensor(
+                        shape=(7,),
+                        dtype=np.float32,
+                        doc='Robot EEF action.',
+                    ),
+                    'discount': tfds.features.Scalar(
+                        dtype=np.float32,
+                        doc='Discount if provided, default to 1.'
+                    ),
+                    'reward': tfds.features.Scalar(
+                        dtype=np.float32,
+                        doc='Reward if provided, 1 on final step for demos.'
+                    ),
+                    'is_first': tfds.features.Scalar(
+                        dtype=np.bool_,
+                        doc='True on first step of the episode.'
+                    ),
+                    'is_last': tfds.features.Scalar(
+                        dtype=np.bool_,
+                        doc='True on last step of the episode.'
+                    ),
+                    'is_terminal': tfds.features.Scalar(
+                        dtype=np.bool_,
+                        doc='True on last step of the episode if it is a terminal step, True for demos.'
+                    ),
+                    'language_instruction': tfds.features.Text(
+                        doc='Language Instruction.'
+                    ),
+                    'language_instruction_nouns': tfds.features.Text(
+                        doc='Language Instruction Nouns.'
+                    ),
+                }),
+                'episode_metadata': tfds.features.FeaturesDict({
+                    'file_path': tfds.features.Text(
+                        doc='Path to the original data file.'
+                    ),
+                }),
+            }))
+
+    def _split_paths(self):
+        """Define filepaths for data splits."""
+        train_files = glob.glob("/cm/shared/nhatcm3/workspace/Dataset/hdf5_data/Real_Data/*.hdf5")
+        return {
+            "train": train_files,
+            # "val": glob.glob("../../libero_goal_no_noops/*.hdf5"),
+        }

rlds_builder/Real_Data/conversion_utils.py

@@ -0,0 +1,226 @@
+from typing import Tuple, Any, Dict, Union, Callable, Iterable
+import numpy as np
+import tensorflow as tf
+import tensorflow_datasets as tfds
+
+import itertools
+from multiprocessing import Pool
+from functools import partial
+from tensorflow_datasets.core import download
+from tensorflow_datasets.core import split_builder as split_builder_lib
+from tensorflow_datasets.core import naming
+from tensorflow_datasets.core import splits as splits_lib
+from tensorflow_datasets.core import utils
+from tensorflow_datasets.core import writer as writer_lib
+from tensorflow_datasets.core import example_serializer
+from tensorflow_datasets.core import dataset_builder
+from tensorflow_datasets.core import file_adapters
+
+Key = Union[str, int]
+# The nested example dict passed to `features.encode_example`
+Example = Dict[str, Any]
+KeyExample = Tuple[Key, Example]
+
+
+class MultiThreadedDatasetBuilder(tfds.core.GeneratorBasedBuilder):
+    """DatasetBuilder for example dataset."""
+    N_WORKERS = 10                  # number of parallel workers for data conversion
+    MAX_PATHS_IN_MEMORY = 100       # number of paths converted & stored in memory before writing to disk
+                                    # -> the higher the faster / more parallel conversion, adjust based on avilable RAM
+                                    # note that one path may yield multiple episodes and adjust accordingly
+    PARSE_FCN = None                # needs to be filled with path-to-record-episode parse function
+
+    def _split_generators(self, dl_manager: tfds.download.DownloadManager):
+        """Define data splits."""
+        split_paths = self._split_paths()
+        return {split: type(self).PARSE_FCN(paths=split_paths[split], split=split) for split in split_paths}
+
+    def _generate_examples(self):
+        pass  # this is implemented in global method to enable multiprocessing
+
+    def _download_and_prepare(  # pytype: disable=signature-mismatch  # overriding-parameter-type-checks
+            self,
+            dl_manager: download.DownloadManager,
+            download_config: download.DownloadConfig,
+    ) -> None:
+        """Generate all splits and returns the computed split infos."""
+        assert self.PARSE_FCN is not None       # need to overwrite parse function
+        split_builder = ParallelSplitBuilder(
+            split_dict=self.info.splits,
+            features=self.info.features,
+            dataset_size=self.info.dataset_size,
+            max_examples_per_split=download_config.max_examples_per_split,
+            beam_options=download_config.beam_options,
+            beam_runner=download_config.beam_runner,
+            file_format=self.info.file_format,
+            shard_config=download_config.get_shard_config(),
+            split_paths=self._split_paths(),
+            parse_function=type(self).PARSE_FCN,
+            n_workers=self.N_WORKERS,
+            max_paths_in_memory=self.MAX_PATHS_IN_MEMORY,
+        )
+        split_generators = self._split_generators(dl_manager)
+        split_generators = split_builder.normalize_legacy_split_generators(
+            split_generators=split_generators,
+            generator_fn=self._generate_examples,
+            is_beam=False,
+        )
+        dataset_builder._check_split_names(split_generators.keys())
+
+        # Start generating data for all splits
+        path_suffix = file_adapters.ADAPTER_FOR_FORMAT[
+            self.info.file_format
+        ].FILE_SUFFIX
+
+        split_info_futures = []
+        for split_name, generator in utils.tqdm(
+                split_generators.items(),
+                desc="Generating splits...",
+                unit=" splits",
+                leave=False,
+        ):
+            filename_template = naming.ShardedFileTemplate(
+                split=split_name,
+                dataset_name=self.name,
+                data_dir=self.data_path,
+                filetype_suffix=path_suffix,
+            )
+            future = split_builder.submit_split_generation(
+                split_name=split_name,
+                generator=generator,
+                filename_template=filename_template,
+                disable_shuffling=self.info.disable_shuffling,
+            )
+            split_info_futures.append(future)
+
+        # Finalize the splits (after apache beam completed, if it was used)
+        split_infos = [future.result() for future in split_info_futures]
+
+        # Update the info object with the splits.
+        split_dict = splits_lib.SplitDict(split_infos)
+        self.info.set_splits(split_dict)
+
+
+class _SplitInfoFuture:
+    """Future containing the `tfds.core.SplitInfo` result."""
+
+    def __init__(self, callback: Callable[[], splits_lib.SplitInfo]):
+        self._callback = callback
+
+    def result(self) -> splits_lib.SplitInfo:
+        return self._callback()
+
+
+def parse_examples_from_generator(paths, fcn, split_name, total_num_examples, features, serializer):
+    generator = fcn(paths, split_name)
+    outputs = []
+    for sample in utils.tqdm(
+            generator,
+            desc=f'Generating {split_name} examples...',
+            unit=' examples',
+            total=total_num_examples,
+            leave=False,
+            mininterval=1.0,
+    ):
+        if sample is None: continue
+        key, example = sample
+        try:
+            example = features.encode_example(example)
+        except Exception as e:  # pylint: disable=broad-except
+            utils.reraise(e, prefix=f'Failed to encode example:\n{example}\n')
+        outputs.append((key, serializer.serialize_example(example)))
+    return outputs
+
+
+class ParallelSplitBuilder(split_builder_lib.SplitBuilder):
+    def __init__(self, *args, split_paths, parse_function, n_workers, max_paths_in_memory, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._split_paths = split_paths
+        self._parse_function = parse_function
+        self._n_workers = n_workers
+        self._max_paths_in_memory = max_paths_in_memory
+
+    def _build_from_generator(
+            self,
+            split_name: str,
+            generator: Iterable[KeyExample],
+            filename_template: naming.ShardedFileTemplate,
+            disable_shuffling: bool,
+    ) -> _SplitInfoFuture:
+        """Split generator for example generators.
+
+        Args:
+          split_name: str,
+          generator: Iterable[KeyExample],
+          filename_template: Template to format the filename for a shard.
+          disable_shuffling: Specifies whether to shuffle the examples,
+
+        Returns:
+          future: The future containing the `tfds.core.SplitInfo`.
+        """
+        total_num_examples = None
+        serialized_info = self._features.get_serialized_info()
+        writer = writer_lib.Writer(
+            serializer=example_serializer.ExampleSerializer(serialized_info),
+            filename_template=filename_template,
+            hash_salt=split_name,
+            disable_shuffling=disable_shuffling,
+            file_format=self._file_format,
+            shard_config=self._shard_config,
+        )
+
+        del generator  # use parallel generators instead
+        paths = self._split_paths[split_name]
+        path_lists = chunk_max(paths, self._n_workers, self._max_paths_in_memory)  # generate N file lists
+        print(f"Generating with {self._n_workers} workers!")
+        pool = Pool(processes=self._n_workers)
+        for i, paths in enumerate(path_lists):
+            print(f"Processing chunk {i + 1} of {len(path_lists)}.")
+            results = pool.map(
+                partial(
+                    parse_examples_from_generator,
+                    fcn=self._parse_function,
+                    split_name=split_name,
+                    total_num_examples=total_num_examples,
+                    serializer=writer._serializer,
+                    features=self._features
+                ),
+                paths
+            )
+            # write results to shuffler --> this will automatically offload to disk if necessary
+            print("Writing conversion results...")
+            for result in itertools.chain(*results):
+                key, serialized_example = result
+                writer._shuffler.add(key, serialized_example)
+                writer._num_examples += 1
+        pool.close()
+
+        print("Finishing split conversion...")
+        shard_lengths, total_size = writer.finalize()
+
+        split_info = splits_lib.SplitInfo(
+            name=split_name,
+            shard_lengths=shard_lengths,
+            num_bytes=total_size,
+            filename_template=filename_template,
+        )
+        return _SplitInfoFuture(lambda: split_info)
+
+
+def dictlist2listdict(DL):
+    " Converts a dict of lists to a list of dicts "
+    return [dict(zip(DL, t)) for t in zip(*DL.values())]
+
+def chunks(l, n):
+    """Yield n number of sequential chunks from l."""
+    d, r = divmod(len(l), n)
+    for i in range(n):
+        si = (d + 1) * (i if i < r else r) + d * (0 if i < r else i - r)
+        yield l[si:si + (d + 1 if i < r else d)]
+
+def chunk_max(l, n, max_chunk_sum):
+    out = []
+    for _ in range(int(np.ceil(len(l) / max_chunk_sum))):
+        out.append(list(chunks(l[:max_chunk_sum], n)))
+        l = l[max_chunk_sum:]
+    return out