upload code

code/.gitignore

@@ -0,0 +1,4 @@
+wandb
+__pycache__
+.idea
+.DS_Store

code/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Karl Pertsch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

code/README.md

@@ -0,0 +1,31 @@
+# RLDS dataset for train vla
+The code modified from [rlds_dataset_mod](https://github.com/moojink/rlds_dataset_mod/blob/main/README.md)
+
+We upload the precessed dataset in this repository ❤
+
+below is the code for processing ⚙
+
+
+### prepare gsutil
+
+```shell
+# https://cloud.google.com/sdk/docs/install-sdk?hl=zh-cn#linux
+curl -O https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-cli-linux-x86_64.tar.gz
+tar -xf google-cloud-cli-linux-x86_64.tar.gz
+./google-cloud-sdk/install.sh
+./google-cloud-sdk/bin/gcloud init --console-only
+./google-cloud-sdk/bin/gcloud components install gsutil
+# check gsutil
+export PATH=$PATH:/path/to/google-cloud-sdk/bin
+ls ./google-cloud-sdk/bin/gsutil
+```
+### prepare environment
+
+```
+conda env create -f environment_ubuntu.yml
+conda activate rlds
+mkdir data_download
+mkdir data_tmp
+```
+
+All the rights are reserved. 

code/environment_ubuntu.yml

@@ -0,0 +1,126 @@
+name: rlds
+channels:
+  - conda-forge
+dependencies:
+  - _libgcc_mutex=0.1=conda_forge
+  - _openmp_mutex=4.5=2_gnu
+  - ca-certificates=2023.7.22=hbcca054_0
+  - ld_impl_linux-64=2.40=h41732ed_0
+  - libffi=3.3=h58526e2_2
+  - libgcc-ng=13.1.0=he5830b7_0
+  - libgomp=13.1.0=he5830b7_0
+  - libsqlite=3.42.0=h2797004_0
+  - libstdcxx-ng=13.1.0=hfd8a6a1_0
+  - libzlib=1.2.13=hd590300_5
+  - ncurses=6.4=hcb278e6_0
+  - openssl=1.1.1u=hd590300_0
+  - pip=23.2.1=pyhd8ed1ab_0
+  - python=3.9.0=hffdb5ce_5_cpython
+  - readline=8.2=h8228510_1
+  - setuptools=68.0.0=pyhd8ed1ab_0
+  - sqlite=3.42.0=h2c6b66d_0
+  - tk=8.6.12=h27826a3_0
+  - tzdata=2023c=h71feb2d_0
+  - wheel=0.41.0=pyhd8ed1ab_0
+  - xz=5.2.6=h166bdaf_0
+  - zlib=1.2.13=hd590300_5
+  - pip:
+      - absl-py==1.4.0
+      - anyio==3.7.1
+      - apache-beam==2.49.0
+      - appdirs==1.4.4
+      - array-record==0.4.0
+      - astunparse==1.6.3
+      - cachetools==5.3.1
+      - certifi==2023.7.22
+      - charset-normalizer==3.2.0
+      - click==8.1.6
+      - cloudpickle==2.2.1
+      - contourpy==1.1.0
+      - crcmod==1.7
+      - cycler==0.11.0
+      - dill==0.3.1.1
+      - dm-tree==0.1.8
+      - dnspython==2.4.0
+      - docker-pycreds==0.4.0
+      - docopt==0.6.2
+      - etils==1.3.0
+      - exceptiongroup==1.1.2
+      - fastavro==1.8.2
+      - fasteners==0.18
+      - flatbuffers==23.5.26
+      - fonttools==4.41.1
+      - gast==0.4.0
+      - gitdb==4.0.10
+      - gitpython==3.1.32
+      - google-auth==2.22.0
+      - google-auth-oauthlib==1.0.0
+      - google-pasta==0.2.0
+      - googleapis-common-protos==1.59.1
+      - grpcio==1.56.2
+      - h11==0.14.0
+      - h5py==3.9.0
+      - hdfs==2.7.0
+      - httpcore==0.17.3
+      - httplib2==0.22.0
+      - idna==3.4
+      - importlib-metadata==6.8.0
+      - importlib-resources==6.0.0
+      - keras==2.13.1
+      - kiwisolver==1.4.4
+      - libclang==16.0.6
+      - markdown==3.4.3
+      - markupsafe==2.1.3
+      - matplotlib==3.7.2
+      - numpy==1.24.3
+      - oauthlib==3.2.2
+      - objsize==0.6.1
+      - opt-einsum==3.3.0
+      - orjson==3.9.2
+      - packaging==23.1
+      - pathtools==0.1.2
+      - pillow==10.0.0
+      - plotly==5.15.0
+      - promise==2.3
+      - proto-plus==1.22.3
+      - protobuf==4.23.4
+      - psutil==5.9.5
+      - pyarrow==11.0.0
+      - pyasn1==0.5.0
+      - pyasn1-modules==0.3.0
+      - pydot==1.4.2
+      - pymongo==4.4.1
+      - pyparsing==3.0.9
+      - python-dateutil==2.8.2
+      - pytz==2023.3
+      - pyyaml==6.0.1
+      - regex==2023.6.3
+      - requests==2.31.0
+      - requests-oauthlib==1.3.1
+      - rsa==4.9
+      - sentry-sdk==1.28.1
+      - setproctitle==1.3.2
+      - six==1.16.0
+      - smmap==5.0.0
+      - sniffio==1.3.0
+      - tenacity==8.2.2
+      - tensorboard==2.13.0
+      - tensorboard-data-server==0.7.1
+      - tensorflow==2.13.0
+      - tensorflow-datasets==4.9.2
+      - tensorflow-estimator==2.13.0
+      - tensorflow-hub==0.14.0
+      - tensorflow-io-gcs-filesystem==0.32.0
+      - tensorflow-metadata==1.13.1
+      - termcolor==2.3.0
+      - toml==0.10.2
+      - tqdm==4.65.0
+      - typing-extensions==4.5.0
+      - urllib3==1.26.16
+      - wandb==0.15.6
+      - werkzeug==2.3.6
+      - wrapt==1.15.0
+      - zipp==3.16.2
+      - zstandard==0.21.0
+      - dlimp @ git+https://github.com/kvablack/dlimp@fba663b10858793d35f9a0fdbe8f0d51906c8c90
+prefix: /scr/kpertsch/miniconda3/envs/rlds_env

code/modify_rlds_dataset.py

@@ -0,0 +1,68 @@
+"""Modifies TFDS dataset with a map function, updates the feature definition and stores new dataset."""
+from functools import partial
+
+from absl import app, flags
+import tensorflow as tf
+import tensorflow_datasets as tfds
+
+from rlds_dataset_mod.mod_functions import TFDS_MOD_FUNCTIONS
+from rlds_dataset_mod.multithreaded_adhoc_tfds_builder import (
+    MultiThreadedAdhocDatasetBuilder,
+)
+
+FLAGS = flags.FLAGS
+
+flags.DEFINE_string("dataset", None, "Dataset name.")
+flags.DEFINE_string("data_dir", None, "Directory where source data is stored.")
+flags.DEFINE_string("target_dir", None, "Directory where modified data is stored.")
+flags.DEFINE_list("mods", None, "List of modification functions, applied in order.")
+flags.DEFINE_integer("n_workers", 10, "Number of parallel workers for data conversion.")
+flags.DEFINE_integer(
+    "max_episodes_in_memory",
+    100,
+    "Number of episodes converted & stored in memory before writing to disk.",
+)
+
+
+def mod_features(features):
+    """Modifies feature dict."""
+    for mod in FLAGS.mods:
+        features = TFDS_MOD_FUNCTIONS[mod].mod_features(features)
+    return features
+
+
+def mod_dataset_generator(builder, split, mods):
+    """Modifies dataset features."""
+    ds = builder.as_dataset(split=split)
+    for mod in mods:
+        ds = TFDS_MOD_FUNCTIONS[mod].mod_dataset(ds)
+    for episode in tfds.core.dataset_utils.as_numpy(ds):
+        yield episode
+
+
+def main(_):
+    builder = tfds.builder(FLAGS.dataset, data_dir=FLAGS.data_dir)
+
+    features = mod_features(builder.info.features)
+    print("############# Target features: ###############")
+    print(features)
+    print("##############################################")
+    assert FLAGS.data_dir != FLAGS.target_dir   # prevent overwriting original dataset
+
+    mod_dataset_builder = MultiThreadedAdhocDatasetBuilder(
+        name=FLAGS.dataset,
+        version=builder.version,
+        features=features,
+        split_datasets={split: builder.info.splits[split] for split in builder.info.splits},
+        config=builder.builder_config,
+        data_dir=FLAGS.target_dir,
+        description=builder.info.description,
+        generator_fcn=partial(mod_dataset_generator, builder=builder, mods=FLAGS.mods),
+        n_workers=FLAGS.n_workers,
+        max_episodes_in_memory=FLAGS.max_episodes_in_memory,
+    )
+    mod_dataset_builder.download_and_prepare()
+
+
+if __name__ == "__main__":
+    app.run(main)

code/prepare_open_x.sh

@@ -0,0 +1,54 @@
+DOWNLOAD_DIR="<your path>"   # todo:
+CONVERSION_DIR="<your path>" # todo:
+N_WORKERS=10                 # number of workers used for parallel conversion --> adjust based on available RAM
+MAX_EPISODES_IN_MEMORY=100    # number of episodes converted in parallel --> adjust based on available RAM
+
+# increase limit on number of files opened in parallel to 20k --> conversion opens up to 1k temporary files
+# in /tmp to store dataset during conversion
+ulimit -n 20000
+
+# format: [dataset_name, dataset_version, transforms]
+DATASET_TRANSFORMS=(
+    # Datasets used for OpenVLA: https://openvla.github.io/
+    "fractal20220817_data 0.1.0 resize_and_jpeg_encode"
+    "kuka 0.1.0 resize_and_jpeg_encode,filter_success"
+    "taco_play 0.1.0 resize_and_jpeg_encode"
+    "jaco_play 0.1.0 resize_and_jpeg_encode"
+    "berkeley_cable_routing 0.1.0 resize_and_jpeg_encode"
+    "roboturk 0.1.0 resize_and_jpeg_encode"
+    "viola 0.1.0 resize_and_jpeg_encode"
+    "berkeley_autolab_ur5 0.1.0 resize_and_jpeg_encode,flip_wrist_image_channels"
+    "toto 0.1.0 resize_and_jpeg_encode"
+    "language_table 0.1.0 resize_and_jpeg_encode"
+    "stanford_hydra_dataset_converted_externally_to_rlds 0.1.0 resize_and_jpeg_encode,flip_wrist_image_channels,flip_image_channels"
+    "austin_buds_dataset_converted_externally_to_rlds 0.1.0 resize_and_jpeg_encode"
+    "nyu_franka_play_dataset_converted_externally_to_rlds 0.1.0 resize_and_jpeg_encode"
+    "furniture_bench_dataset_converted_externally_to_rlds 0.1.0 resize_and_jpeg_encode"
+    "ucsd_kitchen_dataset_converted_externally_to_rlds 0.1.0 resize_and_jpeg_encode"
+    "austin_sailor_dataset_converted_externally_to_rlds 0.1.0 resize_and_jpeg_encode"
+    "austin_sirius_dataset_converted_externally_to_rlds 0.1.0 resize_and_jpeg_encode"
+    "bc_z 0.1.0 resize_and_jpeg_encode"
+    "dlr_edan_shared_control_converted_externally_to_rlds 0.1.0 resize_and_jpeg_encode"
+    "iamlab_cmu_pickup_insert_converted_externally_to_rlds 0.1.0 resize_and_jpeg_encode"
+    "utaustin_mutex 0.1.0 resize_and_jpeg_encode,flip_wrist_image_channels,flip_image_channels"
+    "berkeley_fanuc_manipulation 0.1.0 resize_and_jpeg_encode,flip_wrist_image_channels,flip_image_channels"
+    "cmu_stretch 0.1.0 resize_and_jpeg_encode"
+    "dobbe 0.0.1 resize_and_jpeg_encode"
+    "fmb 0.0.1 resize_and_jpeg_encode"
+    "droid 1.0.0 resize_and_jpeg_encode"
+)
+
+for tuple in "${DATASET_TRANSFORMS[@]}"; do
+  # Extract strings from the tuple
+  strings=($tuple)
+  DATASET=${strings[0]}
+  VERSION=${strings[1]}
+  TRANSFORM=${strings[2]}
+   mkdir ${DOWNLOAD_DIR}/${DATASET}
+  ./google-cloud-sdk/bin/gsutil -m cp -r gs://gresearch/robotics/${DATASET}/${VERSION} ${DOWNLOAD_DIR}/${DATASET}
+   python3 modify_rlds_dataset.py --dataset=$DATASET --data_dir=$DOWNLOAD_DIR --target_dir=$CONVERSION_DIR --mods=$TRANSFORM --n_workers=$N_WORKERS --max_episodes_in_memory=$MAX_EPISODES_IN_MEMORY
+  rm -rf ${DOWNLOAD_DIR}/${DATASET}
+  mv ${CONVERSION_DIR}/${DATASET} ${DOWNLOAD_DIR}
+#  python3 upload_hf.py $DATASET $VERSION
+  rm -rf ${DOWNLOAD_DIR}/${DATASET}
+done

code/rlds_dataset_mod/mod_functions.py

@@ -0,0 +1,173 @@
+from abc import ABC, abstractmethod
+
+import dlimp as dl
+import tensorflow as tf
+import tensorflow_datasets as tfds
+
+
+class TfdsModFunction(ABC):
+    @classmethod
+    @abstractmethod
+    def mod_features(
+        cls,
+        features: tfds.features.FeaturesDict,
+    ) -> tfds.features.FeaturesDict:
+        """
+        Modifies the data builder feature dict to reflect feature changes of ModFunction.
+        """
+        ...
+
+    @classmethod
+    @abstractmethod
+    def mod_dataset(cls, ds: tf.data.Dataset) -> tf.data.Dataset:
+        """
+        Perform arbitrary modifications on the dataset that comply with the modified feature definition.
+        """
+        ...
+
+
+def mod_obs_features(features, obs_feature_mod_function):
+    """Utility function to only modify keys in observation dict."""
+    return tfds.features.FeaturesDict(
+        {
+            "steps": tfds.features.Dataset(
+                {
+                    "observation": tfds.features.FeaturesDict(
+                        {
+                            key: obs_feature_mod_function(
+                                key, features["steps"]["observation"][key]
+                            )
+                            for key in features["steps"]["observation"].keys()
+                        }
+                    ),
+                    **{
+                        key: features["steps"][key]
+                        for key in features["steps"].keys()
+                        if key not in ("observation",)
+                    },
+                }
+            ),
+            **{key: features[key] for key in features.keys() if key not in ("steps",)},
+        }
+    )
+
+
+class ResizeAndJpegEncode(TfdsModFunction):
+    MAX_RES: int = 256
+
+    @classmethod
+    def mod_features(
+        cls,
+        features: tfds.features.FeaturesDict,
+    ) -> tfds.features.FeaturesDict:
+        def downsize_and_jpeg(key, feat):
+            """Downsizes image features, encodes as jpeg."""
+            if len(feat.shape) >= 2 and feat.shape[0] >= 64 and feat.shape[1] >= 64:  # is image / depth feature
+                should_jpeg_encode = (
+                    isinstance(feat, tfds.features.Image) and "depth" not in key
+                )
+                if len(feat.shape) > 2:
+                    new_shape = (ResizeAndJpegEncode.MAX_RES, ResizeAndJpegEncode.MAX_RES, feat.shape[2])
+                else:
+                    new_shape = (ResizeAndJpegEncode.MAX_RES, ResizeAndJpegEncode.MAX_RES)
+
+                if isinstance(feat, tfds.features.Image):
+                    return tfds.features.Image(
+                        shape=new_shape,
+                        dtype=feat.dtype,
+                        encoding_format="jpeg" if should_jpeg_encode else "png",
+                        doc=feat.doc,
+                    )
+                else:
+                    return tfds.features.Tensor(
+                        shape=new_shape,
+                        dtype=feat.dtype,
+                        doc=feat.doc,
+                    )
+
+            return feat
+
+        return mod_obs_features(features, downsize_and_jpeg)
+
+    @classmethod
+    def mod_dataset(cls, ds: tf.data.Dataset) -> tf.data.Dataset:
+        def resize_image_fn(step):
+            # resize images
+            for key in step["observation"]:
+                if len(step["observation"][key].shape) >= 2 and (
+                    step["observation"][key].shape[0] >= 64
+                    or step["observation"][key].shape[1] >= 64
+                ):
+                    size = (ResizeAndJpegEncode.MAX_RES,
+                            ResizeAndJpegEncode.MAX_RES)
+                    if "depth" in key:
+                        step["observation"][key] = tf.cast(
+                            dl.utils.resize_depth_image(
+                                tf.cast(step["observation"][key], tf.float32), size
+                            ),
+                            step["observation"][key].dtype,
+                        )
+                    else:
+                        step["observation"][key] = tf.cast(
+                            dl.utils.resize_image(step["observation"][key], size),
+                            tf.uint8,
+                        )
+            return step
+
+        def episode_map_fn(episode):
+            episode["steps"] = episode["steps"].map(resize_image_fn)
+            return episode
+
+        return ds.map(episode_map_fn)
+
+
+class FilterSuccess(TfdsModFunction):
+    @classmethod
+    def mod_features(
+        cls,
+        features: tfds.features.FeaturesDict,
+    ) -> tfds.features.FeaturesDict:
+        return features  # no feature changes
+
+    @classmethod
+    def mod_dataset(cls, ds: tf.data.Dataset) -> tf.data.Dataset:
+        return ds.filter(lambda e: e["success"])
+
+
+class FlipImgChannels(TfdsModFunction):
+    FLIP_KEYS = ["image"]
+
+    @classmethod
+    def mod_features(
+        cls,
+        features: tfds.features.FeaturesDict,
+    ) -> tfds.features.FeaturesDict:
+        return features  # no feature changes
+
+    @classmethod
+    def mod_dataset(cls, ds: tf.data.Dataset) -> tf.data.Dataset:
+        def flip(step):
+            for key in cls.FLIP_KEYS:
+                if key in step["observation"]:
+                    step["observation"][key] = step["observation"][key][..., ::-1]
+            return step
+
+        def episode_map_fn(episode):
+            episode["steps"] = episode["steps"].map(flip)
+            return episode
+
+        return ds.map(episode_map_fn)
+    
+
+class FlipWristImgChannels(FlipImgChannels):
+    FLIP_KEYS = ["wrist_image", "hand_image"]
+
+
+TFDS_MOD_FUNCTIONS = {
+    "resize_and_jpeg_encode": ResizeAndJpegEncode,
+    "filter_success": FilterSuccess,
+    "flip_image_channels": FlipImgChannels,
+    "flip_wrist_image_channels": FlipWristImgChannels,
+}
+
+

code/rlds_dataset_mod/multithreaded_adhoc_tfds_builder.py

@@ -0,0 +1,243 @@
+from functools import partial
+import itertools
+from multiprocessing import Pool
+from typing import Any, Callable, Dict, Iterable, Tuple, Union
+
+import numpy as np
+import tensorflow as tf
+import tensorflow_datasets as tfds
+from tensorflow_datasets.core import (
+    dataset_builder,
+    download,
+    example_serializer,
+    file_adapters,
+    naming,
+)
+from tensorflow_datasets.core import split_builder as split_builder_lib
+from tensorflow_datasets.core import splits as splits_lib
+from tensorflow_datasets.core import utils
+from tensorflow_datasets.core import writer as writer_lib
+
+Key = Union[str, int]
+# The nested example dict passed to `features.encode_example`
+Example = Dict[str, Any]
+KeyExample = Tuple[Key, Example]
+
+
+class MultiThreadedAdhocDatasetBuilder(tfds.core.dataset_builders.AdhocBuilder):
+    """Multithreaded adhoc dataset builder."""
+
+    def __init__(
+        self, *args, generator_fcn, n_workers, max_episodes_in_memory, **kwargs
+    ):
+        super().__init__(*args, **kwargs)
+        self._generator_fcn = generator_fcn
+        self._n_workers = n_workers
+        self._max_episodes_in_memory = max_episodes_in_memory
+
+    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._max_episodes_in_memory % self._n_workers == 0
+        )  # need to divide max_episodes by workers
+        split_builder = ParallelSplitBuilder(
+            split_dict=self._split_datasets,
+            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(),
+            generator_fcn=self._generator_fcn,
+            n_workers=self._n_workers,
+            max_episodes_in_memory=self._max_episodes_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)
+
+    def _split_generators(self, dl_manager: tfds.download.DownloadManager):
+        """Define dummy split generators."""
+
+        def dummy_generator():
+            yield None
+
+        return {split: dummy_generator() for split in self._split_datasets}
+
+
+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(
+    episodes, max_episodes, fcn, split_name, total_num_examples, features, serializer
+):
+    upper = episodes[-1] + 1
+    upper_str = f'{upper}' if upper < max_episodes else ''
+    generator = fcn(split=split_name + f"[{episodes[0]}:{upper_str}]")
+    outputs = []
+    for key, sample in utils.tqdm(
+        zip(episodes, generator),
+        desc=f"Generating {split_name} examples...",
+        unit=" examples",
+        total=total_num_examples,
+        leave=False,
+        mininterval=1.0,
+    ):
+        if sample is None:
+            continue
+        try:
+            sample = features.encode_example(sample)
+        except Exception as e:  # pylint: disable=broad-except
+            utils.reraise(e, prefix=f"Failed to encode example:\n{sample}\n")
+        outputs.append((str(key), serializer.serialize_example(sample)))
+    return outputs
+
+
+class ParallelSplitBuilder(split_builder_lib.SplitBuilder):
+    def __init__(
+        self, *args, generator_fcn, n_workers, max_episodes_in_memory, **kwargs
+    ):
+        super().__init__(*args, **kwargs)
+        self._generator_fcn = generator_fcn
+        self._n_workers = n_workers
+        self._max_episodes_in_memory = max_episodes_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
+        episode_lists = chunk_max(
+            list(np.arange(self._split_dict[split_name].num_examples)),
+            self._n_workers,
+            self._max_episodes_in_memory,
+        )  # generate N episode lists
+        print(f"Generating with {self._n_workers} workers!")
+        pool = Pool(processes=self._n_workers)
+        for i, episodes in enumerate(episode_lists):
+            print(f"Processing chunk {i + 1} of {len(episode_lists)}.")
+            results = pool.map(
+                partial(
+                    parse_examples_from_generator,
+                    fcn=self._generator_fcn,
+                    split_name=split_name,
+                    total_num_examples=total_num_examples,
+                    serializer=writer._serializer,
+                    features=self._features,
+                    max_episodes=self._split_dict[split_name].num_examples,
+                ),
+                episodes,
+            )
+            # 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([c for c in chunks(l[:max_chunk_sum], n) if c])
+        l = l[max_chunk_sum:]
+    return out

code/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup(name="rlds_dataset_mod", packages=["rlds_dataset_mod"])

code/upload_hf.py

@@ -0,0 +1,25 @@
+from huggingface_hub import HfApi, HfFolder
+import sys
+import os
+
+dataset_name = sys.argv[1]
+version = sys.argv[2]
+
+
+api = HfApi()
+repo_id = ""    # TODO:
+token = ""      # TODO:
+folder_path = f"data_download/{dataset_name}/{version}"
+
+def upload_folder_to_hf(folder_path, repo_id, token):
+    # 使用 Hugging Face API 上传整个文件夹
+    api.upload_folder(
+        folder_path=folder_path,
+        path_in_repo=f"{dataset_name}/{version}",
+        repo_id=repo_id,
+        token=token,
+        repo_type="dataset"
+    )
+    print(f"Uploaded the entire folder {folder_path} to {repo_id}")
+
+upload_folder_to_hf(folder_path, repo_id, token)