Add files using upload-large-folder tool

.gitattributes

@@ -133,3 +133,6 @@ venv/lib/python3.10/site-packages/nvidia/cudnn/lib/libcudnn_cnn_infer.so.8 filte
 venv/lib/python3.10/site-packages/scipy/special/_ufuncs.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 venv/lib/python3.10/site-packages/scipy/stats/_unuran/unuran_wrapper.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 venv/lib/python3.10/site-packages/scipy/sparse/_sparsetools.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.10/site-packages/numpy/core/_simd.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.10/site-packages/aiohttp/_http_parser.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.10/site-packages/scipy.libs/libgfortran-040039e1.so.5.0.0 filter=lfs diff=lfs merge=lfs -text

ckpts/llama-3b/global_step100/bf16_zero_pp_rank_73_mp_rank_01_optim_states.pt

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

ckpts/llama-3b/global_step100/layer_04-model_00-model_states.pt

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

venv/lib/python3.10/site-packages/aiohttp/_http_parser.cpython-310-x86_64-linux-gnu.so

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

venv/lib/python3.10/site-packages/deepspeed/__init__.py

@@ -0,0 +1,348 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import sys
+import types
+import json
+from typing import Optional, Union
+import torch
+from torch.optim import Optimizer
+from torch.optim.lr_scheduler import _LRScheduler
+from packaging import version as pkg_version
+
+# Skip Triton import for AMD due to pytorch-triton-rocm module breaking device API in DeepSpeed
+if not (hasattr(torch.version, 'hip') and torch.version.hip is not None):
+    try:
+        import triton  # noqa: F401 # type: ignore
+        HAS_TRITON = True
+    except ImportError:
+        HAS_TRITON = False
+else:
+    HAS_TRITON = False
+
+from . import ops
+from . import module_inject
+
+from .accelerator import get_accelerator
+from .constants import TORCH_DISTRIBUTED_DEFAULT_PORT
+from .runtime.engine import DeepSpeedEngine, DeepSpeedOptimizerCallable, DeepSpeedSchedulerCallable
+from .runtime.engine import ADAM_OPTIMIZER, LAMB_OPTIMIZER
+from .runtime.hybrid_engine import DeepSpeedHybridEngine
+from .runtime.pipe.engine import PipelineEngine
+from .inference.engine import InferenceEngine
+from .inference.config import DeepSpeedInferenceConfig
+from .runtime.lr_schedules import add_tuning_arguments
+from .runtime.config import DeepSpeedConfig, DeepSpeedConfigError
+from .runtime.activation_checkpointing import checkpointing
+from .ops.transformer import DeepSpeedTransformerLayer, DeepSpeedTransformerConfig
+from .module_inject import replace_transformer_layer, revert_transformer_layer
+
+from .utils import log_dist, OnDevice, logger
+from .comm.comm import init_distributed
+
+from .runtime import zero
+from .runtime.compiler import is_compile_supported
+
+from .pipe import PipelineModule
+
+from .git_version_info import version, git_hash, git_branch
+
+
+def _parse_version(version_str):
+    '''Parse a version string and extract the major, minor, and patch versions.'''
+    ver = pkg_version.parse(version_str)
+    return ver.major, ver.minor, ver.micro
+
+
+# Export version information
+__version__ = version
+__version_major__, __version_minor__, __version_patch__ = _parse_version(__version__)
+__git_hash__ = git_hash
+__git_branch__ = git_branch
+
+# Set to torch's distributed package or deepspeed.comm based inside DeepSpeedEngine init
+dist = None
+
+
+def initialize(args=None,
+               model: torch.nn.Module = None,
+               optimizer: Optional[Union[Optimizer, DeepSpeedOptimizerCallable]] = None,
+               model_parameters: Optional[torch.nn.Module] = None,
+               training_data: Optional[torch.utils.data.Dataset] = None,
+               lr_scheduler: Optional[Union[_LRScheduler, DeepSpeedSchedulerCallable]] = None,
+               distributed_port: int = TORCH_DISTRIBUTED_DEFAULT_PORT,
+               mpu=None,
+               dist_init_required: Optional[bool] = None,
+               collate_fn=None,
+               config=None,
+               config_params=None):
+    """Initialize the DeepSpeed Engine.
+
+    Arguments:
+        args: an object containing local_rank and deepspeed_config fields.
+            This is optional if `config` is passed.
+
+        model: Required: nn.module class before apply any wrappers
+
+        optimizer: Optional: a user defined Optimizer or Callable that returns an Optimizer object.
+            This overrides any optimizer definition in the DeepSpeed json config.
+
+        model_parameters: Optional: An iterable of torch.Tensors or dicts.
+            Specifies what Tensors should be optimized.
+
+        training_data: Optional: Dataset of type torch.utils.data.Dataset
+
+        lr_scheduler: Optional: Learning Rate Scheduler Object or a Callable that takes an Optimizer and returns a Scheduler object.
+            The scheduler object should define a get_lr(), step(), state_dict(), and load_state_dict() methods
+
+        distributed_port: Optional: Master node (rank 0)'s free port that needs to be used for communication during distributed training
+
+        mpu: Optional: A model parallelism unit object that implements
+            get_{model,data}_parallel_{rank,group,world_size}()
+
+        dist_init_required: Optional: None will auto-initialize torch distributed if needed,
+            otherwise the user can force it to be initialized or not via boolean.
+
+        collate_fn: Optional: Merges a list of samples to form a
+            mini-batch of Tensor(s).  Used when using batched loading from a
+            map-style dataset.
+
+        config: Optional: Instead of requiring args.deepspeed_config you can pass your deepspeed config
+            as an argument instead, as a path or a dictionary.
+
+        config_params: Optional: Same as `config`, kept for backwards compatibility.
+
+    Returns:
+        A tuple of ``engine``, ``optimizer``, ``training_dataloader``, ``lr_scheduler``
+
+        * ``engine``: DeepSpeed runtime engine which wraps the client model for distributed training.
+
+        * ``optimizer``: Wrapped optimizer if a user defined ``optimizer`` is supplied, or if
+          optimizer is specified in json config else ``None``.
+
+        * ``training_dataloader``: DeepSpeed dataloader if ``training_data`` was supplied,
+          otherwise ``None``.
+
+        * ``lr_scheduler``: Wrapped lr scheduler if user ``lr_scheduler`` is passed, or
+          if ``lr_scheduler`` specified in JSON configuration. Otherwise ``None``.
+    """
+    log_dist("DeepSpeed info: version={}, git-hash={}, git-branch={}".format(__version__, __git_hash__,
+                                                                             __git_branch__),
+             ranks=[0])
+
+    # Disable zero.Init context if it's currently enabled
+    zero.partition_parameters.shutdown_init_context()
+
+    assert model is not None, "deepspeed.initialize requires a model"
+
+    global dist
+    from deepspeed import comm as dist
+    dist_backend = get_accelerator().communication_backend_name()
+    dist.init_distributed(dist_backend=dist_backend,
+                          distributed_port=distributed_port,
+                          dist_init_required=dist_init_required)
+
+    # Set config using config_params for backwards compat
+    if config is None and config_params is not None:
+        config = config_params
+
+    # Check for deepscale_config for backwards compat
+    if hasattr(args, "deepscale_config") and args.deepscale_config is not None:
+        logger.warning("************ --deepscale_config is deprecated, please use --deepspeed_config ************")
+        if hasattr(args, "deepspeed_config"):
+            assert (args.deepspeed_config is
+                    None), "Not sure how to proceed, we were given both a deepscale_config and deepspeed_config"
+        args.deepspeed_config = args.deepscale_config
+        args.deepscale_config = None
+
+    # Check that we have only one config passed
+    if hasattr(args, "deepspeed_config") and args.deepspeed_config is not None:
+        assert config is None, "Not sure how to proceed, we were given deepspeed configs in the deepspeed arguments and deepspeed.initialize() function call"
+        config = args.deepspeed_config
+    assert config is not None, "DeepSpeed requires --deepspeed_config to specify configuration file"
+
+    if not isinstance(model, PipelineModule):
+        config_class = DeepSpeedConfig(config, mpu)
+        if config_class.hybrid_engine.enabled:
+            engine = DeepSpeedHybridEngine(args=args,
+                                           model=model,
+                                           optimizer=optimizer,
+                                           model_parameters=model_parameters,
+                                           training_data=training_data,
+                                           lr_scheduler=lr_scheduler,
+                                           mpu=mpu,
+                                           dist_init_required=dist_init_required,
+                                           collate_fn=collate_fn,
+                                           config=config,
+                                           config_class=config_class)
+        else:
+            engine = DeepSpeedEngine(args=args,
+                                     model=model,
+                                     optimizer=optimizer,
+                                     model_parameters=model_parameters,
+                                     training_data=training_data,
+                                     lr_scheduler=lr_scheduler,
+                                     mpu=mpu,
+                                     dist_init_required=dist_init_required,
+                                     collate_fn=collate_fn,
+                                     config=config,
+                                     config_class=config_class)
+    else:
+        assert mpu is None, "mpu must be None with pipeline parallelism"
+        mpu = model.mpu()
+        config_class = DeepSpeedConfig(config, mpu)
+        engine = PipelineEngine(args=args,
+                                model=model,
+                                optimizer=optimizer,
+                                model_parameters=model_parameters,
+                                training_data=training_data,
+                                lr_scheduler=lr_scheduler,
+                                mpu=mpu,
+                                dist_init_required=dist_init_required,
+                                collate_fn=collate_fn,
+                                config=config,
+                                config_class=config_class)
+
+    # Restore zero.Init context if necessary
+    zero.partition_parameters.restore_init_context()
+
+    return_items = [engine, engine.optimizer, engine.training_dataloader, engine.lr_scheduler]
+    return tuple(return_items)
+
+
+def _add_core_arguments(parser):
+    r"""Helper (internal) function to update an argument parser with an argument group of the core DeepSpeed arguments.
+        The core set of DeepSpeed arguments include the following:
+        1) --deepspeed: boolean flag to enable DeepSpeed
+        2) --deepspeed_config <json file path>: path of a json configuration file to configure DeepSpeed runtime.
+
+        This is a helper function to the public add_config_arguments()
+
+    Arguments:
+        parser: argument parser
+    Return:
+        parser: Updated Parser
+    """
+    group = parser.add_argument_group('DeepSpeed', 'DeepSpeed configurations')
+
+    group.add_argument('--deepspeed',
+                       default=False,
+                       action='store_true',
+                       help='Enable DeepSpeed (helper flag for user code, no impact on DeepSpeed backend)')
+
+    group.add_argument('--deepspeed_config', default=None, type=str, help='DeepSpeed json configuration file.')
+
+    group.add_argument('--deepscale',
+                       default=False,
+                       action='store_true',
+                       help='Deprecated enable DeepSpeed (helper flag for user code, no impact on DeepSpeed backend)')
+
+    group.add_argument('--deepscale_config',
+                       default=None,
+                       type=str,
+                       help='Deprecated DeepSpeed json configuration file.')
+
+    return parser
+
+
+def add_config_arguments(parser):
+    r"""Update the argument parser to enabling parsing of DeepSpeed command line arguments.
+        The set of DeepSpeed arguments include the following:
+        1) --deepspeed: boolean flag to enable DeepSpeed
+        2) --deepspeed_config <json file path>: path of a json configuration file to configure DeepSpeed runtime.
+
+    Arguments:
+        parser: argument parser
+    Return:
+        parser: Updated Parser
+    """
+    parser = _add_core_arguments(parser)
+
+    return parser
+
+
+def default_inference_config():
+    """
+        Return a default DeepSpeed inference configuration dictionary.
+    """
+    return DeepSpeedInferenceConfig().dict()
+
+
+def init_inference(model, config=None, **kwargs):
+    """Initialize the DeepSpeed InferenceEngine.
+
+    Description: all four cases are valid and supported in DS init_inference() API.
+
+    # Case 1: user provides no config and no kwargs. Default config will be used.
+
+    .. code-block:: python
+
+        generator.model = deepspeed.init_inference(generator.model)
+        string = generator("DeepSpeed is")
+        print(string)
+
+    # Case 2: user provides a config and no kwargs. User supplied config will be used.
+
+    .. code-block:: python
+
+        generator.model = deepspeed.init_inference(generator.model, config=config)
+        string = generator("DeepSpeed is")
+        print(string)
+
+    # Case 3: user provides no config and uses keyword arguments (kwargs) only.
+
+    .. code-block:: python
+
+        generator.model = deepspeed.init_inference(generator.model,
+                                                    tensor_parallel={"tp_size": world_size},
+                                                    dtype=torch.half,
+                                                    replace_with_kernel_inject=True)
+        string = generator("DeepSpeed is")
+        print(string)
+
+    # Case 4: user provides config and keyword arguments (kwargs). Both config and kwargs are merged and kwargs take precedence.
+
+    .. code-block:: python
+
+        generator.model = deepspeed.init_inference(generator.model, config={"dtype": torch.half}, replace_with_kernel_inject=True)
+        string = generator("DeepSpeed is")
+        print(string)
+
+    Arguments:
+        model: Required: original nn.module object without any wrappers
+
+        config: Optional: instead of arguments, you can pass in a DS inference config dict or path to JSON file
+
+    Returns:
+        A deepspeed.InferenceEngine wrapped model.
+    """
+    log_dist("DeepSpeed info: version={}, git-hash={}, git-branch={}".format(__version__, __git_hash__,
+                                                                             __git_branch__),
+             ranks=[0])
+
+    # Load config_dict from config first
+    if config is None:
+        config = {}
+    if isinstance(config, str):
+        with open(config, "r") as f:
+            config_dict = json.load(f)
+    elif isinstance(config, dict):
+        config_dict = config
+    else:
+        raise ValueError(f"'config' argument expected string or dictionary, got {type(config)}")
+
+    # Update with values from kwargs, ensuring no conflicting overlap between config and kwargs
+    overlap_keys = set(config_dict.keys()).intersection(kwargs.keys())
+    # If there is overlap, error out if values are different
+    for key in overlap_keys:
+        if config_dict[key] != kwargs[key]:
+            raise ValueError(f"Conflicting argument '{key}' in 'config':{config_dict[key]} and kwargs:{kwargs[key]}")
+    config_dict.update(kwargs)
+
+    ds_inference_config = DeepSpeedInferenceConfig(**config_dict)
+
+    engine = InferenceEngine(model, config=ds_inference_config)
+
+    return engine

venv/lib/python3.10/site-packages/deepspeed/constants.py

@@ -0,0 +1,21 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import os
+from datetime import timedelta
+
+#############################################
+# Torch distributed constants
+#############################################
+TORCH_DISTRIBUTED_DEFAULT_PORT = 29500
+
+# Default process group wide timeout, if applicable.
+# This only applies to the gloo and nccl backends
+# (only if NCCL_BLOCKING_WAIT or NCCL_ASYNC_ERROR_HANDLING is set to 1).
+# To make an attempt at backwards compatibility with THD, we use an
+# extraordinarily high default timeout, given that THD did not have timeouts.
+default_pg_timeout = timedelta(minutes=int(os.getenv("DEEPSPEED_TIMEOUT", default=30)))
+INFERENCE_GENERIC_MODE = 'generic'
+INFERENCE_SPECIALIZED_MODE = 'specialized'

venv/lib/python3.10/site-packages/deepspeed/env_report.py

@@ -0,0 +1,195 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import os
+import torch
+import deepspeed
+import subprocess
+import argparse
+from .ops.op_builder.all_ops import ALL_OPS
+from .git_version_info import installed_ops, torch_info, accelerator_name
+from deepspeed.accelerator import get_accelerator
+
+GREEN = '\033[92m'
+RED = '\033[91m'
+YELLOW = '\033[93m'
+END = '\033[0m'
+SUCCESS = f"{GREEN} [SUCCESS] {END}"
+OKAY = f"{GREEN}[OKAY]{END}"
+WARNING = f"{YELLOW}[WARNING]{END}"
+FAIL = f'{RED}[FAIL]{END}'
+INFO = '[INFO]'
+
+color_len = len(GREEN) + len(END)
+okay = f"{GREEN}[OKAY]{END}"
+warning = f"{YELLOW}[WARNING]{END}"
+
+
+def op_report(verbose=True):
+    max_dots = 23
+    max_dots2 = 11
+    h = ["op name", "installed", "compatible"]
+    print("-" * (max_dots + max_dots2 + len(h[0]) + len(h[1])))
+    print("DeepSpeed C++/CUDA extension op report")
+    print("-" * (max_dots + max_dots2 + len(h[0]) + len(h[1])))
+
+    print("NOTE: Ops not installed will be just-in-time (JIT) compiled at\n"
+          "      runtime if needed. Op compatibility means that your system\n"
+          "      meet the required dependencies to JIT install the op.")
+
+    print("-" * (max_dots + max_dots2 + len(h[0]) + len(h[1])))
+    print("JIT compiled ops requires ninja")
+    ninja_status = OKAY if ninja_installed() else FAIL
+    print('ninja', "." * (max_dots - 5), ninja_status)
+    print("-" * (max_dots + max_dots2 + len(h[0]) + len(h[1])))
+    print(h[0], "." * (max_dots - len(h[0])), h[1], "." * (max_dots2 - len(h[1])), h[2])
+    print("-" * (max_dots + max_dots2 + len(h[0]) + len(h[1])))
+    installed = f"{GREEN}[YES]{END}"
+    no = f"{YELLOW}[NO]{END}"
+    for op_name, builder in ALL_OPS.items():
+        dots = "." * (max_dots - len(op_name))
+        is_compatible = OKAY if builder.is_compatible(verbose) else no
+        is_installed = installed if installed_ops.get(op_name,
+                                                      False) and accelerator_name == get_accelerator()._name else no
+        dots2 = '.' * ((len(h[1]) + (max_dots2 - len(h[1]))) - (len(is_installed) - color_len))
+        print(op_name, dots, is_installed, dots2, is_compatible)
+    print("-" * (max_dots + max_dots2 + len(h[0]) + len(h[1])))
+
+
+def ninja_installed():
+    try:
+        import ninja  # noqa: F401 # type: ignore
+    except ImportError:
+        return False
+    return True
+
+
+def nvcc_version():
+    import torch.utils.cpp_extension
+    cuda_home = torch.utils.cpp_extension.CUDA_HOME
+    if cuda_home is None:
+        return f"{RED} [FAIL] cannot find CUDA_HOME via torch.utils.cpp_extension.CUDA_HOME={torch.utils.cpp_extension.CUDA_HOME} {END}"
+    try:
+        output = subprocess.check_output([cuda_home + "/bin/nvcc", "-V"], universal_newlines=True)
+    except FileNotFoundError:
+        return f"{RED} [FAIL] nvcc missing {END}"
+    output_split = output.split()
+    release_idx = output_split.index("release")
+    release = output_split[release_idx + 1].replace(',', '').split(".")
+    return ".".join(release)
+
+
+def installed_cann_path():
+    if "ASCEND_HOME_PATH" in os.environ or os.path.exists(os.environ["ASCEND_HOME_PATH"]):
+        return os.environ["ASCEND_HOME_PATH"]
+    return None
+
+
+def installed_cann_version():
+    import re
+    ascend_path = installed_cann_path()
+    if ascend_path is None:
+        return f"CANN_HOME does not exist, unable to compile NPU op(s)"
+    cann_version = ""
+    for dirpath, _, filenames in os.walk(os.path.realpath(ascend_path)):
+        if cann_version:
+            break
+        install_files = [file for file in filenames if re.match(r"ascend_.*_install\.info", file)]
+        if install_files:
+            filepath = os.path.join(dirpath, install_files[0])
+            with open(filepath, "r") as f:
+                for line in f:
+                    if line.find("version") != -1:
+                        cann_version = line.strip().split("=")[-1]
+                        break
+    return cann_version
+
+
+def get_shm_size():
+    try:
+        shm_stats = os.statvfs('/dev/shm')
+    except (OSError, FileNotFoundError, ValueError):
+        return "UNKNOWN", None
+
+    shm_size = shm_stats.f_frsize * shm_stats.f_blocks
+    shm_hbytes = human_readable_size(shm_size)
+    warn = []
+    if shm_size < 512 * 1024**2:
+        warn.append(
+            f" {YELLOW} [WARNING] /dev/shm size might be too small, if running in docker increase to at least --shm-size='1gb' {END}"
+        )
+        if get_accelerator().communication_backend_name() == "nccl":
+            warn.append(
+                f" {YELLOW} [WARNING] see more details about NCCL requirements: https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/troubleshooting.html#sharing-data {END}"
+            )
+    return shm_hbytes, warn
+
+
+def human_readable_size(size):
+    units = ['B', 'KB', 'MB', 'GB', 'TB']
+    i = 0
+    while size >= 1024 and i < len(units) - 1:
+        size /= 1024
+        i += 1
+    return f'{size:.2f} {units[i]}'
+
+
+def debug_report():
+    max_dots = 33
+
+    report = [("torch install path", torch.__path__), ("torch version", torch.__version__),
+              ("deepspeed install path", deepspeed.__path__),
+              ("deepspeed info", f"{deepspeed.__version__}, {deepspeed.__git_hash__}, {deepspeed.__git_branch__}")]
+    if get_accelerator().device_name() == 'cuda':
+        hip_version = getattr(torch.version, "hip", None)
+        report.extend([("torch cuda version", torch.version.cuda), ("torch hip version", hip_version),
+                       ("nvcc version", (None if hip_version else nvcc_version())),
+                       ("deepspeed wheel compiled w.", f"torch {torch_info['version']}, " +
+                        (f"hip {torch_info['hip_version']}" if hip_version else f"cuda {torch_info['cuda_version']}"))
+                       ])
+    elif get_accelerator().device_name() == 'npu':
+        import torch_npu
+        report.extend([("deepspeed wheel compiled w.", f"torch {torch_info['version']}"),
+                       ("torch_npu install path", torch_npu.__path__), ("torch_npu version", torch_npu.__version__),
+                       ("ascend_cann version", installed_cann_version())])
+    else:
+        report.extend([("deepspeed wheel compiled w.", f"torch {torch_info['version']} ")])
+
+    report.append(("shared memory (/dev/shm) size", get_shm_size()))
+
+    print("DeepSpeed general environment info:")
+    for name, value in report:
+        warns = []
+        if isinstance(value, tuple):
+            value, warns = value
+        print(name, "." * (max_dots - len(name)), value)
+        if warns:
+            for warn in warns:
+                print(warn)
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--hide_operator_status',
+                        action='store_true',
+                        help='Suppress display of installation and compatibility statuses of DeepSpeed operators. ')
+    parser.add_argument('--hide_errors_and_warnings', action='store_true', help='Suppress warning and error messages.')
+    args = parser.parse_args()
+    return args
+
+
+def main(hide_operator_status=False, hide_errors_and_warnings=False):
+    if not hide_operator_status:
+        op_report(verbose=not hide_errors_and_warnings)
+    debug_report()
+
+
+def cli_main():
+    args = parse_arguments()
+    main(hide_operator_status=args.hide_operator_status, hide_errors_and_warnings=args.hide_errors_and_warnings)
+
+
+if __name__ == "__main__":
+    main()

venv/lib/python3.10/site-packages/deepspeed/git_version_info.py

@@ -0,0 +1,31 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+try:
+    #  This is populated by setup.py
+    from .git_version_info_installed import *  # noqa: F401 # type: ignore
+except ModuleNotFoundError:
+    import os
+    if os.path.isfile('version.txt'):
+        # Will be missing from checkouts that haven't been installed (e.g., readthedocs)
+        version = open('version.txt', 'r').read().strip()
+    else:
+        version = "0.0.0"
+    git_hash = '[none]'
+    git_branch = '[none]'
+
+    from .ops.op_builder.all_ops import ALL_OPS
+    installed_ops = dict.fromkeys(ALL_OPS.keys(), False)
+    accelerator_name = ""
+    torch_info = {'version': "0.0", "cuda_version": "0.0", "hip_version": "0.0"}
+
+# compatible_ops list is recreated for each launch
+from .ops.op_builder.all_ops import ALL_OPS
+
+compatible_ops = dict.fromkeys(ALL_OPS.keys(), False)
+for op_name, builder in ALL_OPS.items():
+    op_compatible = builder.is_compatible()
+    compatible_ops[op_name] = op_compatible
+    compatible_ops["deepspeed_not_implemented"] = False

venv/lib/python3.10/site-packages/deepspeed/git_version_info_installed.py

@@ -0,0 +1,6 @@
+version='0.14.2'
+git_hash='unknown'
+git_branch='unknown'
+installed_ops={'deepspeed_not_implemented': False, 'deepspeed_ccl_comm': False, 'deepspeed_shm_comm': False, 'cpu_adam': False, 'fused_adam': False}
+accelerator_name='cpu'
+torch_info={'version': '2.3', 'bf16_support': False, 'cuda_version': '12.1', 'nccl_version': '2.20', 'hip_version': '0.0'}

venv/lib/python3.10/site-packages/deepspeed/pydantic_v1.py

@@ -0,0 +1,16 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""Pydantic v1 compatibility module.
+
+Pydantic v2 introduced breaking changes that hinder its adoption:
+https://docs.pydantic.dev/latest/migration/. To provide deepspeed users the option to
+migrate to pydantic v2 on their own timeline, deepspeed uses this compatibility module
+as a pydantic-version-agnostic alias for pydantic's v1 API.
+"""
+
+try:
+    from pydantic.v1 import *  # noqa: F401
+except ImportError:
+    from pydantic import *  # noqa: F401

venv/lib/python3.10/site-packages/deepspeed/runtime/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team

venv/lib/python3.10/site-packages/deepspeed/runtime/bf16_optimizer.py

@@ -0,0 +1,556 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from collections import OrderedDict
+import torch
+import sys
+from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
+from deepspeed import comm as dist
+from deepspeed.runtime.constants import PIPE_REPLICATED
+from deepspeed.runtime.base_optimizer import ZeROOptimizer
+from packaging import version as pkg_version
+from deepspeed.git_version_info import version
+from deepspeed.runtime.utils import (get_global_norm_of_tensors, clip_tensors_by_global_norm, DummyOptim,
+                                     align_dense_tensors, all_gather_dp_groups, is_model_parallel_parameter,
+                                     see_memory_usage, graph_process, get_norm_with_moe_layers)
+from deepspeed.utils import link_hp_params, lazy_init_hp_params_optimizer_state, fragment_address, groups
+from deepspeed.moe.utils import is_moe_param, is_moe_param_group
+from deepspeed.utils.bwc import bwc_tensor_model_parallel_rank
+from deepspeed.checkpoint import enable_universal_checkpoint
+from deepspeed.checkpoint.constants import (DS_VERSION, PARTITION_COUNT, BASE_OPTIMIZER_STATE,
+                                            SINGLE_PARTITION_OF_FP32_GROUPS, CLIP_GRAD, GROUP_PADDINGS,
+                                            PARAM_SLICE_MAPPINGS)
+
+setattr(sys.modules[__name__], 'fragment_address', fragment_address)
+
+
+class BF16_Optimizer(ZeROOptimizer):
+
+    def __init__(self,
+                 init_optimizer,
+                 param_names,
+                 mpu=None,
+                 clip_grad=0.0,
+                 norm_type=2,
+                 allgather_bucket_size=5000000000,
+                 dp_process_group=None,
+                 timers=None,
+                 grad_acc_dtype=None,
+                 graph_harvesting=False,
+                 immediate_grad_update=False,
+                 has_moe_layers=False):
+        super().__init__()
+        see_memory_usage('begin bf16_optimizer', force=True)
+        self.timers = timers
+        self.optimizer = init_optimizer
+        self.param_names = param_names
+        self.using_real_optimizer = not isinstance(self.optimizer, DummyOptim)
+
+        assert grad_acc_dtype in [torch.float32, torch.bfloat16
+                                  ], f"BF16Optimizer: Unsupported gradient accumulation data type: {grad_acc_dtype}"
+        self.grad_acc_dtype = grad_acc_dtype
+        self.immediate_grad_update = immediate_grad_update
+
+        self.clip_grad = clip_grad
+        self.norm_type = norm_type
+        self.mpu = mpu
+        self.allgather_bucket_size = int(allgather_bucket_size)
+        self.dp_process_group = dp_process_group
+        self.dp_rank = dist.get_rank(group=self.dp_process_group)
+        self.has_moe_layers = has_moe_layers
+        self.non_expert_gradients = []
+        self.real_dp_process_group = [dp_process_group for i in range(len(self.optimizer.param_groups))]
+        if self.has_moe_layers:
+            self._configure_moe_settings()
+
+        # Use torch (un)flatten ops
+        self.flatten = _flatten_dense_tensors
+        self.unflatten = _unflatten_dense_tensors
+
+        #align nccl all-gather send buffers to 4-bye boundary
+        self.nccl_start_alignment_factor = 2  # 4-byte alignment/sizeof(fp16) = 2
+
+        # Build BF16/FP32 groups
+        self.bf16_groups = []
+        self.bf16_groups_flat = []
+        self.bf16_partitioned_groups = []
+
+        self.fp32_groups_flat_partition = []
+
+        # Maintain different fp32 gradients views for convenience
+        self.fp32_groups_gradients = []
+        self.fp32_groups_gradient_dict = {}
+        self.fp32_groups_gradients_flat = []
+        self.fp32_groups_actual_gradients_flat = []
+        self.fp32_groups_gradient_flat_partition = []
+        self.fp32_groups_has_gradients = []
+
+        self.group_paddings = []
+        self.graph_harvesting = graph_harvesting
+        if self.using_real_optimizer:
+            self._setup_for_real_optimizer()
+
+        see_memory_usage('end bf16_optimizer', force=True)
+
+    def _configure_moe_settings(self):
+        assert any(
+            [is_moe_param_group(group) for group in self.optimizer.param_groups]
+        ), "The model has moe layers, but None of the param groups are marked as MoE. Create a param group with 'moe' key set to True before creating optimizer"
+
+        for i, group in enumerate(self.optimizer.param_groups):
+            if is_moe_param_group(group):
+                assert all([is_moe_param(param)
+                            for param in group['params']]), "All params in MoE group must be MoE params"
+                self.real_dp_process_group[i] = groups._get_expert_data_parallel_group(group['name'])
+        self.expert_gradients = {}
+        if self.has_moe_layers:
+            for key in groups._get_expert_data_parallel_group_dict().keys():
+                self.expert_gradients[key] = []
+
+    def _setup_for_real_optimizer(self):
+        self.partition_count = [dist.get_world_size(group=pg) for pg in self.real_dp_process_group]
+
+        for i, param_group in enumerate(self.optimizer.param_groups):
+            real_dp_world_size = dist.get_world_size(group=self.real_dp_process_group[i])
+            see_memory_usage(f'before initializing group {i}', force=True)
+
+            partition_id = dist.get_rank(group=self.real_dp_process_group[i])
+
+            # grab the original list
+            trainable_parameters = [param for param in param_group['params'] if param.requires_grad]
+            self.bf16_groups.append(trainable_parameters)
+
+            # create flat bf16 params
+            self.bf16_groups_flat.append(
+                self._flatten_dense_tensors_aligned(self.bf16_groups[i],
+                                                    self.nccl_start_alignment_factor * real_dp_world_size))
+            # Make bf16 params point to flat tensor storage
+            self._update_storage_to_flattened_tensor(tensor_list=self.bf16_groups[i],
+                                                     flat_tensor=self.bf16_groups_flat[i])
+
+            # divide flat weights into equal sized partitions
+            partition_size = self.bf16_groups_flat[i].numel() // real_dp_world_size
+            bf16_dp_partitions = [
+                self.bf16_groups_flat[i].narrow(0, dp_index * partition_size, partition_size)
+                for dp_index in range(real_dp_world_size)
+            ]
+            self.bf16_partitioned_groups.append(bf16_dp_partitions)
+
+            # create fp32 params partition
+            self.fp32_groups_flat_partition.append(bf16_dp_partitions[partition_id].clone().float().detach())
+            self.fp32_groups_flat_partition[i].requires_grad = True
+
+            num_elem_list = [t.numel() for t in self.bf16_groups[i]]
+
+            # create fp32 gradients
+            fp32_flat_buffer = torch.zeros_like(self.bf16_groups_flat[i], dtype=self.grad_acc_dtype)
+            self.fp32_groups_gradients_flat.append(fp32_flat_buffer)
+            if self.has_moe_layers and is_moe_param_group(param_group):
+                self.expert_gradients[param_group['name']].append(fp32_flat_buffer)
+            else:
+                self.non_expert_gradients.append(fp32_flat_buffer)
+
+            # track individual fp32 gradients for entire model
+            fp32_gradients = self._split_flat_tensor(flat_tensor=self.fp32_groups_gradients_flat[i],
+                                                     num_elem_list=num_elem_list)
+            self.fp32_groups_gradients.append(fp32_gradients)
+            self.fp32_groups_gradient_dict[i] = fp32_gradients
+
+            # flat tensor corresponding to actual fp32 gradients (i.e., minus alignment padding)
+            length_without_padding = sum(num_elem_list)
+            self.fp32_groups_actual_gradients_flat.append(
+                torch.narrow(self.fp32_groups_gradients_flat[i], 0, 0, length_without_padding))
+
+            # flat tensor corresponding to gradient partition
+            self.fp32_groups_gradient_flat_partition.append(
+                torch.narrow(self.fp32_groups_gradients_flat[i], 0, partition_id * partition_size, partition_size))
+
+            # track fp32 gradient updates
+            self.fp32_groups_has_gradients.append([False] * len(self.bf16_groups[i]))
+
+            # Record padding required for alignment
+            if partition_id == dist.get_world_size(group=self.real_dp_process_group[i]) - 1:
+                padding = self.bf16_groups_flat[i].numel() - length_without_padding
+            else:
+                padding = 0
+
+            self.group_paddings.append(padding)
+
+            # update optimizer param groups to reference fp32 params partition
+            param_group['params'] = [self.fp32_groups_flat_partition[i]]
+
+            see_memory_usage(f'after initializing group {i}', force=True)
+
+        see_memory_usage('before initialize_optimizer', force=True)
+        self.initialize_optimizer_states()
+        see_memory_usage('end initialize_optimizer', force=True)
+
+        if self.immediate_grad_update:
+            self.create_grad_acc_hooks()
+
+        # Need optimizer states initialized before linking lp to optimizer state
+        self._link_all_hp_params()
+        self._hp_optimizer_states_linked = False
+        self._enable_universal_checkpoint()
+        self._param_slice_mappings = self._create_param_mapping()
+
+    def _enable_universal_checkpoint(self):
+        for lp_param_group in self.bf16_groups:
+            enable_universal_checkpoint(param_list=lp_param_group)
+
+    def _create_param_mapping(self):
+        param_mapping = []
+        for i, _ in enumerate(self.optimizer.param_groups):
+            param_mapping_per_group = OrderedDict()
+            for lp in self.bf16_groups[i]:
+                if lp._hp_mapping is not None:
+                    lp_name = self.param_names[lp]
+                    param_mapping_per_group[lp_name] = lp._hp_mapping.get_hp_fragment_address()
+            param_mapping.append(param_mapping_per_group)
+
+        return param_mapping
+
+    def _link_all_hp_params(self):
+        for i, _ in enumerate(self.optimizer.param_groups):
+            real_dp_world_size = dist.get_world_size(group=self.real_dp_process_group[i])
+
+            # Link bf16 and fp32 params in partition
+            partition_id = dist.get_rank(group=self.real_dp_process_group[i])
+            partition_size = self.bf16_groups_flat[i].numel() // real_dp_world_size
+            flat_hp_partition = self.fp32_groups_flat_partition[i]
+            link_hp_params(lp_param_list=self.bf16_groups[i],
+                           flat_hp_partition=flat_hp_partition,
+                           gradient_dict=self.fp32_groups_gradient_dict,
+                           offload_gradient_dict=None,
+                           use_offload=False,
+                           param_group_index=i,
+                           partition_start=partition_id * partition_size,
+                           partition_size=partition_size,
+                           dp_group=self.real_dp_process_group[i])
+
+    def _lazy_init_hp_params_optimizer_state(self):
+        if not self._hp_optimizer_states_linked:
+            for i, _ in enumerate(self.optimizer.param_groups):
+                lazy_init_hp_params_optimizer_state(self.bf16_groups[i], self.fp32_groups_flat_partition[i],
+                                                    self.optimizer.state)
+            self._hp_optimizer_states_linked = True
+
+    def initialize_optimizer_states(self):
+        """Take an optimizer step with zero-valued gradients to allocate internal
+        optimizer state.
+
+        This helps prevent memory fragmentation by allocating optimizer state at the
+        beginning of training instead of after activations have been allocated.
+        """
+        for param_partition, grad_partition in zip(self.fp32_groups_flat_partition,
+                                                   self.fp32_groups_gradient_flat_partition):
+            # In case of grad acc dtype different than FP32, need to cast to high precision.
+            param_partition.grad = grad_partition.to(
+                param_partition.dtype) if grad_partition.dtype != param_partition.dtype else grad_partition
+
+        if self.grad_acc_dtype is not torch.float32:
+            for param_partition in self.fp32_groups_flat_partition:
+                param_partition.grad = None
+
+        self.clear_hp_grads()
+
+    def _split_flat_tensor(self, flat_tensor, num_elem_list):
+        assert sum(num_elem_list) <= flat_tensor.numel()
+        tensor_list = []
+        offset = 0
+        for num_elem in num_elem_list:
+            dense_tensor = torch.narrow(flat_tensor, 0, offset, num_elem)
+            tensor_list.append(dense_tensor)
+            offset += num_elem
+
+        return tensor_list
+
+    def _update_storage_to_flattened_tensor(self, tensor_list, flat_tensor):
+        updated_params = self.unflatten(flat_tensor, tensor_list)
+        for p, q in zip(tensor_list, updated_params):
+            p.data = q.data
+
+    def _flatten_dense_tensors_aligned(self, tensor_list, alignment):
+        return self.flatten(align_dense_tensors(tensor_list, alignment))
+
+    @torch.no_grad()
+    def step(self, closure=None):
+        if closure is not None:
+            raise NotImplementedError(f'{self.__class__} does not support closure.')
+
+        non_expert_grads_for_norm, expert_grads_for_norm = self.get_grads_for_norm()
+        non_expert_groups_norm = get_global_norm_of_tensors(input_tensors=non_expert_grads_for_norm,
+                                                            mpu=self.mpu,
+                                                            norm_type=self.norm_type,
+                                                            use_graph=self.graph_harvesting)
+        all_groups_norm = non_expert_groups_norm
+        if self.has_moe_layers:
+            all_groups_norm = get_norm_with_moe_layers(non_expert_groups_norm,
+                                                       mpu=self.mpu,
+                                                       expert_tensors=expert_grads_for_norm,
+                                                       norm_type=self.norm_type)
+
+        self._global_grad_norm = all_groups_norm
+
+        assert all_groups_norm > 0.
+        if self.clip_grad > 0.:
+            clip_tensors_by_global_norm(input_tensors=self.get_grads_for_norm(for_clipping=True),
+                                        max_norm=self.clip_grad,
+                                        global_norm=all_groups_norm,
+                                        mpu=self.mpu,
+                                        use_graph=self.graph_harvesting)
+
+        self.optimizer.step()
+
+        # We need to link optimizer state after the first step() call
+        self._lazy_init_hp_params_optimizer_state()
+
+        self.update_lp_params()
+
+        self.clear_hp_grads()
+
+    def backward(self, loss, update_hp_grads=True, clear_lp_grads=False, **bwd_kwargs):
+        """Perform a backward pass and copy the low-precision gradients to the
+        high-precision copy.
+
+        We copy/accumulate to the high-precision grads now to prevent accumulating in the
+        bf16 grads after successive backward() calls (i.e., grad accumulation steps > 1)
+
+        The low-precision grads are deallocated during this procedure.
+        """
+        self.clear_lp_grads()
+        loss.backward(**bwd_kwargs)
+
+        if update_hp_grads:
+            self.update_hp_grads(clear_lp_grads=clear_lp_grads)
+
+    @torch.no_grad()
+    def _update_hp_grad(self, lp, group_idx, param_idx, clear_lp_grads):
+        if lp.grad is None:
+            return
+
+        hp_grad = self.fp32_groups_gradients[group_idx][param_idx]
+        assert hp_grad is not None, \
+            f'high precision param has no gradient, lp param_id = {id(lp)} group_info = [{group_idx}][{param_idx}]'
+
+        hp_grad.data.add_(lp.grad.data.to(hp_grad.dtype).view(hp_grad.shape))
+        lp._hp_grad = hp_grad
+        self.fp32_groups_has_gradients[group_idx][param_idx] = True
+
+        # clear gradients
+        if clear_lp_grads:
+            lp.grad.zero_()
+
+    @torch.no_grad()
+    def _update_hp_grads_func(self, clear_lp_grads=False):
+        for i, group in enumerate(self.bf16_groups):
+            for j, lp in enumerate(group):
+                self._update_hp_grad(lp, i, j, clear_lp_grads)
+
+    @torch.no_grad()
+    def update_hp_grads(self, clear_lp_grads=False):
+        if self.immediate_grad_update:
+            return
+
+        if self.graph_harvesting:
+            graph_process(False, self._update_hp_grads_func, clear_lp_grads)
+        else:
+            self._update_hp_grads_func(clear_lp_grads)
+        #cpu op
+        for i, group in enumerate(self.bf16_groups):
+            for j, lp in enumerate(group):
+                if lp.grad is None:
+                    continue
+                self.fp32_groups_has_gradients[i][j] = True
+
+    @torch.no_grad()
+    def get_grads_for_reduction(self):
+        if self.has_moe_layers:
+            return self.non_expert_gradients, self.expert_gradients
+        return self.non_expert_gradients, {}
+
+    @torch.no_grad()
+    def get_grads_for_norm(self, for_clipping=False):
+        """
+        Returns:
+            tuple[list[Tensor], dict[ep_name, List[Tensor]] | list:
+            If for_clipping, return all gradients.
+            Otherwise, separate and return dict of expert_grad and list of non_expert_grad
+        """
+        # (grads, expert_group_name)
+        expert_grads_for_norm = {}
+
+        # grads
+        non_expert_grads_for_norm = []
+        all_grads_for_clip = []
+
+        tensor_mp_rank = bwc_tensor_model_parallel_rank(mpu=self.mpu)
+        assert len(self.bf16_groups) == len(self.optimizer.param_groups)
+        for i, group in enumerate(self.bf16_groups):
+            for j, lp in enumerate(group):
+                if not for_clipping:
+                    if hasattr(lp, PIPE_REPLICATED) and lp.ds_pipe_replicated:
+                        continue
+
+                    # skip duplicated parameters. perform norm only on cards with tp_rank=0.
+                    # non-duplicated parameters include:
+                    # - Parameters with tp: Use allreducesum of mp_group.
+                    # - Moe Parameters with ep: Use allreducesum of ep_group.
+                    if not (tensor_mp_rank == 0 or is_model_parallel_parameter(lp) or is_moe_param(lp)):
+                        continue
+
+                if not self.fp32_groups_has_gradients[i][j]:
+                    continue
+                if not for_clipping:
+                    param_group = self.optimizer.param_groups[i]
+                    if self.has_moe_layers and is_moe_param_group(param_group):
+                        if param_group['name'] not in expert_grads_for_norm:
+                            expert_grads_for_norm[param_group['name']] = []
+                        expert_grads_for_norm[param_group['name']].append(self.fp32_groups_gradients[i][j])
+                    else:
+                        non_expert_grads_for_norm.append(self.fp32_groups_gradients[i][j])
+                else:
+                    all_grads_for_clip.append(self.fp32_groups_gradients[i][j])
+        if not for_clipping:
+            return non_expert_grads_for_norm, expert_grads_for_norm
+        return all_grads_for_clip
+
+    @torch.no_grad()
+    def update_lp_params(self):
+        for i, (bf16_partitions,
+                fp32_partition) in enumerate(zip(self.bf16_partitioned_groups, self.fp32_groups_flat_partition)):
+            partition_id = dist.get_rank(group=self.real_dp_process_group[i])
+            bf16_partitions[partition_id].data.copy_(fp32_partition.data)
+            # print_rank_0(f'update_lp_params {i=} {partition_id=}', force=True)
+            # if i == 0:
+            #     print_rank_0(f'{fp32_partition[:10]=}', force=True)
+
+        all_gather_dp_groups(groups_flat=self.bf16_groups_flat,
+                             partitioned_param_groups=self.bf16_partitioned_groups,
+                             dp_process_group=self.real_dp_process_group,
+                             start_alignment_factor=self.nccl_start_alignment_factor,
+                             allgather_bucket_size=self.allgather_bucket_size)
+
+    def clear_hp_grads(self):
+        for flat_gradients in self.fp32_groups_gradients_flat:
+            flat_gradients.zero_()
+
+        for i, group in enumerate(self.fp32_groups_gradients):
+            self.fp32_groups_has_gradients[i] = [False] * len(group)
+
+    def clear_lp_grads(self):
+
+        # using zero_() fixed memory address for graph replay
+        set_to_none = False if self.graph_harvesting else True
+        zero_grads_list = []
+        for group in self.bf16_groups:
+            for param in group:
+                if set_to_none:
+                    param.grad = None
+                elif param.grad is not None:
+                    if param.grad.grad_fn is not None:
+                        param.grad.detach_()
+                    zero_grads_list.append(param.grad)
+        if not set_to_none and len(zero_grads_list) > 0:
+            torch._foreach_zero_(zero_grads_list)
+
+    def state_dict(self):
+        state_dict = {}
+        state_dict[CLIP_GRAD] = self.clip_grad
+        state_dict[BASE_OPTIMIZER_STATE] = self.optimizer.state_dict()
+        state_dict[SINGLE_PARTITION_OF_FP32_GROUPS] = self.fp32_groups_flat_partition
+        state_dict[GROUP_PADDINGS] = self.group_paddings
+        state_dict[PARTITION_COUNT] = self.partition_count
+        state_dict[DS_VERSION] = version
+        state_dict[PARAM_SLICE_MAPPINGS] = self._param_slice_mappings
+
+        return state_dict
+
+    # Restore base optimizer fp32 weights bfloat16 weights
+    def _restore_from_bit16_weights(self):
+        for i, group in enumerate(self.bf16_groups):
+            partition_id = dist.get_rank(group=self.real_dp_process_group[i])
+            for bf16_partitions, fp32_partition in zip(self.bf16_partitioned_groups, self.fp32_groups_flat_partition):
+                fp32_partition.data.copy_(bf16_partitions[partition_id].data)
+
+    def refresh_fp32_params(self):
+        self._restore_from_bit16_weights()
+
+    def load_state_dict(self,
+                        state_dict_list,
+                        checkpoint_folder,
+                        load_optimizer_states=True,
+                        load_from_fp32_weights=False,
+                        load_serial=None):
+        if checkpoint_folder:
+            self._load_universal_checkpoint(checkpoint_folder, load_optimizer_states, load_from_fp32_weights)
+        else:
+            self._load_legacy_checkpoint(state_dict_list, load_optimizer_states, load_from_fp32_weights)
+
+    def _load_legacy_checkpoint(self, state_dict_list, load_optimizer_states=True, load_from_fp32_weights=False):
+
+        dp_rank = dist.get_rank(group=self.dp_process_group)
+        current_rank_sd = state_dict_list[dp_rank]
+
+        ckpt_version = current_rank_sd.get(DS_VERSION, False)
+        assert ckpt_version, f"Empty ds_version in checkpoint, not clear how to proceed"
+        ckpt_version = pkg_version.parse(ckpt_version)
+
+        self.clip_grad = current_rank_sd.get(CLIP_GRAD, self.clip_grad)
+
+        if load_optimizer_states:
+            print(f"_load_legacy_checkpoint current_rank_sd[BASE_OPTIMIZER_STATE]")
+            self.optimizer.load_state_dict(current_rank_sd[BASE_OPTIMIZER_STATE])
+
+        if load_from_fp32_weights:
+            for current, saved in zip(self.fp32_groups_flat_partition,
+                                      current_rank_sd[SINGLE_PARTITION_OF_FP32_GROUPS]):
+                src_tensor = _get_padded_tensor(saved, current.numel())
+                current.data.copy_(src_tensor.data)
+
+        if load_optimizer_states:
+            self._link_all_hp_params()
+
+    def _load_universal_checkpoint(self, checkpoint_folder, load_optimizer_states, load_from_fp32_weights):
+        self.load_hp_checkpoint_state_from_checkpoint_dir("bf16_groups", checkpoint_folder)
+
+    def _load_global_state(self, sd):
+        pass
+
+    @property
+    def param_groups(self):
+        """Forward the wrapped optimizer's parameters."""
+        return self.optimizer.param_groups
+
+    def accumulate_hp_grads_and_remove_lp(self, lp_param, group_idx, param_idx):
+        assert self.immediate_grad_update
+        self._update_hp_grad(lp_param, group_idx, param_idx, clear_lp_grads=True)
+
+    def create_grad_acc_hooks(self):
+        self.grad_accs = []
+        for i, param_group in enumerate(self.bf16_groups):
+            for j, param in enumerate(param_group):
+                if param.requires_grad:
+
+                    def wrapper(param, i, j):
+                        param_tmp = param.expand_as(param)
+                        grad_acc = param_tmp.grad_fn.next_functions[0][0]
+
+                        def accumulate_hp_grads_and_remove_lp(*notneeded):
+                            self.accumulate_hp_grads_and_remove_lp(param, i, j)
+
+                        grad_acc.register_hook(accumulate_hp_grads_and_remove_lp)
+                        self.grad_accs.append(grad_acc)
+
+                    wrapper(param, i, j)
+
+
+def _get_padded_tensor(src_tensor, size):
+    if src_tensor.numel() >= size:
+        return src_tensor
+    padded_tensor = torch.zeros(size, dtype=src_tensor.dtype, device=src_tensor.device)
+    slice_tensor = torch.narrow(padded_tensor, 0, 0, src_tensor.numel())
+    slice_tensor.data.copy_(src_tensor.data)
+    return padded_tensor

venv/lib/python3.10/site-packages/deepspeed/runtime/compiler.py

@@ -0,0 +1,166 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from typing import Union, Callable, Dict, Any
+import importlib
+import torch
+from ..pydantic_v1 import validator
+from .config_utils import DeepSpeedConfigModel
+
+COMPILE_CONFIG = "compile"
+
+
+def is_compile_supported():
+    return hasattr(torch, "compiler")
+
+
+def disable(func):
+    if is_compile_supported():
+        return torch.compiler.disable(func)
+    return func
+
+
+def get_compile_config(param_dict):
+    if COMPILE_CONFIG in param_dict:
+        compile_config_dict = param_dict[COMPILE_CONFIG]
+    else:
+        compile_config_dict = {}
+    return CompileConfig(**compile_config_dict)
+
+
+def get_backend_fn(backend: Union[str, Callable]) -> Union[str, Callable]:
+    if isinstance(backend, Callable):
+        return backend
+
+    elif isinstance(backend, str):
+        if backend in torch._dynamo.list_backends(exclude_tags=()):
+            return backend
+
+        # Get module name from backend name
+        module_name = '.'.join(backend.split('.')[:-1])
+        fn_name = backend.split('.')[-1]
+
+        try:
+            module = importlib.import_module(module_name)
+            backend_fn = getattr(module, fn_name)
+        except ImportError:
+            raise ValueError(
+                f"The backend {backend} is not in the list of available backends and could not be imported.")
+        return backend_fn
+
+    raise ValueError(f"backend for torch.compile must be a string or Callable: {backend}")
+
+
+class CompileConfig(DeepSpeedConfigModel):
+    """
+    [EXPERIMENTAL] This configuration enables users to activate `torch.compile` within DeepSpeed and customize its settings.
+    Please be aware that these features and API designs are experimental and subject to change.
+    """
+
+    enabled: bool = False
+    """
+    Enable torch.compile when True.
+    """
+
+    backend: str = "inductor"
+    """
+    Passed to `backend` argument of torch.compile.
+    If the given value is not in torch._dynamo.list_backends(),
+    DeepSpeed attempts to import and instantiate the module with the given name.
+    """
+
+    kwargs: Dict[str, Any] = {}
+    """
+    Passed to `kwargs` argument of torch.compile.
+    """
+
+    @validator("enabled")
+    def validate_enabled(cls, field_value, values):
+        if field_value and not is_compile_supported():
+            raise ValueError("torch.compile is not supported on this version of PyTorch.")
+        return field_value
+
+
+class CompiledModuleWrapper(torch.nn.Module):
+
+    def __init__(self, module, compile_config: Union[CompileConfig, None] = None):
+        super().__init__()
+
+        assert is_compile_supported(), "torch.compile is not supported on this version of PyTorch."
+
+        modules = self.__dict__.get('_modules')
+        modules['wrapped'] = module
+        self.__dict__['wrapped'] = module
+        self._is_compiled = False
+        self._backend = get_backend_fn(compile_config.backend)
+        self._compile_kwargs = compile_config.kwargs
+        self._compiler_fn = None
+
+    def __getattr__(self, name):
+        return getattr(self.__dict__['wrapped'], name)
+
+    def set_backend(self, backend: Union[str, Callable]):
+        """Set the backend for torch.compile.
+
+        Args:
+            backend (Union[str, Callable]): backend name or a function that takes a torch.nn.Module and returns a compiled module.
+            You can directly pass a function that works as a backend.
+            See also `backend` field in `CompileConfig` for more details.
+        """
+        self._backend = get_backend_fn(backend)
+
+    def set_torch_compile_kwargs(self, kwargs: Dict[str, Union[str, Any]]) -> None:
+        """Set kwargs for torch.compile. Kwargs that are set in DeepSpeed config will be overwritten.
+        You can also pass a backend name with "backend" key to change the backend.
+
+        Args:
+            kwargs (Dict[str, Union[str, Any]]): kwargs passed to torch.compile.
+        """
+
+        if "backend" in kwargs:
+            raise ValueError("backend cannot be set as compile kwargs. Use set_backend instead.")
+        self._compile_kwargs.update(kwargs)
+
+    def set_compiler_fn(self, compiler_fn: Callable) -> None:
+        """Set a function to be used for compiling the module.
+        This function should take a torch.nn.Module as input and return a compiled module.
+        Note that other compile options are ignored when a compiler_fn is set.
+
+        Example:
+        ```python
+            def my_compiler_fn(module: torch.nn.Module):
+                ...
+                return torch.compile(module, ...)
+
+            engine.set_compiler_fn(my_compiler_fn)
+        ```
+        """
+        self._compiler_fn = compiler_fn
+
+    def forward(self, *args, **kwargs) -> Any:
+        if not self.is_compiled:
+            if self._compiler_fn is None:
+                self.__dict__['wrapped'] = torch.compile(self.wrapped, backend=self._backend, **self._compile_kwargs)
+            else:
+                self.__dict__['wrapped'] = self._compiler_fn(self.wrapped)
+            self._is_compiled = True
+
+        return self.__dict__['wrapped'](*args, **kwargs)
+
+    @property
+    def is_compiled(self) -> bool:
+        return self._is_compiled
+
+    @property
+    def backend(self) -> Union[str, Callable]:
+        return self._backend
+
+    @property
+    def torch_compile_kwargs(self) -> Dict[str, Any]:
+        return self._compile_kwargs
+
+    @property
+    def compiler_fn(self) -> Union[Callable, None]:
+        return self._compiler_fn

venv/lib/python3.10/site-packages/deepspeed/runtime/config.py

@@ -0,0 +1,1039 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import os
+from typing import Union
+from enum import Enum
+
+import torch
+import json
+import hjson
+import copy
+import base64
+
+from .constants import *
+from .fp16.loss_scaler import (
+    INITIAL_LOSS_SCALE,
+    SCALE_WINDOW,
+    DELAYED_SHIFT,
+    CONSECUTIVE_HYSTERESIS,
+    MIN_LOSS_SCALE,
+)
+from .config_utils import (
+    get_scalar_param,
+    dict_raise_error_on_duplicate_keys,
+    ScientificNotationEncoder,
+)
+from .zero.config import get_zero_config, ZeroStageEnum
+from .activation_checkpointing.config import DeepSpeedActivationCheckpointingConfig
+from ..comm.config import DeepSpeedCommsConfig
+from ..monitor.config import get_monitor_config
+from ..inference.config import WeightQuantConfig
+from .compiler import get_compile_config
+
+from deepspeed import comm as dist
+from deepspeed.runtime.config_utils import DeepSpeedConfigModel
+
+from ..git_version_info import version as __version__
+from ..utils import logger
+
+from ..elasticity import (
+    elasticity_enabled,
+    compute_elastic_config,
+    ensure_immutable_elastic_config,
+)
+from ..elasticity.config import ElasticityConfigError
+from ..elasticity.constants import (
+    ELASTICITY,
+    IGNORE_NON_ELASTIC_BATCH_INFO,
+    IGNORE_NON_ELASTIC_BATCH_INFO_DEFAULT,
+    MODEL_PARALLEL_SIZE,
+    MODEL_PARALLEL_SIZE_DEFAULT,
+    NUM_GPUS_PER_NODE,
+    NUM_GPUS_PER_NODE_DEFAULT,
+)
+
+from ..profiling.config import DeepSpeedFlopsProfilerConfig
+from ..autotuning.config import DeepSpeedAutotuningConfig
+from ..nebula.config import DeepSpeedNebulaConfig
+
+from ..compression.config import get_compression_config, get_quantize_enabled
+from ..compression.constants import *
+from .swap_tensor.aio_config import get_aio_config
+
+from .data_pipeline.config import get_data_efficiency_enabled, get_data_efficiency_config, get_curriculum_enabled_legacy, get_curriculum_params_legacy
+from .data_pipeline.constants import *
+
+TENSOR_CORE_ALIGN_SIZE = 8
+
+ADAGRAD_OPTIMIZER = 'adagrad'
+ADAM_OPTIMIZER = 'adam'
+ADAMW_OPTIMIZER = 'adamw'
+LAMB_OPTIMIZER = 'lamb'
+ONEBIT_ADAM_OPTIMIZER = 'onebitadam'
+ZERO_ONE_ADAM_OPTIMIZER = 'zerooneadam'
+ONEBIT_LAMB_OPTIMIZER = 'onebitlamb'
+MUADAM_OPTIMIZER = 'muadam'
+MUADAMW_OPTIMIZER = 'muadamw'
+MUSGD_OPTIMIZER = 'musgd'
+LION_OPTIMIZER = 'lion'
+DEEPSPEED_OPTIMIZERS = [
+    ADAGRAD_OPTIMIZER, ADAM_OPTIMIZER, ADAMW_OPTIMIZER, LAMB_OPTIMIZER, ONEBIT_ADAM_OPTIMIZER, ONEBIT_LAMB_OPTIMIZER,
+    ZERO_ONE_ADAM_OPTIMIZER, MUADAM_OPTIMIZER, MUADAMW_OPTIMIZER, MUSGD_OPTIMIZER, LION_OPTIMIZER
+]
+
+# extra optimizer parameters for adam/adamw
+TORCH_ADAM_PARAM = "torch_adam"
+
+# default to adamw logic for adam/adamw optimizers unless user explicitly opts out
+ADAM_W_MODE = "adam_w_mode"
+ADAM_W_MODE_DEFAULT = True
+
+
+class DeepSpeedConfigError(Exception):
+    pass
+
+
+class DtypeEnum(Enum):
+    # The torch dtype must always be the first value (so we return torch.dtype)
+    fp16 = torch.float16, "torch.float16", "fp16", "float16", "half"
+    fp32 = torch.float32, "torch.float32", "fp32", "float32", "float"
+    int8 = torch.int8, "torch.int8", "int8"
+    bf16 = torch.bfloat16, "torch.bfloat16", "bf16", "bfloat16"
+
+    # Copied from https://stackoverflow.com/a/43210118
+    # Allows us to use multiple values for each Enum index and returns first
+    # listed value when Enum is called
+    def __new__(cls, *values):
+        obj = object.__new__(cls)
+        # first value is canonical value
+        obj._value_ = values[0]
+        for other_value in values[1:]:
+            cls._value2member_map_[other_value] = obj
+        obj._all_values = values
+        return obj
+
+    def __repr__(self):
+        return "<%s.%s: %s>" % (
+            self.__class__.__name__,
+            self._name_,
+            ", ".join([repr(v) for v in self._all_values]),
+        )
+
+
+def get_pld_enabled(param_dict):
+    if PROGRESSIVE_LAYER_DROP in param_dict.keys():
+        return get_scalar_param(param_dict[PROGRESSIVE_LAYER_DROP], PLD_ENABLED, PLD_ENABLED_DEFAULT)
+    else:
+        return False
+
+
+def get_pld_params(param_dict):
+    if PROGRESSIVE_LAYER_DROP in param_dict.keys():
+        pld_params = copy.copy(param_dict[PROGRESSIVE_LAYER_DROP])
+        pld_params.pop(PLD_ENABLED)
+        return pld_params
+    else:
+        return False
+
+
+def get_amp_enabled(param_dict):
+    if AMP in param_dict.keys():
+        return get_scalar_param(param_dict[AMP], AMP_ENABLED, AMP_ENABLED_DEFAULT)
+    else:
+        return False
+
+
+def get_amp_params(param_dict):
+    if AMP in param_dict.keys():
+        amp_params = copy.copy(param_dict[AMP])
+        amp_params.pop(AMP_ENABLED)
+        return amp_params
+    else:
+        return False
+
+
+def get_fp16_enabled(param_dict):
+    if FP16 in param_dict.keys():
+        return get_scalar_param(param_dict[FP16], FP16_ENABLED, FP16_ENABLED_DEFAULT)
+    else:
+        return False
+
+
+def get_bfloat16_enabled(param_dict):
+    for key in [BFLOAT16, BFLOAT16_OLD]:
+        if key in param_dict.keys():
+            return get_scalar_param(param_dict[key], BFLOAT16_ENABLED, BFLOAT16_ENABLED_DEFAULT)
+    return False
+
+
+def get_bfloat16_immediate_grad_update(param_dict):
+    for key in [BFLOAT16, BFLOAT16_OLD]:
+        if key in param_dict.keys():
+            return get_scalar_param(param_dict[key], BFLOAT16_IMMEDIATE_GRAD_UPDATE,
+                                    BFLOAT16_IMMEDIATE_GRAD_UPDATE_DEFAULT)
+    return False
+
+
+def get_fp16_master_weights_and_grads_enabled(param_dict):
+    if get_fp16_enabled(param_dict):
+        return get_scalar_param(param_dict[FP16], FP16_MASTER_WEIGHTS_AND_GRADS, FP16_MASTER_WEIGHTS_AND_GRADS_DEFAULT)
+    else:
+        return False
+
+
+def get_fp16_auto_cast(param_dict):
+    if get_fp16_enabled(param_dict):
+        return get_scalar_param(param_dict[FP16], FP16_AUTO_CAST, FP16_AUTO_CAST_DEFAULT)
+
+
+def get_loss_scale(param_dict):
+    if get_fp16_enabled(param_dict):
+        return get_scalar_param(param_dict[FP16], FP16_LOSS_SCALE, FP16_LOSS_SCALE_DEFAULT)
+    elif get_bfloat16_enabled(param_dict):
+        return 1.0
+    else:
+        return FP16_LOSS_SCALE_DEFAULT
+
+
+def get_initial_dynamic_scale(param_dict):
+    if get_fp16_enabled(param_dict):
+        initial_scale_power = get_scalar_param(param_dict[FP16], FP16_INITIAL_SCALE_POWER,
+                                               FP16_INITIAL_SCALE_POWER_DEFAULT)
+    elif get_bfloat16_enabled(param_dict):
+        initial_scale_power = 0
+    else:
+        initial_scale_power = FP16_INITIAL_SCALE_POWER_DEFAULT
+
+    return 2**initial_scale_power
+
+
+def get_dynamic_loss_scale_args(param_dict):
+    loss_scale_args = None
+    if get_fp16_enabled(param_dict):
+        fp16_dict = param_dict[FP16]
+        dynamic_loss_args = [
+            FP16_INITIAL_SCALE_POWER,
+            FP16_LOSS_SCALE_WINDOW,
+            FP16_MIN_LOSS_SCALE,
+            FP16_HYSTERESIS,
+            FP16_CONSECUTIVE_HYSTERESIS,
+        ]
+        if any(arg in list(fp16_dict.keys()) for arg in dynamic_loss_args):
+            init_scale = get_scalar_param(fp16_dict, FP16_INITIAL_SCALE_POWER, FP16_INITIAL_SCALE_POWER_DEFAULT)
+            scale_window = get_scalar_param(fp16_dict, FP16_LOSS_SCALE_WINDOW, FP16_LOSS_SCALE_WINDOW_DEFAULT)
+            delayed_shift = get_scalar_param(fp16_dict, FP16_HYSTERESIS, FP16_HYSTERESIS_DEFAULT)
+            consecutive_hysteresis = get_scalar_param(fp16_dict, FP16_CONSECUTIVE_HYSTERESIS,
+                                                      FP16_CONSECUTIVE_HYSTERESIS_DEFAULT)
+            min_loss_scale = get_scalar_param(fp16_dict, FP16_MIN_LOSS_SCALE, FP16_MIN_LOSS_SCALE_DEFAULT)
+            loss_scale_args = {
+                INITIAL_LOSS_SCALE: 2**init_scale,
+                SCALE_WINDOW: scale_window,
+                DELAYED_SHIFT: delayed_shift,
+                CONSECUTIVE_HYSTERESIS: consecutive_hysteresis,
+                MIN_LOSS_SCALE: min_loss_scale,
+            }
+
+    return loss_scale_args
+
+
+def get_gradient_accumulation_steps(param_dict):
+    return get_scalar_param(param_dict, GRADIENT_ACCUMULATION_STEPS, GRADIENT_ACCUMULATION_STEPS_DEFAULT)
+
+
+def get_sparse_gradients_enabled(param_dict):
+    return get_scalar_param(param_dict, SPARSE_GRADIENTS, SPARSE_GRADIENTS_DEFAULT)
+
+
+def get_communication_data_type(param_dict,
+                                comm_type=COMMUNICATION_DATA_TYPE,
+                                comm_data_type_default=COMMUNICATION_DATA_TYPE_DEFAULT):
+    val = get_scalar_param(param_dict, comm_type, comm_data_type_default)
+    val = val.lower() if val is not None else val
+    if val is None:
+        return val  # we must determine it by other parameters
+    elif val == "fp32":
+        return torch.float32
+    elif val == "fp16":
+        return torch.float16
+    elif val == "bf16":
+        return torch.bfloat16
+
+    raise ValueError(f"Invalid communication_data_type. Supported data types: ['fp16', 'bf16', 'fp32']. Got: {val}")
+
+
+def get_prescale_gradients(param_dict):
+    return get_scalar_param(param_dict, PRESCALE_GRADIENTS, PRESCALE_GRADIENTS_DEFAULT)
+
+
+def get_gradient_predivide_factor(param_dict):
+    return get_scalar_param(param_dict, GRADIENT_PREDIVIDE_FACTOR, GRADIENT_PREDIVIDE_FACTOR_DEFAULT)
+
+
+def get_steps_per_print(param_dict):
+    return get_scalar_param(param_dict, STEPS_PER_PRINT, STEPS_PER_PRINT_DEFAULT)
+
+
+def get_disable_allgather(param_dict):
+    return get_scalar_param(param_dict, DISABLE_ALLGATHER, DISABLE_ALLGATHER_DEFAULT)
+
+
+def get_dump_state(param_dict):
+    return get_scalar_param(param_dict, DUMP_STATE, DUMP_STATE_DEFAULT)
+
+
+def get_gradient_clipping(param_dict):
+    return get_scalar_param(param_dict, GRADIENT_CLIPPING, GRADIENT_CLIPPING_DEFAULT)
+
+
+def get_graph_harvesting(param_dict):
+    return get_scalar_param(param_dict, GRAPH_HARVESTING, GRAPH_HARVESTING_DEFAULT)
+
+
+def get_sparse_attention(param_dict):
+    if SPARSE_ATTENTION in param_dict.keys():
+        sparsity = param_dict[SPARSE_ATTENTION]
+        mode = get_sparse_attention_mode(sparsity)
+
+        if mode == SPARSE_DENSE_MODE:
+            return get_sparse_dense_config(sparsity)
+        elif mode == SPARSE_FIXED_MODE:
+            return get_sparse_fixed_config(sparsity)
+        elif mode == SPARSE_VARIABLE_MODE:
+            return get_sparse_variable_config(sparsity)
+        elif mode == SPARSE_BIGBIRD_MODE:
+            return get_sparse_bigbird_config(sparsity)
+        elif mode == SPARSE_BSLONGFORMER_MODE:
+            return get_sparse_bslongformer_config(sparsity)
+        else:
+            raise NotImplementedError(f"Given sparsity mode, {mode}, has not been implemented yet!")
+
+    else:
+        return None
+
+
+def get_sparse_dense_config(sparsity):
+    block = get_scalar_param(sparsity, SPARSE_BLOCK, SPARSE_BLOCK_DEFAULT)
+    return {SPARSE_MODE: SPARSE_DENSE_MODE, SPARSE_BLOCK: block}
+
+
+def get_sparse_fixed_config(sparsity):
+    block = get_scalar_param(sparsity, SPARSE_BLOCK, SPARSE_BLOCK_DEFAULT)
+    different_layout_per_head = get_scalar_param(
+        sparsity,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD_DEFAULT,
+    )
+    num_local_blocks = get_scalar_param(sparsity, SPARSE_NUM_LOCAL_BLOCKS, SPARSE_NUM_LOCAL_BLOCKS_DEFAULT)
+    num_global_blocks = get_scalar_param(sparsity, SPARSE_NUM_GLOBAL_BLOCKS, SPARSE_NUM_GLOBAL_BLOCKS_DEFAULT)
+    attention = get_scalar_param(sparsity, SPARSE_ATTENTION_TYPE, SPARSE_ATTENTION_TYPE_DEFAULT)
+    horizontal_global_attention = get_scalar_param(
+        sparsity,
+        SPARSE_HORIZONTAL_GLOBAL_ATTENTION,
+        SPARSE_HORIZONTAL_GLOBAL_ATTENTION_DEFAULT,
+    )
+    num_different_global_patterns = get_scalar_param(
+        sparsity,
+        SPARSE_NUM_DIFFERENT_GLOBAL_PATTERNS,
+        SPARSE_NUM_DIFFERENT_GLOBAL_PATTERNS_DEFAULT,
+    )
+
+    return {
+        SPARSE_MODE: SPARSE_FIXED_MODE,
+        SPARSE_BLOCK: block,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD: different_layout_per_head,
+        SPARSE_NUM_LOCAL_BLOCKS: num_local_blocks,
+        SPARSE_NUM_GLOBAL_BLOCKS: num_global_blocks,
+        SPARSE_ATTENTION_TYPE: attention,
+        SPARSE_HORIZONTAL_GLOBAL_ATTENTION: horizontal_global_attention,
+        SPARSE_NUM_DIFFERENT_GLOBAL_PATTERNS: num_different_global_patterns,
+    }
+
+
+def get_sparse_variable_config(sparsity):
+    block = get_scalar_param(sparsity, SPARSE_BLOCK, SPARSE_BLOCK_DEFAULT)
+    different_layout_per_head = get_scalar_param(
+        sparsity,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD_DEFAULT,
+    )
+    num_random_blocks = get_scalar_param(sparsity, SPARSE_NUM_RANDOM_BLOCKS, SPARSE_NUM_RANDOM_BLOCKS_DEFAULT)
+    local_window_blocks = get_scalar_param(sparsity, SPARSE_LOCAL_WINDOW_BLOCKS, SPARSE_LOCAL_WINDOW_BLOCKS_DEFAULT)
+    global_block_indices = get_scalar_param(sparsity, SPARSE_GLOBAL_BLOCK_INDICES, SPARSE_GLOBAL_BLOCK_INDICES_DEFAULT)
+    global_block_end_indices = get_scalar_param(
+        sparsity,
+        SPARSE_GLOBAL_BLOCK_END_INDICES,
+        SPARSE_GLOBAL_BLOCK_END_INDICES_DEFAULT,
+    )
+    attention = get_scalar_param(sparsity, SPARSE_ATTENTION_TYPE, SPARSE_ATTENTION_TYPE_DEFAULT)
+    horizontal_global_attention = get_scalar_param(
+        sparsity,
+        SPARSE_HORIZONTAL_GLOBAL_ATTENTION,
+        SPARSE_HORIZONTAL_GLOBAL_ATTENTION_DEFAULT,
+    )
+
+    return {
+        SPARSE_MODE: SPARSE_VARIABLE_MODE,
+        SPARSE_BLOCK: block,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD: different_layout_per_head,
+        SPARSE_NUM_RANDOM_BLOCKS: num_random_blocks,
+        SPARSE_LOCAL_WINDOW_BLOCKS: local_window_blocks,
+        SPARSE_GLOBAL_BLOCK_INDICES: global_block_indices,
+        SPARSE_GLOBAL_BLOCK_END_INDICES: global_block_end_indices,
+        SPARSE_ATTENTION_TYPE: attention,
+        SPARSE_HORIZONTAL_GLOBAL_ATTENTION: horizontal_global_attention,
+    }
+
+
+def get_sparse_bigbird_config(sparsity):
+    block = get_scalar_param(sparsity, SPARSE_BLOCK, SPARSE_BLOCK_DEFAULT)
+    different_layout_per_head = get_scalar_param(
+        sparsity,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD_DEFAULT,
+    )
+    num_random_blocks = get_scalar_param(sparsity, SPARSE_NUM_RANDOM_BLOCKS, SPARSE_NUM_RANDOM_BLOCKS_DEFAULT)
+    num_sliding_window_blocks = get_scalar_param(
+        sparsity,
+        SPARSE_NUM_SLIDING_WINDOW_BLOCKS,
+        SPARSE_NUM_SLIDING_WINDOW_BLOCKS_DEFAULT,
+    )
+    num_global_blocks = get_scalar_param(sparsity, SPARSE_NUM_GLOBAL_BLOCKS, SPARSE_NUM_GLOBAL_BLOCKS_DEFAULT)
+
+    return {
+        SPARSE_MODE: SPARSE_BIGBIRD_MODE,
+        SPARSE_BLOCK: block,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD: different_layout_per_head,
+        SPARSE_NUM_RANDOM_BLOCKS: num_random_blocks,
+        SPARSE_NUM_SLIDING_WINDOW_BLOCKS: num_sliding_window_blocks,
+        SPARSE_NUM_GLOBAL_BLOCKS: num_global_blocks,
+    }
+
+
+def get_sparse_bslongformer_config(sparsity):
+    block = get_scalar_param(sparsity, SPARSE_BLOCK, SPARSE_BLOCK_DEFAULT)
+    different_layout_per_head = get_scalar_param(
+        sparsity,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD_DEFAULT,
+    )
+    num_sliding_window_blocks = get_scalar_param(
+        sparsity,
+        SPARSE_NUM_SLIDING_WINDOW_BLOCKS,
+        SPARSE_NUM_SLIDING_WINDOW_BLOCKS_DEFAULT,
+    )
+    global_block_indices = get_scalar_param(sparsity, SPARSE_GLOBAL_BLOCK_INDICES, SPARSE_GLOBAL_BLOCK_INDICES_DEFAULT)
+    global_block_end_indices = get_scalar_param(
+        sparsity,
+        SPARSE_GLOBAL_BLOCK_END_INDICES,
+        SPARSE_GLOBAL_BLOCK_END_INDICES_DEFAULT,
+    )
+
+    return {
+        SPARSE_MODE: SPARSE_BSLONGFORMER_MODE,
+        SPARSE_BLOCK: block,
+        SPARSE_DIFFERENT_LAYOUT_PER_HEAD: different_layout_per_head,
+        SPARSE_NUM_SLIDING_WINDOW_BLOCKS: num_sliding_window_blocks,
+        SPARSE_GLOBAL_BLOCK_INDICES: global_block_indices,
+        SPARSE_GLOBAL_BLOCK_END_INDICES: global_block_end_indices,
+    }
+
+
+def get_sparse_attention_mode(param_dict):
+    if SPARSE_MODE in param_dict.keys():
+        return param_dict[SPARSE_MODE]
+    else:
+        return SPARSE_MODE_DEFAULT
+
+
+def get_sparse_attention_type(param_dict):
+    if SPARSE_ATTENTION_TYPE in param_dict.keys():
+        return param_dict[SPARSE_ATTENTION_TYPE]
+    else:
+        return SPARSE_ATTENTION_TYPE_DEFAULT
+
+
+def get_pipeline_config(param_dict):
+    """Parses pipeline engine configuration. """
+    default_pipeline = {
+        "stages": "auto",
+        "partition": "best",
+        "seed_layers": False,
+        "activation_checkpoint_interval": 0,
+        "pipe_partitioned": True,
+        "grad_partitioned": True,
+    }
+    config = default_pipeline
+    for key, val in param_dict.get("pipeline", {}).items():
+        config[key] = val
+    return config
+
+
+def get_optimizer_name(param_dict):
+    if OPTIMIZER in param_dict.keys() and TYPE in param_dict[OPTIMIZER].keys():
+        return param_dict[OPTIMIZER][TYPE]
+    else:
+        return OPTIMIZER_TYPE_DEFAULT
+
+
+def get_optimizer_params(param_dict):
+    if (get_optimizer_name(param_dict) is not None and OPTIMIZER_PARAMS in param_dict[OPTIMIZER].keys()):
+        return param_dict[OPTIMIZER][OPTIMIZER_PARAMS]
+    else:
+        return None
+
+
+def get_optimizer_gradient_clipping(param_dict):
+    optimizer_params = get_optimizer_params(param_dict)
+    if optimizer_params is not None and MAX_GRAD_NORM in optimizer_params.keys():
+        return optimizer_params[MAX_GRAD_NORM]
+    else:
+        return None
+
+
+def get_optimizer_legacy_fusion(param_dict):
+    if OPTIMIZER in param_dict.keys() and LEGACY_FUSION in param_dict[OPTIMIZER].keys():
+        return param_dict[OPTIMIZER][LEGACY_FUSION]
+    else:
+        return LEGACY_FUSION_DEFAULT
+
+
+def get_zero_allow_untested_optimizer(param_dict):
+    return get_scalar_param(param_dict, ZERO_ALLOW_UNTESTED_OPTIMIZER, ZERO_ALLOW_UNTESTED_OPTIMIZER_DEFAULT)
+
+
+def get_zero_force_ds_cpu_optimizer(param_dict):
+    return get_scalar_param(param_dict, ZERO_FORCE_DS_CPU_OPTIMIZER, ZERO_FORCE_DS_CPU_OPTIMIZER_DEFAULT)
+
+
+def get_scheduler_name(param_dict):
+    if SCHEDULER in param_dict.keys() and TYPE in param_dict[SCHEDULER].keys():
+        return param_dict[SCHEDULER][TYPE]
+    else:
+        return SCHEDULER_TYPE_DEFAULT
+
+
+def get_scheduler_params(param_dict):
+    if (get_scheduler_name(param_dict) is not None and SCHEDULER_PARAMS in param_dict[SCHEDULER].keys()):
+        return param_dict[SCHEDULER][SCHEDULER_PARAMS]
+    else:
+        return None
+
+
+def get_train_batch_size(param_dict):
+    return get_scalar_param(param_dict, TRAIN_BATCH_SIZE, TRAIN_BATCH_SIZE_DEFAULT)
+
+
+def get_train_micro_batch_size_per_gpu(param_dict):
+    return get_scalar_param(
+        param_dict,
+        TRAIN_MICRO_BATCH_SIZE_PER_GPU,
+        TRAIN_MICRO_BATCH_SIZE_PER_GPU_DEFAULT,
+    )
+
+
+def get_wall_clock_breakdown(param_dict):
+    return get_scalar_param(param_dict, WALL_CLOCK_BREAKDOWN, WALL_CLOCK_BREAKDOWN_DEFAULT)
+
+
+def get_memory_breakdown(param_dict):
+    return get_scalar_param(param_dict, MEMORY_BREAKDOWN, MEMORY_BREAKDOWN_DEFAULT)
+
+
+class HybridEngineConfig(DeepSpeedConfigModel):
+    enabled: bool = False
+    max_out_tokens: int = 512
+    inference_tp_size: int = 1
+    release_inference_cache: bool = False
+    pin_parameters: bool = True
+    tp_gather_partition_size: int = 8
+
+
+def get_hybrid_engine_config(param_dict):
+    hybrid_engine_config_dict = param_dict.get("hybrid_engine", {})
+    hybrid_engine_config = HybridEngineConfig(**hybrid_engine_config_dict)
+    return hybrid_engine_config
+
+
+def get_expert_data_topo_config(param_dict):
+    return get_scalar_param(param_dict, USE_DATA_BEFORE_EXPERT_PARALLEL, USE_DATA_BEFORE_EXPERT_PARALLEL_DEFAULT)
+
+
+def get_eigenvalue_config(param_dict):
+    if get_quantize_enabled(param_dict):
+        param_dict = param_dict[QUANTIZE_TRAINING]
+        assert not get_eigenvalue_enabled(param_dict), "Eigenvalue based MoQ is temporarily disabled"
+        return (
+            get_eigenvalue_enabled(param_dict),
+            get_eigenvalue_verbose(param_dict),
+            get_eigenvalue_max_iter(param_dict),
+            get_eigenvalue_tol(param_dict),
+            get_eigenvalue_stability(param_dict),
+            get_eigenvalue_gas_boundary_resolution(param_dict),
+            get_eigenvalue_layer_name(param_dict),
+            get_eigenvalue_layer_num(param_dict),
+        )
+    else:
+        return (
+            EIGENVALUE_ENABLED_DEFAULT,
+            EIGENVALUE_VERBOSE_DEFAULT,
+            EIGENVALUE_MAX_ITER_DEFAULT,
+            EIGENVALUE_TOL_DEFAULT,
+            EIGENVALUE_STABILITY_DEFAULT,
+            EIGENVALUE_GAS_BOUNDARY_RESOLUTION_DEFAULT,
+            EIGENVALUE_LAYER_NAME_DEFAULT,
+            EIGENVALUE_LAYER_NUM_DEFAULT,
+        )
+
+
+def get_eigenvalue_enabled(param_dict):
+    if EIGENVALUE in param_dict.keys():
+        return get_scalar_param(param_dict[EIGENVALUE], EIGENVALUE_ENABLED, EIGENVALUE_ENABLED_DEFAULT)
+    else:
+        return EIGENVALUE_ENABLED_DEFAULT
+
+
+def get_eigenvalue_verbose(param_dict):
+    if EIGENVALUE in param_dict.keys():
+        return get_scalar_param(param_dict[EIGENVALUE], EIGENVALUE_VERBOSE, EIGENVALUE_VERBOSE_DEFAULT)
+    else:
+        return EIGENVALUE_VERBOSE_DEFAULT
+
+
+def get_eigenvalue_max_iter(param_dict):
+    if EIGENVALUE in param_dict.keys():
+        return get_scalar_param(param_dict[EIGENVALUE], EIGENVALUE_MAX_ITER, EIGENVALUE_MAX_ITER_DEFAULT)
+    else:
+        return EIGENVALUE_MAX_ITER_DEFAULT
+
+
+def get_eigenvalue_tol(param_dict):
+    if EIGENVALUE in param_dict.keys():
+        return get_scalar_param(param_dict[EIGENVALUE], EIGENVALUE_TOL, EIGENVALUE_TOL_DEFAULT)
+    else:
+        return EIGENVALUE_TOL_DEFAULT
+
+
+def get_eigenvalue_stability(param_dict):
+    if EIGENVALUE in param_dict.keys():
+        return get_scalar_param(param_dict[EIGENVALUE], EIGENVALUE_STABILITY, EIGENVALUE_STABILITY_DEFAULT)
+    else:
+        return EIGENVALUE_STABILITY_DEFAULT
+
+
+def get_eigenvalue_gas_boundary_resolution(param_dict):
+    if EIGENVALUE in param_dict.keys():
+        return get_scalar_param(
+            param_dict[EIGENVALUE],
+            EIGENVALUE_GAS_BOUNDARY_RESOLUTION,
+            EIGENVALUE_GAS_BOUNDARY_RESOLUTION_DEFAULT,
+        )
+    else:
+        return EIGENVALUE_GAS_BOUNDARY_RESOLUTION_DEFAULT
+
+
+def get_eigenvalue_layer_name(param_dict):
+    if EIGENVALUE in param_dict.keys():
+        return get_scalar_param(param_dict[EIGENVALUE], EIGENVALUE_LAYER_NAME, EIGENVALUE_LAYER_NAME_DEFAULT)
+    else:
+        return EIGENVALUE_LAYER_NAME_DEFAULT
+
+
+def get_eigenvalue_layer_num(param_dict):
+    if EIGENVALUE in param_dict.keys():
+        return get_scalar_param(param_dict[EIGENVALUE], EIGENVALUE_LAYER_NUM, EIGENVALUE_LAYER_NUM_DEFAULT)
+    else:
+        return EIGENVALUE_LAYER_NUM_DEFAULT
+
+
+def get_checkpoint_params(param_dict):
+    return param_dict.get(CHECKPOINT, {})
+
+
+def get_data_types_params(param_dict):
+    return param_dict.get(DATA_TYPES, {})
+
+
+def get_checkpoint_tag_validation_mode(checkpoint_params):
+    tag_validation_mode = checkpoint_params.get(CHECKPOINT_TAG_VALIDATION, CHECKPOINT_TAG_VALIDATION_DEFAULT)
+    tag_validation_mode = tag_validation_mode.upper()
+    if tag_validation_mode in CHECKPOINT_TAG_VALIDATION_MODES:
+        return tag_validation_mode
+    else:
+        raise DeepSpeedConfigError(
+            "Checkpoint config contains invalid tag_validation "
+            f"value of {tag_validation_mode}, expecting one of {CHECKPOINT_TAG_VALIDATION_MODES}")
+
+
+def get_checkpoint_parallel_write_pipeline(checkpoint_params):
+    par_write_params = checkpoint_params.get(CHECKPOINT_PARALLEL_WRITE, {})
+    par_write_pipeline = par_write_params.get(CHECKPOINT_PARALLEL_WRITE_PIPELINE_STAGE,
+                                              CHECKPOINT_PARALLEL_WRITE_PIPELINE_STAGE_DEFAULT)
+    if par_write_pipeline in [True, False]:
+        return par_write_pipeline
+    else:
+        raise DeepSpeedConfigError("checkpoint::parallel_write::pipeline_stage "
+                                   f"value of '{par_write_pipeline}' is invalid, expecting: true or false")
+
+
+def get_dataloader_drop_last(param_dict):
+    return get_scalar_param(param_dict, DATALOADER_DROP_LAST, DATALOADER_DROP_LAST_DEFAULT)
+
+
+'''Write deepspeed config files by modifying basic templates.
+Can be used for quickly changing parameters via command line parameters.'''
+
+
+class DeepSpeedConfigWriter:
+
+    def __init__(self, data=None):
+        self.data = data if data is not None else {}
+
+    def add_config(self, key, value):
+        self.data[key] = value
+
+    def load_config(self, filename):
+        self.data = json.load(open(filename, "r"), object_pairs_hook=dict_raise_error_on_duplicate_keys)
+
+    def write_config(self, filename):
+        with open(filename, "w") as outfile:
+            json.dump(self.data, outfile)
+
+
+class DeepSpeedConfig(object):
+
+    def __init__(self, config: Union[str, dict], mpu=None):
+        super(DeepSpeedConfig, self).__init__()
+        if isinstance(config, dict):
+            self._param_dict = config
+        elif os.path.exists(config):
+            self._param_dict = hjson.load(open(config, "r"), object_pairs_hook=dict_raise_error_on_duplicate_keys)
+        else:
+            try:
+                config_decoded = base64.urlsafe_b64decode(config).decode('utf-8')
+                self._param_dict = hjson.loads(config_decoded)
+            except (UnicodeDecodeError, AttributeError):
+                raise ValueError(
+                    f"Expected a string path to an existing deepspeed config, or a dictionary or a valid base64. Received: {config}"
+                )
+        try:
+            self.global_rank = dist.get_rank()
+            if mpu is None:
+                self.world_size = dist.get_world_size()
+            else:
+                self.world_size = mpu.get_data_parallel_world_size()
+        except:
+            self.global_rank = 0
+            self.world_size = 1
+
+        # If elastic-mode enabled, update compute + update _param_dict
+        self.elasticity_enabled = elasticity_enabled(self._param_dict)
+        if self.elasticity_enabled:
+            logger.info("DeepSpeed elasticity support enabled")
+            final_batch_size, valid_gpus, micro_batch_size = compute_elastic_config(
+                ds_config=self._param_dict,
+                target_deepspeed_version=__version__,
+                world_size=self.world_size,
+            )
+
+            elastic_dict = self._param_dict[ELASTICITY]
+
+            # Ensure the resource scheduler saw the same elastic config we are using at runtime
+            ensure_immutable_elastic_config(runtime_elastic_config_dict=elastic_dict)
+
+            self.elastic_model_parallel_size = elastic_dict.get(MODEL_PARALLEL_SIZE, MODEL_PARALLEL_SIZE_DEFAULT)
+            if self.elastic_model_parallel_size < 1:
+                raise ElasticityConfigError("Model-Parallel size cannot be less than 1, "
+                                            f"given model-parallel size: {self.elastic_model_parallel_size}")
+
+            self.num_gpus_per_node = elastic_dict.get(NUM_GPUS_PER_NODE, NUM_GPUS_PER_NODE_DEFAULT)
+            if self.num_gpus_per_node < 1:
+                raise ElasticityConfigError("NUmber of GPUs per node cannot be less than 1, "
+                                            f"given number of GPUs per node: {self.num_gpus_per_node}")
+
+            ignore_non_elastic_batch_info = elastic_dict.get(IGNORE_NON_ELASTIC_BATCH_INFO,
+                                                             IGNORE_NON_ELASTIC_BATCH_INFO_DEFAULT)
+
+            if not ignore_non_elastic_batch_info:
+                batch_params = [
+                    TRAIN_BATCH_SIZE,
+                    TRAIN_MICRO_BATCH_SIZE_PER_GPU,
+                    GRADIENT_ACCUMULATION_STEPS,
+                ]
+                if any(map(lambda t: t in self._param_dict, batch_params)):
+                    raise ElasticityConfigError("One or more batch related parameters were found in your " \
+                        f"ds_config ({TRAIN_BATCH_SIZE}, {TRAIN_MICRO_BATCH_SIZE_PER_GPU}, and/or " \
+                        f"{GRADIENT_ACCUMULATION_STEPS}). These parameters *will not be used* since " \
+                        "elastic training is enabled, which takes control of these parameters. " \
+                        "If you want to suppress this error (the parameters will be silently ignored) " \
+                        f"please set {IGNORE_NON_ELASTIC_BATCH_INFO}':true in your elasticity config.")
+
+            # micro_bsz * world_size * gas = total_batch_size
+            # gas = total_batch_size // (micro_bsz * world_size)
+            gradient_accu_steps = final_batch_size // (micro_batch_size * self.world_size)
+
+            if TRAIN_BATCH_SIZE in self._param_dict:
+                logger.warning("[Elasticity] overriding training_batch_size: "
+                               f"{self._param_dict[TRAIN_BATCH_SIZE]} -> {final_batch_size}")
+            if TRAIN_MICRO_BATCH_SIZE_PER_GPU in self._param_dict:
+                logger.warning("[Elasticity] overriding train_micro_batch_size_per_gpu: "
+                               f"{self._param_dict[TRAIN_MICRO_BATCH_SIZE_PER_GPU]} -> {micro_batch_size}")
+            if GRADIENT_ACCUMULATION_STEPS in self._param_dict:
+                logger.warning("[Elasticity] overriding gradient_accumulation_steps: "
+                               f"{self._param_dict[GRADIENT_ACCUMULATION_STEPS]} -> {gradient_accu_steps}")
+
+            logger.info(f"[Elasticity] valid GPU counts: {valid_gpus}")
+
+            self._param_dict[TRAIN_BATCH_SIZE] = final_batch_size
+            self._param_dict[TRAIN_MICRO_BATCH_SIZE_PER_GPU] = micro_batch_size
+            self._param_dict[GRADIENT_ACCUMULATION_STEPS] = gradient_accu_steps
+
+        # Pass a copy so that user json is unmodified, e.g. for logging
+        self._initialize_params(copy.copy(self._param_dict))
+        self._configure_train_batch_size()
+        self._do_sanity_check()
+
+    def _initialize_params(self, param_dict):
+        self.train_batch_size = get_train_batch_size(param_dict)
+        #print(f"beginning get_train_batch_size = {get_train_batch_size}")
+        self.train_micro_batch_size_per_gpu = get_train_micro_batch_size_per_gpu(param_dict)
+        self.gradient_accumulation_steps = get_gradient_accumulation_steps(param_dict)
+        self.steps_per_print = get_steps_per_print(param_dict)
+        self.dump_state = get_dump_state(param_dict)
+
+        self.disable_allgather = get_disable_allgather(param_dict)
+        self.communication_data_type = get_communication_data_type(param_dict)
+        self.seq_parallel_communication_data_type = get_communication_data_type(
+            param_dict, SEQ_PARALLEL_COMMUNICATION_DATA_TYPE, SEQ_PARALLEL_COMMUNICATION_DATA_TYPE_DEFAULT)
+        self.prescale_gradients = get_prescale_gradients(param_dict)
+        self.gradient_predivide_factor = get_gradient_predivide_factor(param_dict)
+        self.sparse_gradients_enabled = get_sparse_gradients_enabled(param_dict)
+
+        self.zero_config = get_zero_config(param_dict)
+        self.mics_shard_size = self.zero_config.mics_shard_size
+        self.mics_hierarchial_params_gather = self.zero_config.mics_hierarchical_params_gather
+        self.zero_optimization_stage = self.zero_config.stage
+        self.zero_enabled = self.zero_optimization_stage > 0
+
+        self.activation_checkpointing_config = DeepSpeedActivationCheckpointingConfig(param_dict)
+
+        self.comms_config = DeepSpeedCommsConfig(param_dict)
+        self.monitor_config = get_monitor_config(param_dict)
+
+        self.gradient_clipping = get_gradient_clipping(param_dict)
+        self.fp16_enabled = get_fp16_enabled(param_dict)
+        self.fp16_auto_cast = get_fp16_auto_cast(param_dict)
+        self.bfloat16_enabled = get_bfloat16_enabled(param_dict)
+        self.bfloat16_immediate_grad_update = get_bfloat16_immediate_grad_update(param_dict)
+        assert not (self.fp16_enabled
+                    and self.bfloat16_enabled), 'bfloat16 and fp16 modes cannot be simultaneously enabled'
+        self.fp16_master_weights_and_gradients = get_fp16_master_weights_and_grads_enabled(param_dict)
+        self.amp_enabled = get_amp_enabled(param_dict)
+        self.amp_params = get_amp_params(param_dict)
+        self.loss_scale = get_loss_scale(param_dict)
+        self.initial_dynamic_scale = get_initial_dynamic_scale(param_dict)
+        self.dynamic_loss_scale_args = get_dynamic_loss_scale_args(param_dict)
+
+        self.compression_config = get_compression_config(param_dict)
+        self.graph_harvesting = get_graph_harvesting(param_dict)
+
+        self.optimizer_name = get_optimizer_name(param_dict)
+        if (self.optimizer_name is not None and self.optimizer_name.lower() in DEEPSPEED_OPTIMIZERS):
+            self.optimizer_name = self.optimizer_name.lower()
+
+        self.optimizer_params = get_optimizer_params(param_dict)
+        self.optimizer_legacy_fusion = get_optimizer_legacy_fusion(param_dict)
+
+        self.zero_allow_untested_optimizer = get_zero_allow_untested_optimizer(param_dict)
+
+        self.zero_force_ds_cpu_optimizer = get_zero_force_ds_cpu_optimizer(param_dict)
+
+        self.scheduler_name = get_scheduler_name(param_dict)
+        self.scheduler_params = get_scheduler_params(param_dict)
+
+        self.flops_profiler_config = DeepSpeedFlopsProfilerConfig(param_dict)
+        self.wall_clock_breakdown = (get_wall_clock_breakdown(param_dict) | self.flops_profiler_config.enabled)
+        self.memory_breakdown = get_memory_breakdown(param_dict)
+        self.autotuning_config = DeepSpeedAutotuningConfig(param_dict)
+
+        (
+            self.eigenvalue_enabled,
+            self.eigenvalue_verbose,
+            self.eigenvalue_max_iter,
+            self.eigenvalue_tol,
+            self.eigenvalue_stability,
+            self.eigenvalue_gas_boundary_resolution,
+            self.eigenvalue_layer_name,
+            self.eigenvalue_layer_num,
+        ) = get_eigenvalue_config(param_dict)
+
+        self.use_data_before_expert_parallel_ = get_expert_data_topo_config(param_dict)
+        self.hybrid_engine = get_hybrid_engine_config(param_dict)
+
+        self.sparse_attention = get_sparse_attention(param_dict)
+        self.pipeline = get_pipeline_config(param_dict)
+
+        self.pld_enabled = get_pld_enabled(param_dict)
+        self.pld_params = get_pld_params(param_dict)
+
+        self.curriculum_enabled_legacy = get_curriculum_enabled_legacy(param_dict)
+        self.curriculum_params_legacy = get_curriculum_params_legacy(param_dict)
+
+        self.data_efficiency_enabled = get_data_efficiency_enabled(param_dict)
+        self.data_efficiency_config = get_data_efficiency_config(param_dict)
+
+        checkpoint_params = get_checkpoint_params(param_dict)
+        validation_mode = get_checkpoint_tag_validation_mode(checkpoint_params)
+        self.checkpoint_tag_validation_enabled = (validation_mode != ValidationMode.IGNORE)
+        self.checkpoint_tag_validation_fail = validation_mode == ValidationMode.FAIL
+        self.load_universal_checkpoint = checkpoint_params.get(LOAD_UNIVERSAL_CHECKPOINT,
+                                                               LOAD_UNIVERSAL_CHECKPOINT_DEFAULT)
+
+        self.use_node_local_storage = checkpoint_params.get(USE_NODE_LOCAL_STORAGE_CHECKPOINT,
+                                                            USE_NODE_LOCAL_STORAGE_CHECKPOINT_DEFAULT)
+
+        data_types_params = get_data_types_params(param_dict)
+        self.grad_accum_dtype = data_types_params.get(GRAD_ACCUM_DTYPE, GRAD_ACCUM_DTYPE_DEFAULT)
+
+        par_write_pipe = get_checkpoint_parallel_write_pipeline(checkpoint_params)
+        self.checkpoint_parallel_write_pipeline = par_write_pipe
+
+        self.aio_config = get_aio_config(param_dict)
+
+        self.dataloader_drop_last = get_dataloader_drop_last(param_dict)
+
+        self.nebula_config = DeepSpeedNebulaConfig(param_dict)
+
+        self.weight_quantization_config = WeightQuantConfig(
+            **param_dict['weight_quantization']) if 'weight_quantization' in param_dict else None
+
+        self.compile_config = get_compile_config(param_dict)
+
+    def _batch_assertion(self):
+
+        train_batch = self.train_batch_size
+        micro_batch = self.train_micro_batch_size_per_gpu
+        grad_acc = self.gradient_accumulation_steps
+
+        assert (train_batch > 0), f"Train batch size: {train_batch} has to be greater than 0"
+
+        assert (micro_batch > 0), f"Micro batch size per gpu: {micro_batch} has to be greater than 0"
+
+        assert (grad_acc > 0), f"Gradient accumulation steps: {grad_acc} has to be greater than 0"
+
+        assert train_batch == micro_batch * grad_acc * self.world_size, (
+            f"Check batch related parameters. train_batch_size is not equal "
+            "to micro_batch_per_gpu * gradient_acc_step * world_size "
+            f"{train_batch} != {micro_batch} * {grad_acc} * {self.world_size}")
+
+    def _set_batch_related_parameters(self):
+
+        train_batch = self.train_batch_size
+        micro_batch = self.train_micro_batch_size_per_gpu
+        grad_acc = self.gradient_accumulation_steps
+
+        #print(f"train_batch = {train_batch}, micro_batch={micro_batch}")
+
+        # all values are provided nothing needs to be set
+        if train_batch is not None and micro_batch is not None and grad_acc is not None:
+            return
+
+        # global_accumulation_steps needs to be set
+        elif train_batch is not None and micro_batch is not None:
+            grad_acc = train_batch // micro_batch
+            grad_acc //= self.world_size
+            self.gradient_accumulation_steps = grad_acc
+
+        # micro_batch_per_gpu needs to be set
+        elif train_batch is not None and grad_acc is not None:
+            micro_batch = train_batch // self.world_size
+            micro_batch //= grad_acc
+            self.train_micro_batch_size_per_gpu = micro_batch
+
+        # train_batch_size needs to be set
+        elif micro_batch is not None and grad_acc is not None:
+            train_batch_size = micro_batch * grad_acc
+            train_batch_size *= self.world_size
+            self.train_batch_size = train_batch_size
+
+        # gradient_accumulation_steps and micro_batch_per_gpus is set
+        elif train_batch is not None:
+            self.gradient_accumulation_steps = 1
+            self.train_micro_batch_size_per_gpu = train_batch // self.world_size
+
+        # train_batch_size and gradient_accumulation_step is set
+        elif micro_batch is not None:
+            self.train_batch_size = micro_batch * self.world_size
+            self.gradient_accumulation_steps = 1
+
+        # either none of the three parameters are provided or just gradient_accumulation_step is provided
+        else:
+            assert False, \
+                'Either train_batch_size or train_micro_batch_size_per_gpu needs to be provided'
+
+    def _configure_train_batch_size(self):
+        self._set_batch_related_parameters()
+        self._batch_assertion()
+
+    def _do_sanity_check(self):
+        self._do_error_check()
+
+        self._do_warning_check()
+
+    def print_user_config(self):
+        logger.info("  json = {}".format(
+            json.dumps(
+                self._param_dict,
+                sort_keys=True,
+                indent=4,
+                cls=ScientificNotationEncoder,
+                separators=(",", ":"),
+            )))
+
+    def print(self, name):
+        logger.info("{}:".format(name))
+        for arg in sorted(vars(self)):
+            if arg != "_param_dict":
+                dots = "." * (29 - len(arg))
+                logger.info("  {} {} {}".format(arg, dots, getattr(self, arg)))
+
+        self.print_user_config()
+
+    def _do_error_check(self):
+        assert (self.train_micro_batch_size_per_gpu
+                ), "DeepSpeedConfig: {} is not defined".format(TRAIN_MICRO_BATCH_SIZE_PER_GPU)
+
+        assert (
+            self.gradient_accumulation_steps), "DeepSpeedConfig: {} is not defined".format(GRADIENT_ACCUMULATION_STEPS)
+
+        if self.zero_enabled:
+            assert (self.zero_optimization_stage <=
+                    ZeroStageEnum.max_stage), "DeepSpeedConfig: Maximum supported ZeRO stage is {}".format(
+                        ZeroStageEnum.max_stage)
+
+        if self.fp16_master_weights_and_gradients:
+            assert self.zero_enabled and self.zero_optimization_stage == ZeroStageEnum.gradients, "Fp16_master_weights_and_grads is only supported with ZeRO Stage 2 for now."
+
+    def _do_warning_check(self):
+        fp16_enabled = self.fp16_enabled
+
+        vocabulary_size = self._param_dict.get(VOCABULARY_SIZE, VOCABULARY_SIZE_DEFAULT)
+        if vocabulary_size and vocabulary_size % TENSOR_CORE_ALIGN_SIZE != 0:
+            logger.warning(
+                "DeepSpeedConfig: vocabulary size {} is not aligned to {}, may import tensor core utilization.".format(
+                    vocabulary_size, TENSOR_CORE_ALIGN_SIZE))
+
+        if (self.optimizer_params is not None and MAX_GRAD_NORM in self.optimizer_params.keys()
+                and self.optimizer_params[MAX_GRAD_NORM] > 0):
+            if fp16_enabled:
+                if self.global_rank == 0:
+                    logger.warning("DeepSpeedConfig: In FP16 mode, DeepSpeed will pass {}:{} to FP16 wrapper".format(
+                        MAX_GRAD_NORM, self.optimizer_params[MAX_GRAD_NORM]))
+            else:
+                if self.global_rank == 0:
+                    logger.warning(
+                        "DeepSpeedConfig: In FP32 mode, DeepSpeed does not permit MAX_GRAD_NORM ({}) > 0, setting to zero"
+                        .format(self.optimizer_params[MAX_GRAD_NORM]))
+                self.optimizer_params[MAX_GRAD_NORM] = 0.0

venv/lib/python3.10/site-packages/deepspeed/runtime/constants.py

@@ -0,0 +1,457 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+#############################################
+# Routes
+#############################################
+ROUTE_TRAIN = "train"
+ROUTE_EVAL = "eval"
+ROUTE_PREDICT = "predict"
+ROUTE_ENCODE = "encode"
+
+#############################################
+# Batch size
+#############################################
+TRAIN_BATCH_SIZE = "train_batch_size"
+TRAIN_BATCH_SIZE_DEFAULT = None
+
+#############################################
+# Sparse attention
+#############################################
+SPARSE_ATTENTION = "sparse_attention"
+SPARSE_DENSE_MODE = "dense"
+SPARSE_FIXED_MODE = "fixed"
+SPARSE_VARIABLE_MODE = "variable"
+SPARSE_BIGBIRD_MODE = "bigbird"
+SPARSE_BSLONGFORMER_MODE = "bslongformer"
+SPARSE_MODE = "mode"
+SPARSE_MODE_DEFAULT = SPARSE_FIXED_MODE
+SPARSE_BLOCK = "block"
+SPARSE_BLOCK_DEFAULT = 16
+SPARSE_DIFFERENT_LAYOUT_PER_HEAD = "different_layout_per_head"
+SPARSE_DIFFERENT_LAYOUT_PER_HEAD_DEFAULT = False
+SPARSE_NUM_LOCAL_BLOCKS = "num_local_blocks"
+SPARSE_NUM_LOCAL_BLOCKS_DEFAULT = 4
+SPARSE_NUM_GLOBAL_BLOCKS = "num_global_blocks"
+SPARSE_NUM_GLOBAL_BLOCKS_DEFAULT = 1
+SPARSE_ATTENTION_TYPE = "attention"
+SPARSE_ATTENTION_TYPE_DEFAULT = "bidirectional"
+SPARSE_HORIZONTAL_GLOBAL_ATTENTION = "horizontal_global_attention"
+SPARSE_HORIZONTAL_GLOBAL_ATTENTION_DEFAULT = False
+SPARSE_NUM_DIFFERENT_GLOBAL_PATTERNS = "num_different_global_patterns"
+SPARSE_NUM_DIFFERENT_GLOBAL_PATTERNS_DEFAULT = 1
+SPARSE_NUM_RANDOM_BLOCKS = "num_random_blocks"
+SPARSE_NUM_RANDOM_BLOCKS_DEFAULT = 0
+SPARSE_LOCAL_WINDOW_BLOCKS = "local_window_blocks"
+SPARSE_LOCAL_WINDOW_BLOCKS_DEFAULT = [4]
+SPARSE_GLOBAL_BLOCK_INDICES = "global_block_indices"
+SPARSE_GLOBAL_BLOCK_INDICES_DEFAULT = [0]
+SPARSE_GLOBAL_BLOCK_END_INDICES = "global_block_end_indices"
+SPARSE_GLOBAL_BLOCK_END_INDICES_DEFAULT = None
+SPARSE_NUM_SLIDING_WINDOW_BLOCKS = "num_sliding_window_blocks"
+SPARSE_NUM_SLIDING_WINDOW_BLOCKS_DEFAULT = 3
+
+#############################################
+# Optimizer and lr scheduler
+#############################################
+OPTIMIZER = "optimizer"
+OPTIMIZER_TYPE_DEFAULT = None
+OPTIMIZER_PARAMS = "params"
+TYPE = "type"
+LEGACY_FUSION = "legacy_fusion"
+LEGACY_FUSION_DEFAULT = False
+SCHEDULER = "scheduler"
+SCHEDULER_TYPE_DEFAULT = None
+SCHEDULER_PARAMS = "params"
+MAX_GRAD_NORM = 'max_grad_norm'
+
+#############################################
+# Optimizer and lr scheduler
+#############################################
+ZERO_ALLOW_UNTESTED_OPTIMIZER = "zero_allow_untested_optimizer"
+ZERO_ALLOW_UNTESTED_OPTIMIZER_DEFAULT = False
+ZERO_FORCE_DS_CPU_OPTIMIZER = "zero_force_ds_cpu_optimizer"
+ZERO_FORCE_DS_CPU_OPTIMIZER_DEFAULT = True
+
+# Steps
+STEPS_PER_PRINT = "steps_per_print"
+STEPS_PER_PRINT_DEFAULT = 10
+
+#########################################
+# Training micro batch size per GPU
+#########################################
+# Batch size for one training step. This is used when the
+# TRAIN_BATCH_SIZE cannot fit in GPU memory to determine
+# the number of gradient accumulation steps. By default, this
+# is set to None. Users can configure in ds_config.json as below example:
+TRAIN_MICRO_BATCH_SIZE_PER_GPU = '''
+TRAIN_MICRO_BATCH_SIZE_PER_GPU is defined in this format:
+"train_micro_batch_size_per_gpu": 1
+'''
+TRAIN_MICRO_BATCH_SIZE_PER_GPU = "train_micro_batch_size_per_gpu"
+TRAIN_MICRO_BATCH_SIZE_PER_GPU_DEFAULT = None
+
+#########################################
+# Gradient Accumulation
+#########################################
+# Gradient accumulation feature. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+GRADIENT_ACCUMULATION_FORMAT = '''
+Gradient Accumulation should be of the format:
+"gradient_accumulation_steps": 1
+'''
+GRADIENT_ACCUMULATION_STEPS = "gradient_accumulation_steps"
+GRADIENT_ACCUMULATION_STEPS_DEFAULT = None
+
+# DeepSpeed CSR gradient sparsity
+SPARSE_GRADIENTS = "sparse_gradients"
+SPARSE_GRADIENTS_DEFAULT = False
+
+#########################################
+# BFLOAT16 support
+#########################################
+# BFLOAT16 feature. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+BFLOAT16_FORMAT = '''
+BFLOAT16 parameters should be of the format:
+"bf16": {
+  "enabled": true
+}
+'''
+BFLOAT16 = "bf16"
+BFLOAT16_OLD = "bfloat16"  # keeping for backwards compatibility
+
+BFLOAT16_ENABLED = "enabled"
+BFLOAT16_ENABLED_DEFAULT = False
+
+# BFLOAT16 optimizer immediate gradient update
+BFLOAT16_IMMEDIATE_GRAD_UPDATE = "immediate_grad_update"
+BFLOAT16_IMMEDIATE_GRAD_UPDATE_DEFAULT = False
+
+#########################################
+# FP16 support
+#########################################
+# FP16 feature. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+FP16_FORMAT = '''
+FP16 parameters should be of the format:
+"fp16": {
+  "enabled": true,
+  "auto_cast": false,
+  "loss_scale": 0,
+  "initial_scale_power": 16,
+  "loss_scale_window": 1000,
+  "hysteresis": 2,
+  "consecutive_hysteresis": false,
+  "min_loss_scale": 1
+}
+'''
+FP16 = "fp16"
+
+FP16_ENABLED = "enabled"
+FP16_ENABLED_DEFAULT = False
+
+# FP16 loss scale, zero means using dynamic scaling
+FP16_LOSS_SCALE = "loss_scale"
+FP16_LOSS_SCALE_DEFAULT = 0
+
+FP16_AUTO_CAST = "auto_cast"
+FP16_AUTO_CAST_DEFAULT = False
+
+# FP16 initial dynamic scale loss power
+FP16_INITIAL_SCALE_POWER = "initial_scale_power"
+FP16_INITIAL_SCALE_POWER_DEFAULT = 16
+
+# FP16 loss scale window
+FP16_LOSS_SCALE_WINDOW = "loss_scale_window"
+FP16_LOSS_SCALE_WINDOW_DEFAULT = 1000
+
+# FP16 hysteresis
+FP16_HYSTERESIS = "hysteresis"
+FP16_HYSTERESIS_DEFAULT = 2
+
+# FP16 consecutive hysteresis
+FP16_CONSECUTIVE_HYSTERESIS = "consecutive_hysteresis"
+FP16_CONSECUTIVE_HYSTERESIS_DEFAULT = False
+
+# FP16 min loss scale
+FP16_MIN_LOSS_SCALE = "min_loss_scale"
+FP16_MIN_LOSS_SCALE_DEFAULT = 1
+
+# FP16 master and grads
+FP16_MASTER_WEIGHTS_AND_GRADS = "fp16_master_weights_and_grads"
+FP16_MASTER_WEIGHTS_AND_GRADS_DEFAULT = False
+
+#########################################
+# Apex AMP support
+#########################################
+# Use Apex AMP for mixed precision support, all parameters (other than 'enabled') will be passed to
+# amp.initialize(model, optimizer, **amp_params)
+# See apex documentation for supported parameters/features: https://nvidia.github.io/apex/amp.html#apex.amp.initialize
+AMP_FORMAT = '''
+"amp" {
+  "enabled: true,
+  "opt_level": "O1",
+  ...
+}
+'''
+AMP = "amp"
+
+AMP_ENABLED = "enabled"
+AMP_ENABLED_DEFAULT = False
+
+#########################################
+# Gradient clipping
+#########################################
+# Gradient clipping. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+GRADIENT_CLIPPING_FORMAT = '''
+Gradient clipping should be enabled as:
+"gradient_clipping": 1.0
+'''
+GRADIENT_CLIPPING = 'gradient_clipping'
+GRADIENT_CLIPPING_DEFAULT = 0.
+
+#########################################
+# Capture graph for short kernels sequences
+#########################################
+# Graph harvesting. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+GRAPH_HARVESTING_FORMAT = '''
+Graph harvesting should be enabled as:
+"graph_harvesting": true
+'''
+GRAPH_HARVESTING = 'graph_harvesting'
+GRAPH_HARVESTING_DEFAULT = False
+
+#########################################
+# Communication data type
+#########################################
+# Supported types: ['none', 'fp16', 'fp32']
+# By default, this feature is not enabled ('none' value)
+# Users can configure in ds_config.json as below example:
+COMMUNICATION_DATA_TYPE_FORMAT = '''
+Communication data type should be set as:
+"communication_data_type": "fp32"
+'''
+COMMUNICATION_DATA_TYPE = "communication_data_type"
+COMMUNICATION_DATA_TYPE_DEFAULT = None
+
+###########################################################
+# Gradient communication data type for sequence parallelism
+###########################################################
+# Supported types: ['fp16', 'bf16','fp32']
+# Default value is fp32
+# Users can configure in ds_config.json as below example:
+SEQ_PARALLEL_COMMUNICATION_DATA_TYPE_FORMAT = '''
+Optional comm data type for seq paralleism should be set as:
+"seq_parallel_communication_data_type": "fp32"
+'''
+SEQ_PARALLEL_COMMUNICATION_DATA_TYPE = "seq_parallel_comm_data_type"
+SEQ_PARALLEL_COMMUNICATION_DATA_TYPE_DEFAULT = "fp32"
+
+#########################################
+# Scale/predivide gradients before allreduce
+#########################################
+# Prescale gradients. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+PRESCALE_GRADIENTS_FORMAT = '''
+Gradient prescaling should be enabled as:
+"prescale_gradients": true
+'''
+PRESCALE_GRADIENTS = "prescale_gradients"
+PRESCALE_GRADIENTS_DEFAULT = False
+
+GRADIENT_PREDIVIDE_FACTOR_FORMAT = '''
+Gradient predivide factor should be enabled as:
+"gradient_predivide_factor": 1.0
+'''
+GRADIENT_PREDIVIDE_FACTOR = "gradient_predivide_factor"
+GRADIENT_PREDIVIDE_FACTOR_DEFAULT = 1.0
+
+#########################################
+# Disable AllGather
+#########################################
+# Disable AllGather. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+DISABLE_ALLGATHER_FORMAT = '''
+Disable AllGather should be enabled as:
+"disable_allgather": true
+'''
+DISABLE_ALLGATHER = "disable_allgather"
+DISABLE_ALLGATHER_DEFAULT = False
+
+#########################################
+# Dump DeepSpeed state
+#########################################
+# Dump State. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+DUMP_STATE_FORMAT = '''
+Dump state should be enabled as:
+"dump_state": true
+'''
+DUMP_STATE = 'dump_state'
+DUMP_STATE_DEFAULT = False
+
+#########################################
+# Vocabulary size
+#########################################
+# Vocabulary size.
+# Users can configure in ds_config.json as below example:
+VOCABULARY_SIZE_FORMAT = '''
+Vocabulary size can be specified as:
+"vocabulary_size": 1024
+'''
+VOCABULARY_SIZE = 'vocabulary_size'
+VOCABULARY_SIZE_DEFAULT = None
+
+#########################################
+# Wall block breakdown
+#########################################
+# Wall clock breakdown. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+WALL_CLOCK_BREAKDOWN_FORMAT = '''
+Wall block breakdown should be enabled as:
+"wall_clock_breakdown": true
+'''
+WALL_CLOCK_BREAKDOWN = 'wall_clock_breakdown'
+WALL_CLOCK_BREAKDOWN_DEFAULT = False
+
+MEMORY_BREAKDOWN = 'memory_breakdown'
+MEMORY_BREAKDOWN_DEFAULT = False
+
+#########################################
+# Eigenvalue
+#########################################
+# Eigenvalue computation. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+EIGENVALUE_FORMAT = '''
+Tensorboard can be specified as:
+"eigenvalue": {
+  "enabled": true,
+  "verbose": true,
+  "max_iter": 100,
+  "tol": 1e-2,
+  "stability": 1e-6
+}
+'''
+EIGENVALUE = "eigenvalue"
+
+# Tensorboard enable signal
+EIGENVALUE_ENABLED = "enabled"
+EIGENVALUE_ENABLED_DEFAULT = False
+
+EIGENVALUE_VERBOSE = "verbose"
+EIGENVALUE_VERBOSE_DEFAULT = False
+
+EIGENVALUE_MAX_ITER = "max_iter"
+EIGENVALUE_MAX_ITER_DEFAULT = 100
+
+EIGENVALUE_TOL = "tol"
+EIGENVALUE_TOL_DEFAULT = 1e-2
+
+EIGENVALUE_STABILITY = "stability"
+EIGENVALUE_STABILITY_DEFAULT = 1e-6
+
+EIGENVALUE_GAS_BOUNDARY_RESOLUTION = "gas_boundary_resolution"
+EIGENVALUE_GAS_BOUNDARY_RESOLUTION_DEFAULT = 1
+
+EIGENVALUE_LAYER_NAME = "layer_name"
+EIGENVALUE_LAYER_NAME_DEFAULT = "bert.encoder.layer"
+
+EIGENVALUE_LAYER_NUM = "layer_num"
+EIGENVALUE_LAYER_NUM_DEFAULT = 0
+
+#########################################
+# Progressive Layer Drop (PLD)
+#########################################
+PROGRESSIVE_LAYER_DROP = "progressive_layer_drop"
+
+# PLD enable signal
+PLD_ENABLED = "enabled"
+PLD_ENABLED_DEFAULT = False
+
+PLD_THETA = "theta"
+PLD_THETA_DEFAULT = 1.0
+
+PLD_GAMMA = "gamma"
+PLD_GAMMA_DEFAULT = 0.001
+
+
+#########################################
+# Validation modes
+#########################################
+class ValidationMode:
+    WARN = "WARN"
+    IGNORE = "IGNORE"
+    FAIL = "FAIL"
+
+
+#########################################
+# Checkpoint config params
+#########################################
+# "checkpoint": {
+#   tag_validation=["Ignore"|"Warn"|"Fail"]
+#   load_universal=false
+#   use_node_local_storage=false
+#   parallel_write: {
+#     pipeline_stage: [True|False]
+#   }
+# }
+CHECKPOINT = "checkpoint"
+CHECKPOINT_TAG_VALIDATION = "tag_validation"
+CHECKPOINT_TAG_VALIDATION_DEFAULT = ValidationMode.WARN
+CHECKPOINT_TAG_VALIDATION_MODES = [ValidationMode.WARN, ValidationMode.IGNORE, ValidationMode.FAIL]
+
+LOAD_UNIVERSAL_CHECKPOINT = "load_universal"
+LOAD_UNIVERSAL_CHECKPOINT_DEFAULT = False
+
+USE_NODE_LOCAL_STORAGE_CHECKPOINT = "use_node_local_storage"
+USE_NODE_LOCAL_STORAGE_CHECKPOINT_DEFAULT = False
+
+CHECKPOINT_PARALLEL_WRITE = "parallel_write"
+CHECKPOINT_PARALLEL_WRITE_PIPELINE_STAGE = "pipeline_stage"
+CHECKPOINT_PARALLEL_WRITE_PIPELINE_STAGE_DEFAULT = False
+
+#########################################
+# Data types config params
+#########################################
+# "data_types": {
+#   grad_accum_dtype=["bf16"|"fp16"|"fp32"]
+#   }
+# }
+
+DATA_TYPES = "data_types"
+GRAD_ACCUM_DTYPE = "grad_accum_dtype"
+GRAD_ACCUM_DTYPE_DEFAULT = None
+
+#########################################
+# Drop the last incomplete Batch
+# #########################################
+# dataloader_drop_last. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+DATALOADER_DROP_LAST_FORMAT = '''
+The last incomplete batch can be dropped by setting:
+"dataloader_drop_last": True
+'''
+DATALOADER_DROP_LAST = "dataloader_drop_last"
+DATALOADER_DROP_LAST_DEFAULT = False
+
+#########################################
+# PIPELINE PARALLELISM
+#########################################
+PIPE_REPLICATED = 'ds_pipe_replicated'
+
+#########################################
+# DATA PARALLELISM
+#########################################
+DATA_PARALLEL_GROUP = "data_parallel_group"
+GLOBAL_RANK = "global_rank"
+
+#########################################
+# EXPERT-DATA PARALLELISM TOPO Config
+#########################################
+USE_DATA_BEFORE_EXPERT_PARALLEL = "use_data_before_expert_parallelism"
+USE_DATA_BEFORE_EXPERT_PARALLEL_DEFAULT = False

venv/lib/python3.10/site-packages/deepspeed/runtime/data_pipeline/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+'''Copyright The Microsoft DeepSpeed Team'''

venv/lib/python3.10/site-packages/deepspeed/runtime/data_pipeline/config.py

@@ -0,0 +1,168 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .constants import *
+import copy
+from ..config_utils import get_scalar_param
+
+
+# TODO: Reducing config verbosity by returning None or {} when disabled.
+# One challenge is that we still need to somehow include the default values,
+# for example the *_ENABLED has default of false.
+def get_data_efficiency_config(param_dict):
+    output = {}
+    output[DATA_EFFICIENCY_ENABLED] = get_data_efficiency_enabled(param_dict)
+    output[DATA_EFFICIENCY_SEED] = get_data_efficiency_seed(param_dict)
+    if DATA_EFFICIENCY not in param_dict.keys():
+        param_dict[DATA_EFFICIENCY] = {}
+    sub_param_dict = param_dict[DATA_EFFICIENCY]
+    output[DATA_SAMPLING] = get_data_sampling(sub_param_dict)
+    output[DATA_ROUTING] = get_data_routing(sub_param_dict)
+
+    return output
+
+
+def get_data_efficiency_enabled(param_dict):
+    if DATA_EFFICIENCY in param_dict.keys():
+        return get_scalar_param(param_dict[DATA_EFFICIENCY], DATA_EFFICIENCY_ENABLED, DATA_EFFICIENCY_ENABLED_DEFAULT)
+    else:
+        return False
+
+
+def get_data_efficiency_seed(param_dict):
+    if DATA_EFFICIENCY in param_dict.keys():
+        return get_scalar_param(param_dict[DATA_EFFICIENCY], DATA_EFFICIENCY_SEED, DATA_EFFICIENCY_SEED_DEFAULT)
+    else:
+        return DATA_EFFICIENCY_SEED_DEFAULT
+
+
+def get_data_sampling(param_dict):
+    output = {}
+    output[DATA_SAMPLING_ENABLED] = get_data_sampling_enabled(param_dict)
+    output[DATA_SAMPLING_NUM_EPOCHS] = get_data_sampling_num_epochs(param_dict)
+    output[DATA_SAMPLING_NUM_WORKERS] = get_data_sampling_num_workers(param_dict)
+    if DATA_SAMPLING not in param_dict.keys():
+        param_dict[DATA_SAMPLING] = {}
+    sub_param_dict = param_dict[DATA_SAMPLING]
+    output[CURRICULUM_LEARNING] = get_curriculum_learning(sub_param_dict)
+
+    return output
+
+
+def get_data_sampling_enabled(param_dict):
+    if DATA_SAMPLING in param_dict.keys():
+        return get_scalar_param(param_dict[DATA_SAMPLING], DATA_SAMPLING_ENABLED, DATA_SAMPLING_ENABLED_DEFAULT)
+    else:
+        return False
+
+
+def get_data_sampling_num_epochs(param_dict):
+    if DATA_SAMPLING in param_dict.keys():
+        return get_scalar_param(param_dict[DATA_SAMPLING], DATA_SAMPLING_NUM_EPOCHS, DATA_SAMPLING_NUM_EPOCHS_DEFAULT)
+    else:
+        return DATA_SAMPLING_NUM_EPOCHS_DEFAULT
+
+
+def get_data_sampling_num_workers(param_dict):
+    if DATA_SAMPLING in param_dict.keys():
+        return get_scalar_param(param_dict[DATA_SAMPLING], DATA_SAMPLING_NUM_WORKERS,
+                                DATA_SAMPLING_NUM_WORKERS_DEFAULT)
+    else:
+        return DATA_SAMPLING_NUM_WORKERS_DEFAULT
+
+
+def get_curriculum_learning(param_dict):
+    output = {}
+    output[CURRICULUM_LEARNING_ENABLED] = get_curriculum_learning_enabled(param_dict)
+    if CURRICULUM_LEARNING not in param_dict.keys():
+        param_dict[CURRICULUM_LEARNING] = {}
+    sub_param_dict = param_dict[CURRICULUM_LEARNING]
+    if output[CURRICULUM_LEARNING_ENABLED]:
+        assert CURRICULUM_LEARNING_METRICS in sub_param_dict.keys(
+        ), f"Curriculum learning is enabled, {CURRICULUM_LEARNING_METRICS} must be specified"
+        for key, val in get_curriculum_learning_params(param_dict).items():
+            output[key] = val
+    return output
+
+
+def get_curriculum_learning_enabled(param_dict):
+    if CURRICULUM_LEARNING in param_dict.keys():
+        return get_scalar_param(param_dict[CURRICULUM_LEARNING], CURRICULUM_LEARNING_ENABLED,
+                                CURRICULUM_LEARNING_ENABLED_DEFAULT)
+    else:
+        return False
+
+
+def get_curriculum_learning_params(param_dict):
+    if CURRICULUM_LEARNING in param_dict.keys():
+        curriculum_learning_params = copy.copy(param_dict[CURRICULUM_LEARNING])
+        curriculum_learning_params.pop(CURRICULUM_LEARNING_ENABLED)
+        return curriculum_learning_params
+    else:
+        return {}
+
+
+def get_curriculum_enabled_legacy(param_dict):
+    if CURRICULUM_LEARNING_LEGACY in param_dict.keys():
+        return get_scalar_param(param_dict[CURRICULUM_LEARNING_LEGACY], CURRICULUM_ENABLED_LEGACY,
+                                CURRICULUM_ENABLED_DEFAULT_LEGACY)
+    else:
+        return False
+
+
+def get_curriculum_params_legacy(param_dict):
+    if CURRICULUM_LEARNING_LEGACY in param_dict.keys():
+        curriculum_params = copy.copy(param_dict[CURRICULUM_LEARNING_LEGACY])
+        curriculum_params.pop(CURRICULUM_ENABLED_LEGACY)
+        return curriculum_params
+    else:
+        return False
+
+
+def get_data_routing(param_dict):
+    output = {}
+    output[DATA_ROUTING_ENABLED] = get_data_routing_enabled(param_dict)
+    if DATA_ROUTING not in param_dict.keys():
+        param_dict[DATA_ROUTING] = {}
+    sub_param_dict = param_dict[DATA_ROUTING]
+    output[RANDOM_LTD] = get_random_ltd(sub_param_dict)
+
+    return output
+
+
+def get_data_routing_enabled(param_dict):
+    if DATA_ROUTING in param_dict.keys():
+        return get_scalar_param(param_dict[DATA_ROUTING], DATA_ROUTING_ENABLED, DATA_ROUTING_ENABLED_DEFAULT)
+    else:
+        return False
+
+
+def get_random_ltd(param_dict):
+    output = {}
+    output[RANDOM_LTD_ENABLED] = RANDOM_LTD_ENABLED_DEFAULT
+    output[RANDOM_LTD_LAYER_TOKEN_LR_SCHEDULE] = {}
+    output[RANDOM_LTD_LAYER_TOKEN_LR_SCHEDULE][
+        RANDOM_LTD_LAYER_TOKEN_LR_ENABLED] = RANDOM_LTD_LAYER_TOKEN_LR_ENABLED_DEFAULT
+    if get_random_ltd_enabled(param_dict):
+        output[RANDOM_LTD_ENABLED] = get_random_ltd_enabled(param_dict)
+        for key, val in get_random_ltd_params(param_dict).items():
+            output[key] = val
+    return output
+
+
+def get_random_ltd_enabled(param_dict):
+    if RANDOM_LTD in param_dict.keys():
+        return get_scalar_param(param_dict[RANDOM_LTD], RANDOM_LTD_ENABLED, RANDOM_LTD_ENABLED_DEFAULT)
+    else:
+        return False
+
+
+def get_random_ltd_params(param_dict):
+    if RANDOM_LTD in param_dict.keys():
+        random_ltd_params = copy.copy(param_dict[RANDOM_LTD])
+        random_ltd_params.pop(RANDOM_LTD_ENABLED)
+        return random_ltd_params
+    else:
+        return {}

venv/lib/python3.10/site-packages/deepspeed/runtime/data_pipeline/constants.py

@@ -0,0 +1,116 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""
+Data efficiency library
+ See sample config at https://www.deepspeed.ai/docs/config-json/data-efficiency
+"""
+DATA_EFFICIENCY = "data_efficiency"
+DATA_EFFICIENCY_ENABLED = "enabled"
+DATA_EFFICIENCY_ENABLED_DEFAULT = False
+DATA_EFFICIENCY_SEED = "seed"
+DATA_EFFICIENCY_SEED_DEFAULT = 1234
+
+#########################################
+# Data efficiency - Data Sampling
+#########################################
+DATA_SAMPLING = "data_sampling"
+DATA_SAMPLING_ENABLED = "enabled"
+DATA_SAMPLING_ENABLED_DEFAULT = False
+DATA_SAMPLING_NUM_EPOCHS = "num_epochs"
+DATA_SAMPLING_NUM_EPOCHS_DEFAULT = 1000
+DATA_SAMPLING_NUM_WORKERS = "num_workers"
+DATA_SAMPLING_NUM_WORKERS_DEFAULT = 0
+
+#########################################
+# Data efficiency - Data Sampling - Curriculum Learning
+#########################################
+CURRICULUM_LEARNING = "curriculum_learning"
+CURRICULUM_LEARNING_ENABLED = "enabled"
+CURRICULUM_LEARNING_ENABLED_DEFAULT = False
+CURRICULUM_LEARNING_CLUSTER_PATH = "data_cluster_path"
+CURRICULUM_LEARNING_METRICS = "curriculum_metrics"
+CURRICULUM_LEARNING_SAMPLE_PATH = "index_to_sample_path"
+CURRICULUM_LEARNING_METRIC_PATH = "index_to_metric_path"
+CURRICULUM_LEARNING_CLUSTERING_TYPE = "clustering_type"
+CURRICULUM_LEARNING_SINGLE_CLUSTER = "single_cluster"
+CURRICULUM_LEARNING_CLUSTER_PREFIX = "cluster"
+CURRICULUM_LEARNING_DIFFICULTY_TYPE = "difficulty_type"
+CURRICULUM_LEARNING_VALUE_BASED = "value"
+CURRICULUM_LEARNING_PERCENTILE_BASED = "percentile"
+CURRICULUM_LEARNING_MIN_DIFFICULTY = "min_difficulty"
+CURRICULUM_LEARNING_MAX_DIFFICULTY = "max_difficulty"
+CURRICULUM_LEARNING_SCHEDULE_TYPE = "schedule_type"
+CURRICULUM_LEARNING_SCHEDULE_CONFIG = "schedule_config"
+CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY = "difficulty"
+CURRICULUM_LEARNING_SCHEDULE_MAX_STEP = "max_step"
+CURRICULUM_LEARNING_SCHEDULE_TOTAL_STEP = "total_curriculum_step"
+CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY_STEP = "difficulty_step"
+CURRICULUM_LEARNING_SCHEDULE_ROOT_DEGREE = "root_degree"
+CURRICULUM_LEARNING_SCHEDULE_FIXED_DISCRETE = "fixed_discrete"
+CURRICULUM_LEARNING_SCHEDULE_FIXED_ROOT = "fixed_root"
+CURRICULUM_LEARNING_SCHEDULE_FIXED_LINEAR = "fixed_linear"
+CURRICULUM_LEARNING_SCHEDULE_CUSTOM = "custom"
+CURRICULUM_LEARNING_CURRENT_DIFFICULTY = "current_difficulty"
+
+CURRICULUM_LEARNING_BATCH = "batch"
+CURRICULUM_LEARNING_CONSUMED_SAMPLES = "consumed_samples"
+CURRICULUM_LEARNING_STEP = "curriculum_step"
+CURRICULUM_LEARNING_CURRENT_DIFFICULTIES = "current_difficulties"
+CURRICULUM_LEARNING_DATA_CLUSTER_PATHS = "data_cluster_paths"
+CURRICULUM_LEARNING_DATA_CLUSTER_CURRENT_POSITION = "data_cluster_current_position"
+CURRICULUM_LEARNING_NP_RNG_STATE = "np_rng_state"
+
+#########################################
+# Curriculum Learning legacy implementation
+#########################################
+CURRICULUM_LEARNING_LEGACY = "curriculum_learning"
+
+CURRICULUM_ENABLED_LEGACY = "enabled"
+CURRICULUM_ENABLED_DEFAULT_LEGACY = False
+
+#########################################
+# Data efficiency - Data Routing
+#########################################
+DATA_ROUTING = "data_routing"
+DATA_ROUTING_ENABLED = "enabled"
+DATA_ROUTING_ENABLED_DEFAULT = False
+
+#########################################
+# Data efficiency - Data Routing - Random LTD
+#########################################
+RANDOM_LTD = "random_ltd"
+RANDOM_LTD_ENABLED = "enabled"
+RANDOM_LTD_ENABLED_DEFAULT = False
+
+RANDOM_LTD_MODEL_MASK_NAME = "model_mask_name"
+RANDOM_LTD_MODEL_TYPE = "model_type"
+RANDOM_LTD_MICRO_BATCH_SIZE = "micro_batch_size"
+RANDOM_LTD_GLOBAL_BATCH_SIZE = "global_batch_size"
+RANDOM_LTD_SAMPLE_INDEX = "sample_idx"
+RANDOM_LTD_ATTENTION_MASK = "attention_mask"
+RANDOM_LTD_HIDDEN_STATE_ORDER = "hidden_state_order"
+RANDOM_LTD_LAYER_NUM = "random_ltd_layer_num"
+RANDOM_LTD_LAYER_ID = "random_ltd_layer_id"
+RANDOM_LTD_TOTAL_LAYER_NUM = "total_layer_num"
+RANDOM_LTD_CONSUMED_LAYER_TOKENS = "consumed_layer_tokens"
+
+# scheduler
+RANDOM_LTD_SCHEDULER = "random_ltd_schedule"
+RANDOM_LTD_MAX_VALUE = "max_value"
+RANDOM_LTD_MIN_VALUE = "min_value"
+RANDOM_LTD_CURRENT_VALUE = "current_value"
+RANDOM_LTD_SCHEDULE_CONFIG = "schedule_config"
+RANDOM_LTD_INCREASE_STEP = "seq_per_step"
+RANDOM_LTD_REQUIRE_STEP = "require_steps"
+RANDOM_LTD_SCHEDULER_TYPE = "schedule_type"
+RANDOM_LTD_CURR_STEP = "current_steps"
+
+# learning rate schedulers
+RANDOM_LTD_LAYER_TOKEN_LR_SCHEDULE = "layer_token_lr_schedule"
+RANDOM_LTD_LAYER_TOKEN_LR_ENABLED = "enabled"
+RANDOM_LTD_LAYER_TOKEN_LR_ENABLED_DEFAULT = False
+RANDOM_LTD_TOTAL_LAYER_TOKENS = "total_layer_tokens"
+RANDOM_LTD_WARMUP_TYPE = "warmup_type"
+RANDOM_LTD_WARMUP_LAYER_TOKENS = "warmup_layer_tokens"

venv/lib/python3.10/site-packages/deepspeed/runtime/data_pipeline/curriculum_scheduler.py

@@ -0,0 +1,158 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import math
+from deepspeed.utils import logger
+from .constants import *
+
+
+class CurriculumScheduler(object):
+
+    def __init__(self, config):
+        super().__init__()
+        self.state = {}
+        assert CURRICULUM_LEARNING_MIN_DIFFICULTY in config, \
+            f"Curriculum learning requires the config '{CURRICULUM_LEARNING_MIN_DIFFICULTY}'"
+        assert CURRICULUM_LEARNING_MAX_DIFFICULTY in config, \
+            f"Curriculum learning requires the config '{CURRICULUM_LEARNING_MAX_DIFFICULTY}'"
+        assert CURRICULUM_LEARNING_SCHEDULE_TYPE in config, \
+            f"Curriculum learning requires the config '{CURRICULUM_LEARNING_SCHEDULE_TYPE}'"
+        self.state[CURRICULUM_LEARNING_MIN_DIFFICULTY] = config[CURRICULUM_LEARNING_MIN_DIFFICULTY]
+        self.state[CURRICULUM_LEARNING_MAX_DIFFICULTY] = config[CURRICULUM_LEARNING_MAX_DIFFICULTY]
+        self.state[CURRICULUM_LEARNING_CURRENT_DIFFICULTY] = config[CURRICULUM_LEARNING_MIN_DIFFICULTY]
+        self.state[CURRICULUM_LEARNING_SCHEDULE_TYPE] = config[CURRICULUM_LEARNING_SCHEDULE_TYPE]
+        self.first_step = True
+        if config[CURRICULUM_LEARNING_SCHEDULE_TYPE] == CURRICULUM_LEARNING_SCHEDULE_FIXED_DISCRETE:
+            """
+            The schedule_config is a list of difficulty and a list of max
+            step belonging to each difficulty. Example json config:
+            "schedule_config": {
+              "difficulty": [1,2,3],
+              "max_step": [5,10]
+            }
+            The "max_step" has one less element than "difficulty", because
+            the last difficulty will be used for all following steps.
+            The self.state[CURRICULUM_LEARNING_SCHEDULE_CONFIG] is a dictionary of
+            difficulty : [max step for this difficulty, next difficulty].
+            """
+            assert CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY in config[CURRICULUM_LEARNING_SCHEDULE_CONFIG], \
+                f"Curriculum learning with fixed_discrete schedule requires the schedule_config '{CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY}'"
+            assert CURRICULUM_LEARNING_SCHEDULE_MAX_STEP in config[CURRICULUM_LEARNING_SCHEDULE_CONFIG], \
+                f"Curriculum learning with fixed_discrete schedule requires the schedule_config '{CURRICULUM_LEARNING_SCHEDULE_MAX_STEP}'"
+            assert len(config[CURRICULUM_LEARNING_SCHEDULE_CONFIG][CURRICULUM_LEARNING_SCHEDULE_MAX_STEP]) > 0
+            assert len(config[CURRICULUM_LEARNING_SCHEDULE_CONFIG][CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY]) > 0
+            assert len(config[CURRICULUM_LEARNING_SCHEDULE_CONFIG][CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY]) == len(
+                config[CURRICULUM_LEARNING_SCHEDULE_CONFIG][CURRICULUM_LEARNING_SCHEDULE_MAX_STEP]) + 1
+            self.state[CURRICULUM_LEARNING_SCHEDULE_CONFIG] = config[CURRICULUM_LEARNING_SCHEDULE_CONFIG]
+        elif config[CURRICULUM_LEARNING_SCHEDULE_TYPE] == CURRICULUM_LEARNING_SCHEDULE_FIXED_ROOT:
+            """
+            The schedule_config includes:
+            total_curriculum_step: how many steps the curriculum learning takes to go
+            from min difficulty to max difficulty.
+            difficulty_step: the difficulty level determined every time must
+            be a multiple of this difficulty_step. This is used to determine
+            the step of difficulty increase, and to ensure the use of NVIDIA
+            Tensor Core acceleration (requires multiple of 8 (FP16) or
+            16 (INT8)).
+            root_degree: the degree of the root function. Degree of 2 means
+            square root and degree of 3 means cube root. Degree of 1 is
+            equivalent to linear.
+            "schedule_config": {
+              "total_curriculum_step": 30000,
+              "difficulty_step": 8,
+              "root_degree": 2
+            }
+            """
+            assert CURRICULUM_LEARNING_SCHEDULE_TOTAL_STEP in config[CURRICULUM_LEARNING_SCHEDULE_CONFIG], \
+                f"Curriculum learning with fixed_root schedule requires the schedule_config '{CURRICULUM_LEARNING_SCHEDULE_TOTAL_STEP}'"
+            assert CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY_STEP in config[CURRICULUM_LEARNING_SCHEDULE_CONFIG], \
+                f"Curriculum learning with fixed_root schedule requires the schedule_config '{CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY_STEP}'"
+            assert CURRICULUM_LEARNING_SCHEDULE_ROOT_DEGREE in config[CURRICULUM_LEARNING_SCHEDULE_CONFIG], \
+                f"Curriculum learning with fixed_root schedule requires the schedule_config '{CURRICULUM_LEARNING_SCHEDULE_ROOT_DEGREE}'"
+            if config[CURRICULUM_LEARNING_SCHEDULE_CONFIG][CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY_STEP] % 8 != 0:
+                logger.warning(
+                    f'When using seqlen metric, the difficulty_step for curriculum learning has to be multiple of 8 (for FP16 data) or 16 (for INT8 data) to enable NVIDIA Tensor Core acceleration. Disregard this warning if this is unrelated to your metric/hardware.'
+                )
+            self.state[CURRICULUM_LEARNING_SCHEDULE_CONFIG] = config[CURRICULUM_LEARNING_SCHEDULE_CONFIG]
+        elif config[CURRICULUM_LEARNING_SCHEDULE_TYPE] == CURRICULUM_LEARNING_SCHEDULE_FIXED_LINEAR:
+            """
+            The schedule_config is the same as CURRICULUM_LEARNING_SCHEDULE_FIXED_ROOT but without the
+            root_degree.
+            "schedule_config": {
+              "total_curriculum_step": 30000,
+              "difficulty_step": 8
+            }
+            """
+            assert CURRICULUM_LEARNING_SCHEDULE_TOTAL_STEP in config[CURRICULUM_LEARNING_SCHEDULE_CONFIG], \
+                f"Curriculum learning with fixed_linear schedule requires the schedule_config '{CURRICULUM_LEARNING_SCHEDULE_TOTAL_STEP}'"
+            assert CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY_STEP in config[CURRICULUM_LEARNING_SCHEDULE_CONFIG], \
+                f"Curriculum learning with fixed_linear schedule requires the schedule_config '{CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY_STEP}'"
+            if config[CURRICULUM_LEARNING_SCHEDULE_CONFIG][CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY_STEP] % 8 != 0:
+                logger.warning(
+                    f'When using seqlen metric, the difficulty_step for curriculum learning has to be multiple of 8 (for FP16 data) or 16 (for INT8 data) to enable NVIDIA Tensor Core acceleration. Disregard this warning if this is unrelated to your metric/hardware.'
+                )
+            self.state[CURRICULUM_LEARNING_SCHEDULE_CONFIG] = config[CURRICULUM_LEARNING_SCHEDULE_CONFIG]
+        elif config[CURRICULUM_LEARNING_SCHEDULE_TYPE] == CURRICULUM_LEARNING_SCHEDULE_CUSTOM:
+            """
+            Fully customized schedule. User need to provide a custom schedule
+            function by using the set_custom_curriculum_learning_schedule API
+            in deepspeed/runtime/engine.py
+            """
+            self.custom_get_difficulty = None
+        else:
+            raise RuntimeError('Unsupported curriculum schedule type')
+
+    def get_current_difficulty(self):
+        return self.state[CURRICULUM_LEARNING_CURRENT_DIFFICULTY]
+
+    def set_current_difficulty(self, difficulty):
+        self.state[CURRICULUM_LEARNING_CURRENT_DIFFICULTY] = difficulty
+
+    def set_custom_get_difficulty(self, schedule_function):
+        self.custom_get_difficulty = schedule_function
+
+    def get_state(self):
+        return self.state
+
+    def set_state(self, state):
+        self.state = state
+
+    def __fixed_discrete_get_difficulty(self, global_steps):
+        s_state = self.state[CURRICULUM_LEARNING_SCHEDULE_CONFIG]
+        if global_steps > s_state[CURRICULUM_LEARNING_SCHEDULE_MAX_STEP][-1]:
+            return s_state[CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY][-1]
+        for i in range(len(s_state[CURRICULUM_LEARNING_SCHEDULE_MAX_STEP])):
+            if global_steps <= s_state[CURRICULUM_LEARNING_SCHEDULE_MAX_STEP][i]:
+                return s_state[CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY][i]
+
+    def __fixed_root_get_difficulty(self, global_steps, root_degree=None):
+        s_state = self.state[CURRICULUM_LEARNING_SCHEDULE_CONFIG]
+        if root_degree is None:
+            root_degree = s_state[CURRICULUM_LEARNING_SCHEDULE_ROOT_DEGREE]
+        next_difficulty = (float(global_steps) / s_state[CURRICULUM_LEARNING_SCHEDULE_TOTAL_STEP])**(1.0 / root_degree)
+        next_difficulty = math.floor(
+            next_difficulty *
+            (self.state[CURRICULUM_LEARNING_MAX_DIFFICULTY] - self.state[CURRICULUM_LEARNING_MIN_DIFFICULTY]) +
+            self.state[CURRICULUM_LEARNING_MIN_DIFFICULTY])
+        next_difficulty -= (next_difficulty % s_state[CURRICULUM_LEARNING_SCHEDULE_DIFFICULTY_STEP])
+        next_difficulty = min(next_difficulty, self.state[CURRICULUM_LEARNING_MAX_DIFFICULTY])
+        return next_difficulty
+
+    def get_difficulty(self, global_steps):
+        if self.state[CURRICULUM_LEARNING_SCHEDULE_TYPE] == CURRICULUM_LEARNING_SCHEDULE_FIXED_DISCRETE:
+            return self.__fixed_discrete_get_difficulty(global_steps)
+        elif self.state[CURRICULUM_LEARNING_SCHEDULE_TYPE] == CURRICULUM_LEARNING_SCHEDULE_FIXED_LINEAR:
+            return self.__fixed_root_get_difficulty(global_steps, 1)
+        elif self.state[CURRICULUM_LEARNING_SCHEDULE_TYPE] == CURRICULUM_LEARNING_SCHEDULE_FIXED_ROOT:
+            return self.__fixed_root_get_difficulty(global_steps)
+        elif self.state[CURRICULUM_LEARNING_SCHEDULE_TYPE] == CURRICULUM_LEARNING_SCHEDULE_CUSTOM:
+            return self.custom_get_difficulty(global_steps)
+        else:
+            raise RuntimeError('Unsupported curriculum schedule type')
+
+    def update_difficulty(self, global_steps):
+        if self.state[CURRICULUM_LEARNING_CURRENT_DIFFICULTY] < self.state[CURRICULUM_LEARNING_MAX_DIFFICULTY]:
+            self.state[CURRICULUM_LEARNING_CURRENT_DIFFICULTY] = self.get_difficulty(global_steps)
+        return self.state[CURRICULUM_LEARNING_CURRENT_DIFFICULTY]

venv/lib/python3.10/site-packages/deepspeed/runtime/data_pipeline/data_sampling/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+'''Copyright The Microsoft DeepSpeed Team'''

venv/lib/python3.10/site-packages/deepspeed/runtime/data_pipeline/data_sampling/data_analyzer.py

@@ -0,0 +1,880 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import os
+import sys
+from collections import defaultdict
+import csv
+import time
+from multiprocessing import Process, Manager
+import numpy as np
+import torch
+from torch.utils.data import BatchSampler, SequentialSampler, DataLoader, Subset
+
+import deepspeed.comm as dist
+from deepspeed.utils import logger
+from deepspeed.runtime.data_pipeline.data_sampling.indexed_dataset import MMapIndexedDataset, valid_dtypes
+from deepspeed.runtime.data_pipeline.data_sampling.utils import split_dataset, split_index, create_mmap_dataset_builder, close_mmap_dataset_builder, find_fit_int_dtype
+
+
+class DataAnalyzer(object):
+
+    def __init__(self,
+                 dataset,
+                 num_workers=1,
+                 worker_id=0,
+                 num_threads=1,
+                 num_threads_reduce=1,
+                 specific_threads=[],
+                 batch_size=1,
+                 metric_names=[],
+                 metric_functions=[],
+                 metric_types=[],
+                 metric_dtypes=[],
+                 save_path="./",
+                 collate_fn=None,
+                 custom_map_init=None,
+                 custom_map_update=None,
+                 custom_map_finalize=None,
+                 custom_reduce=None,
+                 sample_indices=None):
+        super().__init__()
+        self.dataset = dataset
+        self.num_workers = num_workers
+        self.worker_id = worker_id
+        self.num_threads = num_threads
+        self.num_threads_reduce = num_threads_reduce
+        self.specific_threads = specific_threads
+        self.batch_size = batch_size
+        self.metric_names = metric_names
+        self.metric_functions = metric_functions
+        self.metric_types = metric_types
+        self.metric_dtypes = metric_dtypes
+        self.save_path = save_path
+        self.collate_fn = collate_fn
+        self.custom_map_init = custom_map_init
+        self.custom_map_update = custom_map_update
+        self.custom_map_finalize = custom_map_finalize
+        self.custom_reduce = custom_reduce
+        self.sample_indices = sample_indices
+
+    def init_metric_results(self, thread_id, metric_names, metric_types, metric_dtypes, save_path, worker_id):
+        metric_results = []
+        for m_idx in range(len(metric_names)):
+            metric_name, metric_type, metric_dtype = metric_names[m_idx], \
+                metric_types[m_idx], metric_dtypes[m_idx]
+            assert metric_dtype in valid_dtypes, f"metric_dtype {metric_dtype} not supported. Supported dtypes {valid_dtypes}"
+            metric_save_path = f"{save_path}/{metric_name}/worker{worker_id}_thread{thread_id}/"
+            os.makedirs(metric_save_path, exist_ok=True)
+            if metric_type == 'single_value_per_sample':
+                sample_to_metric_fname = f"{metric_save_path}/{metric_name}_sample_to_metric"
+                sample_to_metric_builder = create_mmap_dataset_builder(sample_to_metric_fname, metric_dtype)
+                metric_to_sample_fname = f"{metric_save_path}/{metric_name}_metric_to_sample"
+                os.system(f"rm -rf {metric_to_sample_fname}*")
+                metric_to_sample_dict = defaultdict(list)
+                metric_results.append({
+                    "sample_to_metric_fname": sample_to_metric_fname,
+                    "sample_to_metric_builder": sample_to_metric_builder,
+                    "metric_to_sample_fname": metric_to_sample_fname,
+                    "metric_to_sample_dict": metric_to_sample_dict
+                })
+            elif metric_type == 'accumulate_value_over_samples':
+                metric_value = None
+                metric_value_fname = f"{metric_save_path}/{metric_name}_metric_value"
+                metric_results.append({"metric_value": metric_value, "metric_value_fname": metric_value_fname})
+        return metric_results
+
+    def update_metric_results(self,
+                              data,
+                              metric_types,
+                              metric_dtypes,
+                              metric_functions,
+                              metric_results,
+                              batch_start_idx=0):
+        for m_idx in range(len(metric_types)):
+            metric_type, metric_dtype, metric_function, metric_result = metric_types[m_idx], \
+                metric_dtypes[m_idx], metric_functions[m_idx], metric_results[m_idx]
+            metric_values = metric_function(data)
+
+            assert torch.is_tensor(metric_values) or isinstance(metric_values, np.ndarray), \
+                "metric_function must return a tensor or array"
+            assert metric_values.dtype == metric_dtype, \
+                f"metric_function result dtype {metric_values.dtype} does not match metric_dtype {metric_dtype}"
+            if isinstance(metric_values, np.ndarray):
+                metric_values = torch.from_numpy(metric_values)
+
+            if metric_type == 'single_value_per_sample':
+                for row in range(metric_values.size()[0]):
+                    sample_idx = batch_start_idx + row  # sample idx following dataset iteration order
+                    if isinstance(data, dict) and 'index' in data:  # Megatron use case, idx provided in 'index' field
+                        sample_idx = data['index'][row][0].item()
+                    elif self.sample_indices is not None:  # user defined shuffling of indices
+                        sample_idx = self.sample_indices[sample_idx]
+                    metric_result["sample_to_metric_builder"].add_item(metric_values[row].reshape(-1))
+                    metric_result["metric_to_sample_dict"][metric_values[row].item()].append(sample_idx)
+                for m_value in metric_result["metric_to_sample_dict"]:
+                    if len(metric_result["metric_to_sample_dict"][m_value]) > 100:
+                        metric_fname = metric_result["metric_to_sample_fname"]
+                        with open(f"{metric_fname}_{m_value}.csv", 'a') as f:
+                            writer = csv.writer(f)
+                            writer.writerows([metric_result["metric_to_sample_dict"][m_value]])
+                        metric_result["metric_to_sample_dict"][m_value] = []
+            elif metric_type == 'accumulate_value_over_samples':
+                if metric_result["metric_value"] is None:
+                    metric_result["metric_value"] = metric_values
+                else:
+                    metric_result["metric_value"].add_(metric_values)
+
+    def finalize_metric_results(self, metric_types, metric_dtypes, metric_results):
+        for m_idx in range(len(metric_types)):
+            metric_type, metric_dtype, metric_result = metric_types[m_idx], \
+                metric_dtypes[m_idx], metric_results[m_idx]
+            if metric_type == 'single_value_per_sample':
+                metric_fname = metric_result["sample_to_metric_fname"]
+                close_mmap_dataset_builder(metric_result["sample_to_metric_builder"], metric_fname)
+                for m_value in metric_result["metric_to_sample_dict"]:
+                    if len(metric_result["metric_to_sample_dict"][m_value]) > 0:
+                        metric_fname = metric_result["metric_to_sample_fname"]
+                        with open(f"{metric_fname}_{m_value}.csv", 'a') as f:
+                            writer = csv.writer(f)
+                            writer.writerows([metric_result["metric_to_sample_dict"][m_value]])
+                        metric_result["metric_to_sample_dict"][m_value] = []
+            elif metric_type == 'accumulate_value_over_samples':
+                if metric_result["metric_value"] is not None:
+                    metric_value_builder = create_mmap_dataset_builder(metric_result["metric_value_fname"],
+                                                                       metric_dtype)
+                    metric_value_builder.add_item(metric_result["metric_value"].reshape(-1))
+                    close_mmap_dataset_builder(metric_value_builder, metric_result["metric_value_fname"])
+
+    def run_map_helper(self, thread_id):
+        start_idx, end_idx = self.thread_splits[thread_id][0], \
+            self.thread_splits[thread_id][1]
+        logger.info(f"worker {self.worker_id} thread {thread_id}: start working " \
+            f"on data subset {start_idx} to {end_idx}")
+        thread_dataset = Subset(self.dataset, list(range(start_idx, end_idx)))
+        sampler = BatchSampler(SequentialSampler(thread_dataset), batch_size=self.batch_size, drop_last=False)
+        iterator = iter(
+            DataLoader(thread_dataset,
+                       batch_sampler=sampler,
+                       num_workers=0,
+                       collate_fn=self.collate_fn,
+                       pin_memory=False))
+        if self.custom_map_init is None:
+            metric_results = self.init_metric_results(thread_id, self.metric_names, self.metric_types,
+                                                      self.metric_dtypes, self.save_path, self.worker_id)
+        else:
+            metric_results = self.custom_map_init(thread_id, self.metric_names, self.metric_types, self.metric_dtypes,
+                                                  self.save_path, self.worker_id)
+        total_sample = len(thread_dataset)
+        processed_sample = 0
+        start = time.time()
+        while True:
+            try:
+                data = next(iterator)
+                batch_start_idx = start_idx + processed_sample
+                if self.custom_map_update is None:
+                    self.update_metric_results(data, self.metric_types, self.metric_dtypes, self.metric_functions,
+                                               metric_results, batch_start_idx)
+                else:
+                    self.custom_map_update(data, self.metric_types, self.metric_dtypes, self.metric_functions,
+                                           metric_results, batch_start_idx)
+                processed_sample += len(data)
+                duration = (time.time() - start) / 3600.0
+                remain_duration = duration * total_sample / processed_sample - duration
+                logger.info(
+                    f"worker {self.worker_id} thread {thread_id}: {processed_sample} " \
+                    f"out of {total_sample} processed in {duration:.2f} hr, " \
+                    f"estimated to finish in {remain_duration:.2f} hr")
+            except StopIteration:
+                logger.info(f"worker {self.worker_id} thread {thread_id}: reach end of file")
+                break
+        if self.custom_map_finalize is None:
+            self.finalize_metric_results(self.metric_types, self.metric_dtypes, metric_results)
+        else:
+            self.custom_map_finalize(self.metric_types, self.metric_dtypes, metric_results)
+        logger.info(f"worker {self.worker_id} thread {thread_id}: finished")
+
+    def run_map(self):
+        self.worker_splits, self.thread_splits = split_dataset(self.dataset, self.num_workers, self.worker_id,
+                                                               self.num_threads)
+        if len(self.specific_threads) > 0:
+            threads_to_run = self.specific_threads
+        else:
+            threads_to_run = list(range(self.num_threads))
+        if self.num_threads > 1:
+            p = []
+            for thread in threads_to_run:
+                p.append(Process(target=self.run_map_helper, args=(thread, )))
+                p[thread].start()
+
+            for thread in threads_to_run:
+                p[thread].join()
+        else:
+            assert self.num_threads == 1
+            self.run_map_helper(0)
+
+    def get_metric_value_percentiles(self, metric_name, num_sample_per_value, total_num_samples):
+        logger.info(f"Checking the value percentiles of metric {metric_name}...")
+        processed_samples = 0
+        current_percentile = 5
+        for key in sorted(num_sample_per_value.keys()):
+            processed_samples += num_sample_per_value[key]
+            if processed_samples >= total_num_samples * current_percentile / 100.0:
+                logger.info(f"Metric {metric_name} {current_percentile}th percentile: {key}")
+                current_percentile += 5
+
+    def merge_gather_map_stats(self, num_workers, num_threads, num_threads_reduce, t_idx_reduce, metric_save_path,
+                               metric_name, return_dict):
+        results = []
+        for w_idx in range(num_workers):
+            for t_idx in range(num_threads):
+                if (w_idx * num_threads + t_idx) % num_threads_reduce == t_idx_reduce:
+                    w_metric_save_path = f"{metric_save_path}/worker{w_idx}_thread{t_idx}/"
+                    w_sample_to_metric_fname = f"{w_metric_save_path}/{metric_name}_sample_to_metric"
+                    w_sample_to_metric = MMapIndexedDataset(w_sample_to_metric_fname, skip_warmup=True)
+                    unique_v = list(np.unique(w_sample_to_metric))
+                    sample_to_metric_count = len(w_sample_to_metric)
+                    logger.info(f"Finished gathering map stats from worker {w_idx} thread {t_idx}.")
+                    results.append([unique_v, sample_to_metric_count])
+        return_dict[t_idx_reduce] = results
+
+    def merge_sample_to_metric(self, t_idx_reduce, metric_save_path, metric_name, metric_value_dtype,
+                               map_worker_thread):
+        sample_to_metric_fname = f"{metric_save_path}/{metric_name}_sample_to_metric_thread{t_idx_reduce}"
+        sample_to_metric_builder = create_mmap_dataset_builder(sample_to_metric_fname, metric_value_dtype)
+        for w_t in map_worker_thread:
+            w_metric_save_path = f"{metric_save_path}/worker{w_t[0]}_thread{w_t[1]}/"
+            w_sample_to_metric_fname = f"{w_metric_save_path}/{metric_name}_sample_to_metric"
+            w_data = MMapIndexedDataset(w_sample_to_metric_fname, skip_warmup=True)
+            for row in range(len(w_data)):
+                sample_to_metric_builder.add_item(torch.tensor(w_data[row].astype(np.int64), dtype=torch.long))
+            logger.info(f"Finished merge_sample_to_metric from worker {w_t[0]} thread {w_t[1]}.")
+        close_mmap_dataset_builder(sample_to_metric_builder, sample_to_metric_fname)
+
+    def merge_metric_to_sample(self, t_idx_reduce, metric_save_path, metric_name, sample_idx_dtype, metric_value_dtype,
+                               unique_metric_values, num_workers, num_threads):
+        index_to_sample_fname = f"{metric_save_path}/{metric_name}_index_to_sample_thread{t_idx_reduce}"
+        index_to_sample_builder = create_mmap_dataset_builder(index_to_sample_fname, sample_idx_dtype)
+        index_to_metric_fname = f"{metric_save_path}/{metric_name}_index_to_metric_thread{t_idx_reduce}"
+        index_to_metric_builder = create_mmap_dataset_builder(index_to_metric_fname, metric_value_dtype)
+        for unique_v in unique_metric_values:
+            samples = []
+            for w_idx in range(num_workers):
+                for t_idx in range(num_threads):
+                    w_metric_save_path = f"{metric_save_path}/worker{w_idx}_thread{t_idx}/"
+                    w_metric_to_sample_fname = f"{w_metric_save_path}/{metric_name}_metric_to_sample_{unique_v}.csv"
+                    if os.path.isfile(w_metric_to_sample_fname):
+                        with open(w_metric_to_sample_fname, 'r') as f:
+                            datareader = csv.reader(f)
+                            for row in datareader:
+                                samples += [int(x) for x in row]
+            index_to_sample_builder.add_item(torch.tensor(samples, dtype=torch.long))
+            index_to_metric_builder.add_item(torch.tensor([unique_v], dtype=torch.long))
+            logger.info(f"Finished reducing metric {metric_name} value {unique_v}.")
+        close_mmap_dataset_builder(index_to_sample_builder, index_to_sample_fname)
+        close_mmap_dataset_builder(index_to_metric_builder, index_to_metric_fname)
+
+    def merge_map_results(self, dataset, metric_names, metric_types, save_path, num_workers, num_threads,
+                          num_threads_reduce):
+        total_num_samples = len(dataset)
+        sample_idx_dtype = find_fit_int_dtype(0, total_num_samples - 1)
+        logger.info(
+            f"Total number of data samples: {total_num_samples}. Will use {sample_idx_dtype} to store the sample indexes."
+        )
+        for m_idx in range(len(metric_names)):
+            metric_name, metric_type = metric_names[m_idx], metric_types[m_idx]
+            if metric_type == 'single_value_per_sample':
+                metric_save_path = f"{save_path}/{metric_name}/"
+                sample_to_metric_count = 0
+                unique_metric_values = set([])
+                manager = Manager()
+                return_dict = manager.dict()
+                p = []
+                for t_idx_reduce in range(num_threads_reduce):
+                    p.append(
+                        Process(target=self.merge_gather_map_stats,
+                                args=(
+                                    num_workers,
+                                    num_threads,
+                                    num_threads_reduce,
+                                    t_idx_reduce,
+                                    metric_save_path,
+                                    metric_name,
+                                    return_dict,
+                                )))
+                    p[t_idx_reduce].start()
+                for t_idx_reduce in range(num_threads_reduce):
+                    p[t_idx_reduce].join()
+                for t_idx_reduce in range(num_threads_reduce):
+                    results = return_dict[t_idx_reduce]
+                    for res in results:
+                        unique_metric_values = unique_metric_values.union(set(res[0]))
+                        sample_to_metric_count += res[1]
+                value_max = max(unique_metric_values)
+                value_min = min(unique_metric_values)
+                assert sample_to_metric_count == total_num_samples, "The number of samples in map result files are not correct. It's possible that some map worker didn't finish successfully."
+                metric_value_dtype = find_fit_int_dtype(value_min, value_max)
+                logger.info(
+                    f"Metric {metric_name} has values between {value_min} and {value_max}. Will use {metric_value_dtype} to store the metric values."
+                )
+
+                # sample_to_metric
+                map_worker_thread = []
+                for w_idx in range(num_workers):
+                    for t_idx in range(num_threads):
+                        map_worker_thread.append([w_idx, t_idx])
+                thread_splits = split_index(0, len(map_worker_thread), num_threads_reduce)
+                p = []
+                for t_idx_reduce in range(num_threads_reduce):
+                    start_idx, end_idx = thread_splits[t_idx_reduce][0], thread_splits[t_idx_reduce][1]
+                    p.append(
+                        Process(target=self.merge_sample_to_metric,
+                                args=(
+                                    t_idx_reduce,
+                                    metric_save_path,
+                                    metric_name,
+                                    metric_value_dtype,
+                                    map_worker_thread[start_idx:end_idx],
+                                )))
+                    p[t_idx_reduce].start()
+                for t_idx_reduce in range(num_threads_reduce):
+                    p[t_idx_reduce].join()
+
+                sample_to_metric_fname = f"{metric_save_path}/{metric_name}_sample_to_metric"
+                sample_to_metric_builder = create_mmap_dataset_builder(sample_to_metric_fname, metric_value_dtype)
+                for t_idx_reduce in range(num_threads_reduce):
+                    chunk_fname = f"{metric_save_path}/{metric_name}_sample_to_metric_thread{t_idx_reduce}"
+                    logger.info(f"Merging file {chunk_fname}")
+                    sample_to_metric_builder.merge_file_(chunk_fname)
+                close_mmap_dataset_builder(sample_to_metric_builder, sample_to_metric_fname)
+                sample_to_metric = MMapIndexedDataset(sample_to_metric_fname, skip_warmup=True)
+                assert len(sample_to_metric) == total_num_samples
+
+                # metric_to_sample
+                unique_metric_values = list(sorted(unique_metric_values))
+                thread_splits = split_index(0, len(unique_metric_values), num_threads_reduce)
+                p = []
+                for t_idx_reduce in range(num_threads_reduce):
+                    start_idx, end_idx = thread_splits[t_idx_reduce][0], thread_splits[t_idx_reduce][1]
+                    p.append(
+                        Process(target=self.merge_metric_to_sample,
+                                args=(
+                                    t_idx_reduce,
+                                    metric_save_path,
+                                    metric_name,
+                                    sample_idx_dtype,
+                                    metric_value_dtype,
+                                    unique_metric_values[start_idx:end_idx],
+                                    num_workers,
+                                    num_threads,
+                                )))
+                    p[t_idx_reduce].start()
+                for t_idx_reduce in range(num_threads_reduce):
+                    p[t_idx_reduce].join()
+                index_to_sample_fname = f"{metric_save_path}/{metric_name}_index_to_sample"
+                index_to_sample_builder = create_mmap_dataset_builder(index_to_sample_fname, sample_idx_dtype)
+                index_to_metric_fname = f"{metric_save_path}/{metric_name}_index_to_metric"
+                index_to_metric_builder = create_mmap_dataset_builder(index_to_metric_fname, metric_value_dtype)
+                for t_idx_reduce in range(num_threads_reduce):
+                    chunk_is_fname = f"{metric_save_path}/{metric_name}_index_to_sample_thread{t_idx_reduce}"
+                    logger.info(f"Merging file {chunk_is_fname}")
+                    index_to_sample_builder.merge_file_(chunk_is_fname)
+                    chunk_im_fname = f"{metric_save_path}/{metric_name}_index_to_metric_thread{t_idx_reduce}"
+                    logger.info(f"Merging file {chunk_im_fname}")
+                    index_to_metric_builder.merge_file_(chunk_im_fname)
+                close_mmap_dataset_builder(index_to_sample_builder, index_to_sample_fname)
+                close_mmap_dataset_builder(index_to_metric_builder, index_to_metric_fname)
+
+                num_sample_per_value = DataAnalyzer.output_index_to_sample_percentile(
+                    index_to_sample_fname, index_to_metric_fname, metric_name, metric_save_path, total_num_samples,
+                    sample_idx_dtype)
+                self.get_metric_value_percentiles(metric_name, num_sample_per_value, total_num_samples)
+            elif metric_type == 'accumulate_value_over_samples':
+                metric_save_path = f"{save_path}/{metric_name}/"
+                metric_value = None
+                for w_idx in range(num_workers):
+                    for t_idx in range(num_threads):
+                        w_metric_save_path = f"{metric_save_path}/worker{w_idx}_thread{t_idx}/"
+                        w_metric_value_fname = f"{w_metric_save_path}/{metric_name}_metric_value"
+                        w_metric_value = MMapIndexedDataset(w_metric_value_fname, skip_warmup=True)
+                        if metric_value is None:
+                            metric_value = np.copy(w_metric_value[0])
+                        else:
+                            metric_value += np.copy(w_metric_value[0])
+                value_max = int(max(metric_value))
+                value_min = int(min(metric_value))
+                metric_value_dtype = find_fit_int_dtype(value_min, value_max)
+                metric_value_fname = f"{metric_save_path}/{metric_name}_metric_value"
+                metric_value_builder = create_mmap_dataset_builder(metric_value_fname, metric_value_dtype)
+                metric_value_builder.add_item(torch.tensor(metric_value.astype(np.int64), dtype=torch.long))
+                close_mmap_dataset_builder(metric_value_builder, metric_value_fname)
+
+    @staticmethod
+    def output_index_to_sample_percentile(index_to_sample_fname, index_to_metric_fname, metric_name, metric_save_path,
+                                          total_num_samples, sample_idx_dtype):
+        """ read index_to_metric and index_to_sample files and write distribution to index_to_sample_percentage_merged """
+        num_sample_per_value = {}
+        index_to_sample = MMapIndexedDataset(index_to_sample_fname, skip_warmup=True)
+        index_to_metric = MMapIndexedDataset(index_to_metric_fname, skip_warmup=True)
+        index_to_sample_merged_fname = f"{metric_save_path}/{metric_name}_index_to_sample_percentile_merged"
+        index_to_sample_merged_builder = create_mmap_dataset_builder(index_to_sample_merged_fname, sample_idx_dtype)
+        for v_idx in range(len(index_to_sample)):
+            if v_idx > 0:
+                assert index_to_metric[v_idx] > index_to_metric[v_idx - 1]
+            num_sample_per_value[index_to_metric[v_idx][0]] = len(index_to_sample[v_idx])
+        assert sum(list(num_sample_per_value.values())) == total_num_samples
+        merge_step = max(1, len(index_to_sample) // 100)
+        for v_idx in range(0, len(index_to_sample), merge_step):
+            merged_samples = np.copy(
+                np.concatenate(index_to_sample[v_idx:min(len(index_to_sample), (v_idx + merge_step))], axis=None))
+            index_to_sample_merged_builder.add_item(torch.tensor(merged_samples.astype(np.int64), dtype=torch.long))
+            logger.info(f"Finished merging index_to_sample {v_idx} to {v_idx+merge_step}.")
+        close_mmap_dataset_builder(index_to_sample_merged_builder, index_to_sample_merged_fname)
+        return num_sample_per_value
+
+    def run_reduce(self):
+        if self.custom_reduce is None:
+            self.merge_map_results(self.dataset, self.metric_names, self.metric_types, self.save_path,
+                                   self.num_workers, self.num_threads, self.num_threads_reduce)
+        else:
+            self.custom_reduce(self.dataset, self.metric_names, self.metric_types, self.save_path, self.num_workers,
+                               self.num_threads, self.num_threads_reduce)
+
+    def run_map_reduce(self, comm_group=None):
+        self.run_map()
+        # wait for the mapping operation, where all nodes outputs their own (partial) result files
+        dist.barrier(group=comm_group)
+        if self.worker_id == 0:
+            self.run_reduce()
+        # wait for the reduce, where rank 0 merges all (partial) files. Dataset can then be used by all nodes.
+        dist.barrier(group=comm_group)
+
+
+class DistributedDataAnalyzer(object):
+
+    def __init__(
+        self,
+        dataset,
+        num_workers=1,
+        num_threads=1,
+        worker_id=0,
+        batch_size=1,
+        metric_names=[],
+        metric_functions=[],
+        metric_types=[],
+        save_path="./",
+        collate_fn=None,
+        device='cuda',
+        comm_group=None,
+        sample_indices=None,
+    ) -> None:
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.metric_names = metric_names
+        self.metric_functions = metric_functions
+        self.metric_types = metric_types
+        self.save_path = save_path
+        self.collate_fn = collate_fn
+        self.device = device
+        self.sample_indices = sample_indices
+        self.num_threads = num_threads
+        self.worker_id = worker_id
+
+        if not dist.is_initialized():
+            dist.init_distributed()
+
+        # comm_group and worker_id+num_workers are mutually exclusive
+        self.comm_group = comm_group
+        if self.comm_group is None:
+            # self.comm_group = deepspeed.utils.groups._clone_world_group()
+            self.num_workers = num_workers
+            self.worker_id = worker_id
+        else:
+            self.num_workers = self.comm_group.size()
+            self.worker_id = self.comm_group.rank()
+
+        if self.worker_id == 0:
+            logger.info(f"Distributed data analyzer initialized with {self.num_workers} workers.")
+
+    def run_map_helper(self, thread_id=0, metric_queues=None):
+        thread_start_idx, thread_end_idx = self.thread_splits[thread_id][0], self.thread_splits[thread_id][1]
+        worker_dataset = Subset(self.dataset, list(range(thread_start_idx, thread_end_idx)))
+        sampler = BatchSampler(SequentialSampler(worker_dataset), batch_size=self.batch_size, drop_last=False)
+        dataloader = DataLoader(dataset=worker_dataset,
+                                batch_sampler=sampler,
+                                num_workers=0,
+                                collate_fn=self.collate_fn,
+                                pin_memory=False)
+
+        # set initial results list
+        metric_results = []
+        for metric_type in self.metric_types:
+            assert metric_type in ['single_value_per_sample', 'accumulate_value_over_samples'], \
+                f"metric_type {metric_type} not implemented."
+            metric_results.append([] if metric_type == 'single_value_per_sample' else None)
+
+        # iterate dataloader and store metric results
+        batch_start_idx = thread_start_idx
+        for data in dataloader:
+            for m_idx in range(len(self.metric_names)):
+                metric_type, metric_function = self.metric_types[m_idx], self.metric_functions[m_idx]
+                metric_values = metric_function(data)
+                assert torch.is_tensor(metric_values) or isinstance(metric_values, np.ndarray), \
+                    "metric_function must return a tensor or array"
+                if isinstance(metric_values, np.ndarray):
+                    metric_values = torch.from_numpy(metric_values)
+                assert metric_values.dtype in valid_dtypes, \
+                    f"metric_function result dtype {metric_values.dtype} not supported. Supported dtypes {valid_dtypes}"
+
+                if metric_type == 'single_value_per_sample':
+                    for row in range(metric_values.size()[0]):
+                        value = metric_values[row].item()
+                        sample_idx = batch_start_idx + row  # sample idx following dataset iteration order
+                        if isinstance(data, dict) and 'index' in data:  # Megatron use case
+                            sample_idx = data['index'][row][0].item()
+                        elif self.sample_indices is not None:  # user defined shuffling of indices
+                            sample_idx = self.sample_indices[sample_idx]
+                        metric_results[m_idx].append((value, sample_idx))
+                elif metric_type == 'accumulate_value_over_samples':
+                    if metric_results[m_idx] is None:
+                        metric_results[m_idx] = metric_values
+                    else:
+                        metric_results[m_idx].add_(metric_values)
+            batch_start_idx += len(data)
+
+        if self.num_threads == 1:
+            return metric_results
+
+        # copy metric_results to the shared queue
+        assert metric_queues
+        for m_idx in range(len(self.metric_names)):
+            results = metric_results[m_idx]
+            if torch.is_tensor(results):
+                results = results.item() if results.dim() == 0 else results.tolist()
+            try:
+                metric_queues[m_idx].put((thread_id, results))
+            except Exception as e:
+                logger.error(f"Error putting metric results to queue: {e}")
+                sys.exit(1)
+
+    def run_map_reduce(self):
+
+        # setup individual dataloaders
+        self.worker_splits, self.thread_splits = split_dataset(self.dataset,
+                                                               self.num_workers,
+                                                               self.worker_id,
+                                                               num_threads=self.num_threads)
+        node_start_idx, node_end_idx = self.worker_splits[self.worker_id]
+        logger.info(f"worker {self.worker_id} working on data subset {node_start_idx} to {node_end_idx}.")
+
+        if self.num_threads in [0, 1, None]:
+            metric_results = self.run_map_helper()
+            metric_results = [torch.tensor(m).to(self.device) for m in metric_results]
+        else:
+
+            # create a shared queue of results per metric to be populated by individual threads
+            with Manager() as manager:
+                metric_queues = [manager.Queue() for _ in self.metric_names]
+                threads = [
+                    Process(target=self.run_map_helper, args=(t, metric_queues)) for t in range(self.num_threads)
+                ]
+                for thread in threads:
+                    thread.start()
+                for thread in threads:
+                    thread.join()
+
+                # gather results from shared queues into metric_results
+                metric_results = [None for _ in self.metric_names]
+                for m_idx, (queue, metric_type) in enumerate(zip(metric_queues, self.metric_types)):
+                    while not queue.empty():
+                        t_idx, t_results = queue.get()
+                        t_start_idx, t_end_idx = self.thread_splits[t_idx]
+                        if t_start_idx >= t_end_idx:  # no results from this thread
+                            continue  #corner case for small datasets and high thread count
+                        t_results = torch.tensor(t_results)
+                        if metric_type == 'single_value_per_sample':
+                            # add thread results to the metric_results list, ordered by thread idx
+                            if metric_results[m_idx] is None:  # initialize if needed
+                                metric_results[m_idx] = torch.zeros(node_end_idx - node_start_idx,
+                                                                    t_results.size(1)).to(self.device)
+                            metric_results[m_idx][t_start_idx - node_start_idx:t_end_idx - node_start_idx] = t_results
+                        else:
+                            if metric_results[m_idx] is None:  # initialize if needed
+                                metric_results[m_idx] = torch.zeros(t_results.size()).to(self.device)
+                            metric_results[m_idx].add_(t_results)
+
+        # compute dtype for sample ids
+        total_num_samples = len(self.dataset)
+        sample_idx_dtype = find_fit_int_dtype(0, total_num_samples - 1)
+        logger.info(f"Total number of data samples: {total_num_samples}.")
+        logger.info(f"Will use {sample_idx_dtype} to store the sample indexes.")
+
+        for m_idx in range(len(self.metric_names)):
+            metric_values, metric_name, metric_type = \
+                metric_results[m_idx], self.metric_names[m_idx], self.metric_types[m_idx]
+            metric_save_path = f"{self.save_path}/{metric_name}/"
+            os.makedirs(metric_save_path, exist_ok=True)
+
+            if metric_type == 'single_value_per_sample':
+
+                # Compute sample and metric value dtypes based on range
+                values, samples = metric_values[:, 0], metric_values[:, 1]
+                value_min, value_max = Dist.min_max(values, self.comm_group)
+                sample_min, sample_max = Dist.min_max(samples, self.comm_group)
+                metric_value_dtype = find_fit_int_dtype(value_min, value_max)
+                sample_value_dtype = find_fit_int_dtype(sample_min, sample_max)
+
+                # sample_to_metric maps sample ids to metric values, as a list of metric values
+                sample_to_metric_fname = f"{metric_save_path}/{metric_name}_sample_to_metric"
+                values = [torch.tensor([x]) for x in metric_values[:, 0]]
+                self.file_write_ordered(values, sample_to_metric_fname, metric_value_dtype)
+
+                # distributed sorting by values, gives an ordered disjoint subset of keys on nodes
+                metric_values = Dist.sample_sort(metric_values, self.comm_group, self.num_workers)
+                metric_to_samples_dict = {}
+                if len(metric_values) > 0:
+                    for value, sample in metric_values:
+                        if value.item() not in metric_to_samples_dict:
+                            metric_to_samples_dict[value.item()] = []
+                        metric_to_samples_dict[value.item()].append(sample.item())
+
+                # index_to_metric and index_to_sample serialize a dicitonary from metric to samples
+                # index_to_metric stores a key per row, index_to_sample stores the values per row
+                values = [torch.tensor([x]) for x in metric_to_samples_dict.keys()]
+                samples = [torch.tensor(metric_to_samples_dict[x]) for x in metric_to_samples_dict.keys()]
+                index_to_metric_fname = f"{metric_save_path}/{metric_name}_index_to_metric"  #dict keys
+                index_to_sample_fname = f"{metric_save_path}/{metric_name}_index_to_sample"  #dict values
+                self.file_write_ordered(values, index_to_metric_fname, metric_value_dtype)
+                self.file_write_ordered(samples, index_to_sample_fname, sample_value_dtype)
+
+                if self.worker_id == 0:
+                    DataAnalyzer.output_index_to_sample_percentile(index_to_sample_fname, index_to_metric_fname,
+                                                                   metric_name, metric_save_path, total_num_samples,
+                                                                   sample_idx_dtype)
+                dist.barrier(self.comm_group)
+
+            elif metric_type == 'accumulate_value_over_samples':
+                metric_value_fname = f"{metric_save_path}/{metric_name}_metric_value"
+                dist.reduce(metric_values, dst=0, op=dist.ReduceOp.SUM, group=self.comm_group)
+                metric_value_dtype = find_fit_int_dtype(metric_values.min(), metric_values.max())
+
+                if self.worker_id == 0:
+                    builder = create_mmap_dataset_builder(metric_value_fname, metric_value_dtype)
+                    builder.add_item(metric_values.cpu())
+                    close_mmap_dataset_builder(builder, metric_value_fname)
+        dist.barrier(self.comm_group)
+
+    def file_write_ordered(self, tensor_list, fname, numpy_dtype):
+        """ MPI_file_write_ordered extended to write a list of tensors, by one rank, iteratively """
+
+        # each node has a list of rows (tensors) to be written to the file.
+        # we will serialize it in order to communicate it in one comm step.
+
+        tkwargs = dict(dtype=torch.int64, device=self.device)
+
+        # 1. gather on rank 0 the number of rows to be sent/recv
+        row_count = torch.tensor([len(tensor_list)], **tkwargs)
+        row_counts = torch.zeros(self.num_workers, **tkwargs)
+        dist.all_gather_into_tensor(row_counts, row_count, group=self.comm_group)
+        assert row_counts[self.worker_id] == row_count == len(tensor_list), "all_gather failed"
+
+        # 2. gather on rank 0 the sizes of the rows to be sent/recv
+        row_len = torch.tensor([len(l) for l in tensor_list], **tkwargs)
+        row_lens = Dist.gather_v(row_len, 0, self.comm_group, self.num_workers, self.worker_id)
+
+        # 4. gather on rank 0 of the total size (sum of all row lengths) to be received
+        size = torch.tensor([sum(row_len).item()], **tkwargs)
+        sizes = torch.zeros(self.num_workers, **tkwargs)
+        dist.all_gather_into_tensor(sizes, size, group=self.comm_group)
+        assert sizes[self.worker_id] == size.item(), "all_gather did not return the same sizes"  #sanity check
+
+        # method to deserializes a buffer into rows of different lengths and write them to file
+        def write_buffer_to_file(buff, src, builder):
+            assert self.worker_id == 0, "only rank 0 can write to file"
+
+            # collect all buffers and write them at once
+            buff = buff.cpu().detach().numpy()
+            row_offsets = np.cumsum([0] + row_lens[src].tolist())
+            arr_list = []
+            for i in range(len(row_lens[src])):
+                arr_list.append(buff[row_offsets[i]:row_offsets[i + 1]])
+            builder.add_items(arr_list)
+
+        # 5. rank 0 prepares output folder and file
+        if self.worker_id == 0:
+            os.makedirs(os.path.dirname(fname), exist_ok=True)
+            builder = create_mmap_dataset_builder(fname, numpy_dtype)
+
+        # iterate through ranks that have data to be sent/recv/written
+        for src in [rank for rank, count in enumerate(row_counts) if count > 0]:
+
+            dist.barrier(group=self.comm_group)
+            if self.worker_id == 0 and src == 0:  # rank 0's write its own data
+                buffer = torch.cat(tensor_list, dim=0).to(self.device)
+                write_buffer_to_file(buffer, 0, builder)
+            elif self.worker_id == 0 and src > 0:  # rank 0 receives other rank's data and writes it
+                buffer = torch.empty(sizes[src].item(), dtype=buffer.dtype, device=buffer.device)
+                err = dist.recv(buffer, src=src, group=self.comm_group, tag=src)
+                assert err == src and len(buffer) > 0, "recv failed"
+                write_buffer_to_file(buffer, src, builder)
+            elif self.worker_id == src:  # current rank sends data to rank 0
+                buffer = torch.cat(tensor_list, dim=0).to(self.device)
+                dist.send(buffer, 0, group=self.comm_group, tag=src)
+
+        # rank 0 closes the file
+        if self.worker_id == 0:
+            close_mmap_dataset_builder(builder, fname)  # close file
+        dist.barrier(self.comm_group)
+
+
+class Dist:
+    """ auxiliary class to perform distributed operations on tensors"""
+
+    @staticmethod
+    def min_max(tensor, comm_group):
+        """ given a distributed tensor, return the min/max values across all ranks"""
+
+        value_min, value_max = tensor.min(), tensor.max()
+        dist.reduce(value_min, 0, op=dist.ReduceOp.MIN, group=comm_group)
+        dist.reduce(value_max, 0, op=dist.ReduceOp.MAX, group=comm_group)
+        return value_min.item(), value_max.item()
+
+    @staticmethod
+    def gather_v(tensor, dst, comm_group, num_workers, worker_id):
+        """ MPI_Gatherv. gather tensors of variable sizes in a single rank """
+
+        # gather the number of rows to be sent/recv
+        size = torch.tensor([len(tensor)], dtype=torch.int64, device=tensor.device)
+        sizes = torch.zeros(num_workers, dtype=torch.int64, device=tensor.device)
+        dist.all_gather_into_tensor(sizes, size, group=comm_group)
+        assert sizes[worker_id] == size, "all_gather failed"
+
+        # all_gather requires all tensors to be of same size so we need to pad them
+        max_size = max(sizes).item()
+        buffer = torch.empty(max_size, dtype=tensor.dtype, device=tensor.device)
+        buffer[0:size] = tensor.data
+        buffer_list = None
+        if worker_id == 0:  # create padded recv buffers
+            buffer_list = [torch.empty(max_size, dtype=tensor.dtype, device=tensor.device) for _ in range(num_workers)]
+        dist.gather(buffer, buffer_list, dst=dst, group=comm_group)
+
+        # revert padding and return value
+        if worker_id == 0:
+            buffer_list = [r[:s.item()] for r, s in zip(buffer_list, sizes)]
+        return buffer_list
+
+    @staticmethod
+    def sample_sort(tensor, comm_group, num_workers, n_samples=100):
+        """ perform a distributed random sort of a tensor, and returns the sorted partial tensor"""
+        device, dims = tensor.device, tensor.size()[1]
+
+        # 1 - sort rows by first column, then second column, then third, etc...
+        tensor = torch.tensor(sorted(tensor.tolist()), dtype=tensor.dtype, device=tensor.device)
+
+        # 2 - collect few samples per rank
+        idx = torch.round(torch.linspace(0, len(tensor) - 1, n_samples)).to(int)
+        samples = tensor[idx][:, 0].contiguous().to(device)  #only first column, all but last row
+
+        # 2 - Allgather samples
+        all_samples = [torch.zeros(n_samples, dtype=samples.dtype, device=device) for _ in range(num_workers)]
+        dist.all_gather(all_samples, samples, group=comm_group)
+        all_samples = torch.cat(all_samples, dim=0).to(device)
+
+        # 3 - Sort all samples and collect the ranges of each rank as equidistant
+        all_samples = all_samples.sort()[0]
+        idx = torch.round(torch.linspace(0, len(all_samples) - 1, num_workers + 1)).to(int)
+        ranges = all_samples[idx]  # range of each rank r as ranges[r] <= x < ranges[r+1]
+        ranges[-1] += 1  # increase upper limit of last rank so that x < ranges[r+1].
+
+        # 4 - collect elements to send to each rank, based on the rank ranges
+        send = []
+        for rank in range(num_workers):
+            mask = (tensor[:, 0] >= ranges[rank]) & (tensor[:, 0] < ranges[rank + 1])
+            send.append(tensor[mask])
+
+        # 5. all to all to communicate the sizes to be sent/recv
+        send_count = [torch.tensor([len(s) * dims], dtype=torch.int64, device=device) for s in send]
+        recv_count = list(torch.empty([num_workers], dtype=torch.int64, device=device).chunk(num_workers))
+        dist.all_to_all(recv_count, send_count, group=comm_group)
+
+        # 6. all-to-all-v to communicate the elements to be sent/recv as a single tensor
+        send = torch.cat(send, dim=0).flatten().to(device)
+        recv = torch.zeros(sum(recv_count), dtype=send.dtype).to(device)
+        send_count = [s.item() for s in send_count]  # convert to list of ints
+        recv_count = [r.item() for r in recv_count]
+        dist.all_to_all_single(recv, send, recv_count, send_count, group=comm_group)
+        del send
+
+        # 7. the received tensor is the 1D disjoint subset of the distributed tensor.
+        # We will recover the original dimensionality and sort it by columns again.
+        recv = recv.view(-1, dims)
+        recv = torch.tensor(sorted(recv.tolist()), dtype=recv.dtype, device=recv.device)
+        return recv
+
+
+def test_compare_both_data_analyzers(dataset):
+    """ given a dataset, compare file and memory based data analyser"""
+
+    id = lambda t: t.to(torch.int64)  # identity
+    batch_sum = lambda t: id(t).sum()  #sum batch
+    num_threads = 4
+    kwargs = dict(
+        dataset=dataset,
+        batch_size=2**10,
+        worker_id=int(os.environ['RANK']),
+        num_workers=int(os.environ['WORLD_SIZE']),
+        metric_names=["mod", "batch_sum"],
+        metric_functions=[id, batch_sum],
+        metric_types=['single_value_per_sample', 'accumulate_value_over_samples'],
+        num_threads=num_threads,
+    )
+
+    dda = DistributedDataAnalyzer(
+        save_path="./output_dist",
+        device=f"cuda:{int(os.environ['LOCAL_RANK'])}",
+        **kwargs,
+    )
+    start_time = time.time()
+    dda.run_map_reduce()
+    if dda.worker_id == 0:
+        print("DistributedDataAnalyzer runtime: %s seconds " % (time.time() - start_time))
+
+    da = DataAnalyzer(num_threads_reduce=num_threads,
+                      save_path="./output_disk",
+                      metric_dtypes=[torch.int64, torch.int64],
+                      **kwargs)
+    start_time = time.time()
+    da.run_map_reduce()
+    if da.worker_id == 0:
+        print("DataAnalyzer runtime: %s seconds " % (time.time() - start_time))
+
+    output_paths = [
+        "batch_sum/batch_sum_metric_value.bin", "batch_sum/batch_sum_metric_value.idx", \
+        "mod/mod_index_to_metric.bin", "mod/mod_index_to_metric.idx", \
+        "mod/mod_index_to_sample.bin", "mod/mod_index_to_sample.idx", \
+        "mod/mod_index_to_sample_percentile_merged.bin", "mod/mod_index_to_sample_percentile_merged.idx", \
+        "mod/mod_sample_to_metric.bin", "mod/mod_sample_to_metric.idx"
+    ]
+
+    if dda.worker_id == 0:
+        for path in output_paths:
+            with open(os.path.join(da.save_path, path), 'rb') as f1, \
+                open(os.path.join(dda.save_path, path), 'rb') as f2:
+                if f1.read() != f2.read():
+                    print(f"files {path} are not identical.")
+
+
+if __name__ == "__main__":
+
+    class TestDataset(torch.utils.data.Dataset):
+
+        def __init__(self, size=10_000_000):
+            self.values = [(x + 7) % 10_000 for x in range(size)]
+            self.size = size
+
+        __len__ = lambda self: self.size
+        __getitem__ = lambda self, idx: self.values[idx]
+
+    test_compare_both_data_analyzers(TestDataset())

venv/lib/python3.10/site-packages/deepspeed/runtime/data_pipeline/data_sampling/data_sampler.py

@@ -0,0 +1,349 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""
+coding=utf-8
+ Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+
+ 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.
+Part of this code was adopted from https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/data/data_samplers.py
+"""
+
+import torch
+import os
+import numpy as np
+
+import deepspeed.comm as dist
+from deepspeed.utils import logger
+from deepspeed.accelerator import get_accelerator
+from ..constants import *
+from ..curriculum_scheduler import CurriculumScheduler
+from .indexed_dataset import MMapIndexedDataset
+from .utils import create_mmap_dataset_builder, close_mmap_dataset_builder, find_fit_int_dtype
+
+
+class DeepSpeedDataSampler(object):
+
+    def __init__(self,
+                 data_efficiency_config,
+                 one_epoch_total_samples,
+                 micro_batch_size,
+                 data_parallel_rank,
+                 data_parallel_size,
+                 data_parallel_group,
+                 gradient_accumulation_steps,
+                 global_rank,
+                 drop_last=True):
+        # Keep a copy of input params for later use.
+        self.data_efficiency_config = data_efficiency_config
+        self.one_epoch_total_samples = one_epoch_total_samples
+        self.index_dtype = find_fit_int_dtype(0, one_epoch_total_samples)
+        self.total_samples = one_epoch_total_samples * self.data_efficiency_config[DATA_SAMPLING][
+            DATA_SAMPLING_NUM_EPOCHS]
+        self.micro_batch_size = micro_batch_size
+        self.data_parallel_rank = data_parallel_rank
+        self.data_parallel_group = data_parallel_group
+        self.micro_batch_times_data_parallel_size = \
+            self.micro_batch_size * data_parallel_size
+        self.gradient_accumulation_steps = gradient_accumulation_steps
+        self.global_batch_size = self.micro_batch_times_data_parallel_size * \
+            self.gradient_accumulation_steps
+        self.global_rank = global_rank
+        self.drop_last = drop_last
+        self.np_rng = np.random.default_rng(self.data_efficiency_config[DATA_EFFICIENCY_SEED])
+        self.state = {}
+        self.batch = []
+        self.consumed_samples = 0
+        if self.data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][CURRICULUM_LEARNING_ENABLED]:
+            self.curriculum_step = 0
+            self.current_difficulties = {}
+            self.data_cluster_paths = []
+            self.data_cluster_current_position = []
+            self.curriculum_schedulers = {}
+            self.curriculum_index_to_sample = {}
+            self.curriculum_index_to_metric = {}
+            self.difficulty_type = {}
+            self.clustering_type = {}
+            self.data_1epoch_size = None
+            if self.global_rank == 0:
+                self.data_clusters = []
+                self.data_cluster_sizes = []
+                cluster_path = self.data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][
+                    CURRICULUM_LEARNING_CLUSTER_PATH]
+                if not os.path.exists(cluster_path):
+                    os.makedirs(cluster_path)
+            for metric in self.data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][CURRICULUM_LEARNING_METRICS]:
+                self.curriculum_schedulers[metric] = CurriculumScheduler(
+                    data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][CURRICULUM_LEARNING_METRICS][metric])
+                self.difficulty_type[metric] = data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][
+                    CURRICULUM_LEARNING_METRICS][metric][CURRICULUM_LEARNING_DIFFICULTY_TYPE]
+                self.clustering_type[metric] = data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][
+                    CURRICULUM_LEARNING_METRICS][metric][CURRICULUM_LEARNING_CLUSTERING_TYPE]
+                if self.global_rank == 0:
+                    if self.clustering_type[metric] != CURRICULUM_LEARNING_SINGLE_CLUSTER:
+                        self.curriculum_index_to_sample[metric] = MMapIndexedDataset(
+                            data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][CURRICULUM_LEARNING_METRICS]
+                            [metric][CURRICULUM_LEARNING_SAMPLE_PATH],
+                            skip_warmup=True)
+                        if self.difficulty_type[metric] == CURRICULUM_LEARNING_VALUE_BASED:
+                            self.curriculum_index_to_metric[metric] = MMapIndexedDataset(
+                                data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][CURRICULUM_LEARNING_METRICS]
+                                [metric][CURRICULUM_LEARNING_METRIC_PATH],
+                                skip_warmup=True)
+
+        # Sanity checks.
+        assert self.total_samples > 0, \
+            'no sample to consume: {}'.format(self.total_samples)
+        assert self.micro_batch_size > 0
+        assert data_parallel_size > 0
+        assert self.data_parallel_rank < data_parallel_size, \
+            'data_parallel_rank should be smaller than data size: {}, ' \
+            '{}'.format(self.data_parallel_rank, data_parallel_size)
+
+    def __len__(self):
+        return self.total_samples
+
+    def set_custom_curriculum_learning_schedule(self, schedule_func_dict):
+        for metric in self.curriculum_schedulers:
+            if metric in schedule_func_dict:
+                self.curriculum_schedulers[metric].set_custom_get_difficulty(schedule_func_dict[metric])
+
+    def get_start_end_idx(self, batch_len=None):
+        """
+        given the length of a minibatch (defaults to micro-batch size * data_parallel_size),
+        return the start and end indices of the current data parallel rank
+        """
+        batch_len = batch_len or self.micro_batch_times_data_parallel_size
+        start_idx_fn = lambda r: round(r * batch_len / self.data_parallel_group.size())
+        start_idx = start_idx_fn(self.data_parallel_rank)
+        end_idx = start_idx_fn(self.data_parallel_rank + 1)
+        return start_idx, end_idx
+
+    def get_sample_based_on_metric_value(self, metric, value_start, value_end):
+        new_samples = None
+        for row in range(len(self.curriculum_index_to_sample[metric])):
+            if self.curriculum_index_to_metric[metric][row] <= value_end and self.curriculum_index_to_metric[metric][
+                    row] > value_start:
+                row_samples = np.copy(self.curriculum_index_to_sample[metric][row])
+                new_samples = row_samples if new_samples is None else np.concatenate(
+                    (new_samples, row_samples), axis=None)
+        return new_samples
+
+    def get_sample_based_on_metric_percentile(self, metric, percentile_start, percentile_end):
+        new_samples = None
+        if self.data_1epoch_size is None:
+            self.data_1epoch_size = sum(len(x) for x in self.curriculum_index_to_sample[metric])
+        max_percentile = self.data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][CURRICULUM_LEARNING_METRICS][
+            metric][CURRICULUM_LEARNING_MAX_DIFFICULTY]
+        sample_per_percentile = self.data_1epoch_size // max_percentile
+        start_count = sample_per_percentile * percentile_start
+        end_count = sample_per_percentile * percentile_end
+        if percentile_end == max_percentile:
+            end_count = self.data_1epoch_size
+        current_count = 0
+        for row in range(len(self.curriculum_index_to_sample[metric])):
+            row_size = len(self.curriculum_index_to_sample[metric][row])
+            if current_count + row_size > start_count:
+                row_start = max(0, start_count - current_count)
+                if current_count + row_size <= end_count:
+                    row_end = row_size
+                else:
+                    row_end = end_count - current_count
+                row_samples = np.copy(self.curriculum_index_to_sample[metric][row][row_start:row_end])
+                new_samples = row_samples if new_samples is None else np.concatenate(
+                    (new_samples, row_samples), axis=None)
+            current_count += row_size
+            if current_count >= end_count:
+                break
+        return new_samples
+
+    def get_new_cluster(self, previous_difficulties):
+        cluster_fname = CURRICULUM_LEARNING_CLUSTER_PREFIX
+        for metric in self.curriculum_schedulers:
+            cluster_fname = f"{cluster_fname}_{metric}{self.current_difficulties[metric]}"
+        cluster_path = self.data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][
+            CURRICULUM_LEARNING_CLUSTER_PATH]
+        cluster_path = f"{cluster_path}/{cluster_fname}"
+        if self.global_rank == 0:
+            new_cluster = None
+            need_clustering = 0
+            for metric in self.clustering_type:
+                if self.clustering_type[metric] != CURRICULUM_LEARNING_SINGLE_CLUSTER:
+                    need_clustering += 1
+            if need_clustering > 1:
+                for metric in self.curriculum_schedulers:
+                    if self.clustering_type[metric] == CURRICULUM_LEARNING_SINGLE_CLUSTER:
+                        metric_cluster = np.arange(start=0,
+                                                   stop=self.one_epoch_total_samples,
+                                                   step=1,
+                                                   dtype=self.index_dtype)
+                    else:
+                        if self.difficulty_type[metric] == CURRICULUM_LEARNING_VALUE_BASED:
+                            metric_cluster = self.get_sample_based_on_metric_value(metric, float('-inf'),
+                                                                                   self.current_difficulties[metric])
+                        elif self.difficulty_type[metric] == CURRICULUM_LEARNING_PERCENTILE_BASED:
+                            metric_cluster = self.get_sample_based_on_metric_percentile(
+                                metric, 0, self.current_difficulties[metric])
+                    new_cluster = metric_cluster if new_cluster is None else \
+                        np.intersect1d(new_cluster, metric_cluster, assume_unique=True)
+                for cluster in self.data_clusters:
+                    new_cluster = np.setdiff1d(new_cluster, cluster[0], assume_unique=True)
+            else:
+                if len(self.data_clusters) == 0:
+                    new_cluster = np.arange(start=0, stop=self.one_epoch_total_samples, step=1, dtype=self.index_dtype)
+                for metric in self.curriculum_schedulers:
+                    if self.clustering_type[metric] != CURRICULUM_LEARNING_SINGLE_CLUSTER:
+                        if self.difficulty_type[metric] == CURRICULUM_LEARNING_VALUE_BASED:
+                            new_cluster = self.get_sample_based_on_metric_value(metric, previous_difficulties[metric],
+                                                                                self.current_difficulties[metric])
+                        elif self.difficulty_type[metric] == CURRICULUM_LEARNING_PERCENTILE_BASED:
+                            new_cluster = self.get_sample_based_on_metric_percentile(
+                                metric, previous_difficulties[metric], self.current_difficulties[metric])
+            if new_cluster is not None and len(new_cluster) > 0:
+                logger.info(
+                    f"new data cluster (previous_difficulties {previous_difficulties}, current_difficulties {self.current_difficulties}) with size {len(new_cluster)} generated."
+                )
+                self.np_rng.shuffle(new_cluster)
+                cluster_builder = create_mmap_dataset_builder(cluster_path, self.index_dtype)
+                cluster_builder.add_item_numpy(new_cluster)
+                close_mmap_dataset_builder(cluster_builder, cluster_path)
+                self.data_clusters.append(MMapIndexedDataset(cluster_path, skip_warmup=True))
+                self.data_cluster_sizes.append(len(self.data_clusters[-1][0]))
+            else:
+                logger.info(
+                    f"new data cluster (previous_difficulties {previous_difficulties}, current_difficulties {self.current_difficulties}) has no matched data thus skipped."
+                )
+        dist.barrier(group=self.data_parallel_group)
+        if os.path.isfile(f"{cluster_path}.bin"):
+            self.data_cluster_paths.append(cluster_fname)
+            self.data_cluster_current_position.append(0)
+
+    def sample_from_clusters(self):
+        num_clusters = len(self.data_clusters)
+        weight_sum = sum(self.data_cluster_sizes)
+        weights = [x / weight_sum for x in self.data_cluster_sizes]
+        samples = self.np_rng.choice(num_clusters, self.global_batch_size, replace=True, p=weights)
+        samples = np.bincount(samples, minlength=num_clusters)
+        return samples
+
+    def reshuffle_clusters(self, cidx):
+        cluster_fname = self.data_cluster_paths[cidx]
+        cluster_path = self.data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][
+            CURRICULUM_LEARNING_CLUSTER_PATH]
+        cluster_path = f"{cluster_path}/{cluster_fname}"
+        cluster = np.copy(self.data_clusters[cidx][0])
+        self.np_rng.shuffle(cluster)
+        cluster_builder = create_mmap_dataset_builder(cluster_path, self.index_dtype)
+        cluster_builder.add_item_numpy(cluster)
+        close_mmap_dataset_builder(cluster_builder, cluster_path)
+        self.data_clusters[cidx] = MMapIndexedDataset(cluster_path, skip_warmup=True)
+
+    def get_sample_from_cluster(self, cidx, num_samples):
+        start_idx = self.data_cluster_current_position[cidx]
+        samples = list(np.copy(self.data_clusters[cidx][0][start_idx:(start_idx + num_samples)]))
+        self.data_cluster_current_position[cidx] += num_samples
+        if len(samples) < num_samples:
+            num_samples_remained = num_samples - len(samples)
+            logger.info(f"reshuffling cluster {cidx}.")
+            self.reshuffle_clusters(cidx)
+            samples += list(np.copy(self.data_clusters[cidx][0][:num_samples_remained]))
+            self.data_cluster_current_position[cidx] = num_samples_remained
+        return samples
+
+    def get_next_global_batch(self):
+        if self.data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][CURRICULUM_LEARNING_ENABLED]:
+            self.curriculum_step += 1
+            new_cluster = False
+            previous_difficulties = {}
+            for metric in self.curriculum_schedulers:
+                next_difficulty = self.curriculum_schedulers[metric].update_difficulty(self.curriculum_step)
+                if metric not in self.current_difficulties or \
+                    next_difficulty != self.current_difficulties[metric]:
+                    new_cluster = True
+                if metric in self.current_difficulties:
+                    previous_difficulties[metric] = self.current_difficulties[metric]
+                else:
+                    if self.difficulty_type[metric] == CURRICULUM_LEARNING_VALUE_BASED:
+                        previous_difficulties[metric] = float('-inf')
+                    elif self.difficulty_type[metric] == CURRICULUM_LEARNING_PERCENTILE_BASED:
+                        previous_difficulties[metric] = 0
+                self.current_difficulties[metric] = next_difficulty
+            if new_cluster:
+                self.get_new_cluster(previous_difficulties)
+            if self.global_rank == 0:
+                samples_per_cluster = self.sample_from_clusters()
+                batch = []
+                for cidx in range(len(samples_per_cluster)):
+                    batch += self.get_sample_from_cluster(cidx, samples_per_cluster[cidx])
+                self.np_rng.shuffle(batch)
+
+                # broadcast tensor must have same shape across participants. So we fill batch with -1s when not full
+                assert len(batch) <= self.global_batch_size
+                batch += [-1] * (self.global_batch_size - len(batch))
+                batch = torch.tensor(batch, device=get_accelerator().current_device_name(), dtype=torch.long).view(-1)
+            else:
+                batch = torch.empty(self.global_batch_size,
+                                    device=get_accelerator().current_device_name(),
+                                    dtype=torch.long)
+            dist.broadcast(batch, 0, group=self.data_parallel_group)
+            batch = batch[batch != -1]  # remove trailing -1s used to fill incomplete batch tensor
+            self.batch = batch.tolist()
+
+    def __iter__(self):
+        while self.consumed_samples <= self.total_samples:
+            if len(self.batch) == 0:
+                self.get_next_global_batch()
+            current_batch = self.batch[:self.micro_batch_times_data_parallel_size]
+            self.batch = self.batch[self.micro_batch_times_data_parallel_size:]
+            if len(current_batch) == self.micro_batch_times_data_parallel_size or \
+                (len(current_batch) > 0 and not self.drop_last):
+                start_idx, end_idx = self.get_start_end_idx(len(current_batch))
+                yield current_batch[start_idx:end_idx]
+                self.consumed_samples += len(current_batch)
+                current_batch = []
+
+    def state_dict(self):
+        return {
+            CURRICULUM_LEARNING_BATCH: self.batch,
+            CURRICULUM_LEARNING_CONSUMED_SAMPLES: self.consumed_samples,
+            CURRICULUM_LEARNING_STEP: self.curriculum_step,
+            CURRICULUM_LEARNING_CURRENT_DIFFICULTIES: self.current_difficulties,
+            CURRICULUM_LEARNING_DATA_CLUSTER_PATHS: self.data_cluster_paths,
+            CURRICULUM_LEARNING_DATA_CLUSTER_CURRENT_POSITION: self.data_cluster_current_position,
+            CURRICULUM_LEARNING_NP_RNG_STATE: np.random.get_state()
+        }
+
+    def load_state_dict(self, state_dict):
+        self.batch = state_dict[CURRICULUM_LEARNING_BATCH]
+        self.consumed_samples = state_dict[CURRICULUM_LEARNING_CONSUMED_SAMPLES]
+        self.curriculum_step = state_dict[CURRICULUM_LEARNING_STEP]
+        self.current_difficulties = state_dict[CURRICULUM_LEARNING_CURRENT_DIFFICULTIES]
+        self.data_cluster_paths = state_dict[CURRICULUM_LEARNING_DATA_CLUSTER_PATHS]
+        self.data_cluster_current_position = state_dict[CURRICULUM_LEARNING_DATA_CLUSTER_CURRENT_POSITION]
+        np.random.set_state(state_dict[CURRICULUM_LEARNING_NP_RNG_STATE])
+        cluster_root_path = self.data_efficiency_config[DATA_SAMPLING][CURRICULUM_LEARNING][
+            CURRICULUM_LEARNING_CLUSTER_PATH]
+        # Backward compatibility: previously data_cluster_paths were stored as
+        # absolute paths. Now we changed it to just the file name so that even
+        # if user moved the cluster files, the checkpoint loading still works
+        # as long as user set the correct new CURRICULUM_LEARNING_CLUSTER_PATH
+        # in deepspeed json config.
+        for idx in range(len(self.data_cluster_paths)):
+            if '/' in self.data_cluster_paths[idx]:
+                self.data_cluster_paths[idx] = self.data_cluster_paths[idx].split('/')[-1]
+        if self.global_rank == 0:
+            for cluster_fname in self.data_cluster_paths:
+                cluster_path = f"{cluster_root_path}/{cluster_fname}"
+                self.data_clusters.append(MMapIndexedDataset(cluster_path, skip_warmup=True))
+                self.data_cluster_sizes.append(len(self.data_clusters[-1][0]))

venv/lib/python3.10/site-packages/deepspeed/runtime/data_pipeline/data_sampling/indexed_dataset.py

@@ -0,0 +1,627 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""
+Part of this code was adopted from https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/data/indexed_dataset.py
+"""
+
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+# copied from fairseq/fairseq/data/indexed_dataset.py
+# Removed IndexedRawTextDataset since it relied on Fairseq dictionary
+# other slight modifications to remove fairseq dependencies
+# Added document index to index file and made it accessible.
+#    An empty sentence no longer separates documents.
+
+# Some of the fixes/improvements are adopted from
+# https://github.com/bigscience-workshop/Megatron-DeepSpeed/blob/main/megatron/data/indexed_dataset.py
+
+from functools import lru_cache
+import os
+import shutil
+import struct
+from itertools import accumulate
+
+import numpy as np
+import torch
+
+
+def __best_fitting_dtype(vocab_size=None):
+    if vocab_size is not None and vocab_size < 65500:
+        return np.uint16
+    else:
+        return np.int32
+
+
+def get_available_dataset_impl():
+    return ['lazy', 'cached', 'mmap']
+
+
+def infer_dataset_impl(path):
+    if IndexedDataset.exists(path):
+        with open(index_file_path(path), 'rb') as f:
+            magic = f.read(8)
+            if magic == IndexedDataset._HDR_MAGIC:
+                return 'cached'
+            elif magic == MMapIndexedDataset.Index._HDR_MAGIC[:8]:
+                return 'mmap'
+            else:
+                return None
+    else:
+        print(f"Dataset does not exist: {path}")
+        print("Path should be a basename that both .idx and .bin can be appended to get full filenames.")
+        return None
+
+
+def make_builder(out_file, impl, vocab_size=None):
+    if impl == 'mmap':
+        return MMapIndexedDatasetBuilder(out_file, dtype=__best_fitting_dtype(vocab_size))
+    else:
+        return IndexedDatasetBuilder(out_file)
+
+
+def make_dataset(path, impl, skip_warmup=False):
+    if not IndexedDataset.exists(path):
+        print(f"Dataset does not exist: {path}")
+        print("Path should be a basename that both .idx and .bin can be appended to get full filenames.")
+        return None
+    if impl == 'infer':
+        impl = infer_dataset_impl(path)
+    if impl == 'lazy' and IndexedDataset.exists(path):
+        return IndexedDataset(path)
+    elif impl == 'cached' and IndexedDataset.exists(path):
+        return IndexedCachedDataset(path)
+    elif impl == 'mmap' and MMapIndexedDataset.exists(path):
+        return MMapIndexedDataset(path, skip_warmup)
+    print(f"Unknown dataset implementation: {impl}")
+    return None
+
+
+def dataset_exists(path, impl):
+    if impl == 'mmap':
+        return MMapIndexedDataset.exists(path)
+    else:
+        return IndexedDataset.exists(path)
+
+
+def read_longs(f, n):
+    a = np.empty(n, dtype=np.int64)
+    f.readinto(a)
+    return a
+
+
+def write_longs(f, a):
+    f.write(np.array(a, dtype=np.int64))
+
+
+# valid metric_dtypes as numpy and torch types
+dtypes = {
+    1: (np.uint8, torch.uint8),
+    2: (np.int8, torch.int8),
+    3: (np.int16, torch.int16),
+    4: (np.int32, torch.int32),
+    5: (np.int64, torch.int64),
+    6: (np.uint16, None),
+    7: (np.uint32, None),
+    8: (np.uint64, None),
+}
+
+valid_dtypes = set([dt[0] for dt in dtypes.values()] + [dt[1] for dt in dtypes.values() if dt[1] is not None])
+
+
+def code(dtype):
+    for c, (np_dt, torch_dt) in dtypes.items():
+        if dtype in [np_dt, torch_dt]:
+            return c
+    raise ValueError(f"{dtype} not supported. Supported types: {valid_dtypes}")
+
+
+def index_file_path(prefix_path):
+    return prefix_path + '.idx'
+
+
+def data_file_path(prefix_path):
+    return prefix_path + '.bin'
+
+
+def create_doc_idx(sizes):
+    doc_idx = [0]
+    for i, s in enumerate(sizes):
+        if s == 0:
+            doc_idx.append(i + 1)
+    return doc_idx
+
+
+class IndexedDataset(torch.utils.data.Dataset):
+    """Loader for IndexedDataset"""
+    _HDR_MAGIC = b'TNTIDX\x00\x00'
+
+    def __init__(self, path):
+        super().__init__()
+        self.path = path
+        self.data_file = None
+        self.read_index(path)
+
+    def read_index(self, path):
+        with open(index_file_path(path), 'rb') as f:
+            magic = f.read(8)
+            assert magic == self._HDR_MAGIC, ('Index file doesn\'t match expected format. '
+                                              'Make sure that --dataset-impl is configured properly.')
+            version = f.read(8)
+            assert struct.unpack('<Q', version) == (1, )
+            code, self.element_size = struct.unpack('<QQ', f.read(16))
+            self.dtype = dtypes[code][0]  #numpy type
+            self._len, self.s = struct.unpack('<QQ', f.read(16))
+            self.doc_count = struct.unpack('<Q', f.read(8))
+            self.dim_offsets = read_longs(f, self._len + 1)
+            self.data_offsets = read_longs(f, self._len + 1)
+            self.sizes = read_longs(f, self.s)
+            self.doc_idx = read_longs(f, self.doc_count)
+
+    def read_data(self, path):
+        self.data_file = open(data_file_path(path), 'rb', buffering=0)
+
+    def check_index(self, i):
+        if i < 0 or i >= self._len:
+            raise IndexError('index out of range')
+
+    def __del__(self):
+        if self.data_file:
+            self.data_file.close()
+
+    # @lru_cache(maxsize=8)
+    def __getitem__(self, idx):
+        if not self.data_file:
+            self.read_data(self.path)
+        if isinstance(idx, int):
+            i = idx
+            self.check_index(i)
+            tensor_size = self.sizes[self.dim_offsets[i]:self.dim_offsets[i + 1]]
+            a = np.empty(tensor_size, dtype=self.dtype)
+            self.data_file.seek(self.data_offsets[i] * self.element_size)
+            self.data_file.readinto(a)
+            return a
+        elif isinstance(idx, slice):
+            start, stop, step = idx.indices(len(self))
+            if step != 1:
+                raise ValueError("Slices into indexed_dataset must be contiguous")
+            sizes = self.sizes[self.dim_offsets[start]:self.dim_offsets[stop]]
+            size = sum(sizes)
+            a = np.empty(size, dtype=self.dtype)
+            self.data_file.seek(self.data_offsets[start] * self.element_size)
+            self.data_file.readinto(a)
+            offsets = list(accumulate(sizes))
+            sents = np.split(a, offsets[:-1])
+            return sents
+
+    def __len__(self):
+        return self._len
+
+    def num_tokens(self, index):
+        return self.sizes[index]
+
+    def size(self, index):
+        return self.sizes[index]
+
+    @staticmethod
+    def exists(path):
+        return (os.path.exists(index_file_path(path)) and os.path.exists(data_file_path(path)))
+
+    @property
+    def supports_prefetch(self):
+        return False  # avoid prefetching to save memory
+
+
+class IndexedCachedDataset(IndexedDataset):
+
+    def __init__(self, path):
+        super().__init__(path)
+        self.cache = None
+        self.cache_index = {}
+
+    @property
+    def supports_prefetch(self):
+        return True
+
+    def prefetch(self, indices):
+        if all(i in self.cache_index for i in indices):
+            return
+        if not self.data_file:
+            self.read_data(self.path)
+        indices = sorted(set(indices))
+        total_size = 0
+        for i in indices:
+            total_size += self.data_offsets[i + 1] - self.data_offsets[i]
+        self.cache = np.empty(total_size, dtype=self.dtype)
+        ptx = 0
+        self.cache_index.clear()
+        for i in indices:
+            self.cache_index[i] = ptx
+            size = self.data_offsets[i + 1] - self.data_offsets[i]
+            a = self.cache[ptx:ptx + size]
+            self.data_file.seek(self.data_offsets[i] * self.element_size)
+            self.data_file.readinto(a)
+            ptx += size
+        if self.data_file:
+            # close and delete data file after prefetch so we can pickle
+            self.data_file.close()
+            self.data_file = None
+
+    # @lru_cache(maxsize=8)
+    def __getitem__(self, idx):
+        if isinstance(idx, int):
+            i = idx
+            self.check_index(i)
+            tensor_size = self.sizes[self.dim_offsets[i]:self.dim_offsets[i + 1]]
+            a = np.empty(tensor_size, dtype=self.dtype)
+            ptx = self.cache_index[i]
+            np.copyto(a, self.cache[ptx:ptx + a.size])
+            return a
+        elif isinstance(idx, slice):
+            # Hack just to make this work, can optimizer later if necessary
+            sents = []
+            for i in range(*idx.indices(len(self))):
+                sents.append(self[i])
+            return sents
+
+
+class IndexedDatasetBuilder(object):
+
+    def __init__(self, out_file, dtype=np.int32):
+        self.out_file = open(out_file, 'wb')
+        self.dtype = dtype
+        self.data_offsets = [0]
+        self.dim_offsets = [0]
+        self.sizes = []
+        self.element_size = self.dtype().itemsize
+        self.doc_idx = [0]
+
+    def add_item(self, tensor):
+        bytes = self.out_file.write(np.array(tensor.numpy(), dtype=self.dtype))
+        self.data_offsets.append(self.data_offsets[-1] + bytes / self.element_size)
+        for s in tensor.size():
+            self.sizes.append(s)
+        self.dim_offsets.append(self.dim_offsets[-1] + len(tensor.size()))
+
+    def end_document(self):
+        self.doc_idx.append(len(self.sizes))
+
+    def merge_file_(self, another_file):
+        index = IndexedDataset(another_file)
+        assert index.dtype == self.dtype
+
+        doc_offset = len(self.sizes)
+
+        begin = self.data_offsets[-1]
+        for data_offset in index.data_offsets[1:]:
+            self.data_offsets.append(begin + data_offset)
+        self.sizes.extend(index.sizes)
+        begin = self.dim_offsets[-1]
+        for dim_offset in index.dim_offsets[1:]:
+            self.dim_offsets.append(begin + dim_offset)
+        self.doc_idx.extend((doc_offset + index.doc_idx)[1:])
+
+        with open(data_file_path(another_file), 'rb') as f:
+            while True:
+                data = f.read(1024)
+                if data:
+                    self.out_file.write(data)
+                else:
+                    break
+
+    def finalize(self, index_file):
+        self.out_file.close()
+        index = open(index_file, 'wb')
+        index.write(b'TNTIDX\x00\x00')
+        index.write(struct.pack('<Q', 1))
+        index.write(struct.pack('<QQ', code(self.dtype), self.element_size))
+        index.write(struct.pack('<QQ', len(self.data_offsets) - 1, len(self.sizes)))
+        index.write(struct.pack('<Q', len(self.doc_idx)))
+        write_longs(index, self.dim_offsets)
+        write_longs(index, self.data_offsets)
+        write_longs(index, self.sizes)
+        write_longs(index, self.doc_idx)
+        index.close()
+
+
+def _warmup_mmap_file(path):
+    with open(path, 'rb') as stream:
+        while stream.read(100 * 1024 * 1024):
+            pass
+
+
+def exscan_from_cumsum_(arr):
+    # given an array holding the result of an inclusive scan (cumsum),
+    # convert to an exclusive scan (shift to the right)
+    # [10, 30, 35, 50] --> [0, 10, 30, 35]
+    if arr.size > 1:
+        arr[1:] = arr[:-1]
+    if arr.size > 0:
+        arr[0] = 0
+
+
+def get_pointers_with_total(sizes, elemsize, dtype):
+    """Return a numpy array of type np.dtype giving the byte offsets.
+
+    Multiplies values in the sizes array by elemsize (bytes),
+    and then computes an exclusive scan to get byte offsets.
+    Returns the total number of bytes as second item in a tuple.
+    """
+
+    # scale values in sizes array by elemsize to get sizes in bytes
+    pointers = np.array(sizes, dtype=dtype)
+    pointers *= elemsize
+    np.cumsum(pointers, axis=0, out=pointers)
+
+    # get total number of bytes from all sizes (last element)
+    bytes_last = pointers[-1] if len(sizes) > 0 else 0
+
+    # convert to byte offsets
+    exscan_from_cumsum_(pointers)
+
+    return pointers, bytes_last
+
+
+class MMapIndexedDataset(torch.utils.data.Dataset):
+
+    class Index(object):
+        _HDR_MAGIC = b'MMIDIDX\x00\x00'
+
+        @classmethod
+        def writer(cls, path, dtype):
+
+            class _Writer(object):
+
+                def __enter__(self):
+                    self._file = open(path, 'wb')
+
+                    self._file.write(cls._HDR_MAGIC)
+                    self._file.write(struct.pack('<Q', 1))
+                    self._file.write(struct.pack('<B', code(dtype)))
+
+                    return self
+
+                @staticmethod
+                def _get_pointers(sizes, npdtype):
+                    """Return a numpy array of byte offsets given a list of sizes.
+
+                    Multiplies values in the sizes array by dtype size (bytes),
+                    and then computes an exclusive scan to get byte offsets.
+                    """
+
+                    # compute element sizes in bytes
+                    pointers, _ = get_pointers_with_total(sizes, dtype().itemsize, npdtype)
+                    return pointers
+
+                def write(self, sizes, doc_idx):
+                    self._file.write(struct.pack('<Q', len(sizes)))
+                    self._file.write(struct.pack('<Q', len(doc_idx)))
+
+                    sizes32 = np.array(sizes, dtype=np.int32)
+                    self._file.write(sizes32.tobytes(order='C'))
+                    del sizes32
+
+                    pointers = self._get_pointers(sizes, np.int64)
+                    del sizes
+                    self._file.write(pointers.tobytes(order='C'))
+                    del pointers
+
+                    doc_idx = np.array(doc_idx, dtype=np.int64)
+                    self._file.write(doc_idx.tobytes(order='C'))
+
+                def __exit__(self, exc_type, exc_val, exc_tb):
+                    self._file.close()
+
+            return _Writer()
+
+        def __init__(self, path, skip_warmup=False):
+            with open(path, 'rb') as stream:
+                magic_test = stream.read(9)
+                assert self._HDR_MAGIC == magic_test, ('Index file doesn\'t match expected format. '
+                                                       'Make sure that --dataset-impl is configured properly.')
+                version = struct.unpack('<Q', stream.read(8))
+                assert (1, ) == version
+
+                dtype_code, = struct.unpack('<B', stream.read(1))
+                self._dtype = dtypes[dtype_code][0]  #numpy type
+                self._dtype_size = self._dtype().itemsize
+
+                self._len = struct.unpack('<Q', stream.read(8))[0]
+                self._doc_count = struct.unpack('<Q', stream.read(8))[0]
+                offset = stream.tell()
+
+            if not skip_warmup:
+                print("    warming up index mmap file...")
+                _warmup_mmap_file(path)
+
+            self._bin_buffer_mmap = np.memmap(path, mode='r', order='C')
+            self._bin_buffer = memoryview(self._bin_buffer_mmap)
+            print("    reading sizes...")
+            self._sizes = np.frombuffer(self._bin_buffer, dtype=np.int32, count=self._len, offset=offset)
+            print("    reading pointers...")
+            self._pointers = np.frombuffer(self._bin_buffer,
+                                           dtype=np.int64,
+                                           count=self._len,
+                                           offset=offset + self._sizes.nbytes)
+            print("    reading document index...")
+            self._doc_idx = np.frombuffer(self._bin_buffer,
+                                          dtype=np.int64,
+                                          count=self._doc_count,
+                                          offset=offset + self._sizes.nbytes + self._pointers.nbytes)
+
+        def __del__(self):
+            self._bin_buffer_mmap._mmap.close()
+            del self._bin_buffer_mmap
+
+        @property
+        def dtype(self):
+            return self._dtype
+
+        @property
+        def sizes(self):
+            return self._sizes
+
+        @property
+        def doc_idx(self):
+            return self._doc_idx
+
+        @lru_cache(maxsize=8)
+        def __getitem__(self, i):
+            return self._pointers[i], self._sizes[i]
+
+        def __len__(self):
+            return self._len
+
+    def __init__(self, path, skip_warmup=False):
+        super().__init__()
+
+        self._path = None
+        self._index = None
+        self._bin_buffer = None
+
+        self._do_init(path, skip_warmup)
+
+    def __getstate__(self):
+        return self._path
+
+    def __setstate__(self, state):
+        self._do_init(state)
+
+    def _do_init(self, path, skip_warmup):
+        self._path = path
+        self._index = self.Index(index_file_path(self._path), skip_warmup)
+
+        if not skip_warmup:
+            print("    warming up data mmap file...")
+            _warmup_mmap_file(data_file_path(self._path))
+        print("    creating numpy buffer of mmap...")
+        self._bin_buffer_mmap = np.memmap(data_file_path(self._path), mode='r', order='C')
+        print("    creating memory view of numpy buffer...")
+        self._bin_buffer = memoryview(self._bin_buffer_mmap)
+
+    def __del__(self):
+        self._bin_buffer_mmap._mmap.close()
+        del self._bin_buffer_mmap
+        del self._index
+
+    def __len__(self):
+        return len(self._index)
+
+    # @lru_cache(maxsize=8)
+    def __getitem__(self, idx):
+        if isinstance(idx, int):
+            ptr, size = self._index[idx]
+            np_array = np.frombuffer(self._bin_buffer, dtype=self._index.dtype, count=size, offset=ptr)
+            return np_array
+        elif isinstance(idx, slice):
+            start, stop, step = idx.indices(len(self))
+            if step != 1:
+                raise ValueError("Slices into indexed_dataset must be contiguous")
+            ptr = self._index._pointers[start]
+            sizes = self._index._sizes[idx]
+            offsets = list(accumulate(sizes))
+            total_size = sum(sizes)
+            np_array = np.frombuffer(self._bin_buffer, dtype=self._index.dtype, count=total_size, offset=ptr)
+            sents = np.split(np_array, offsets[:-1])
+            return sents
+
+    def get(self, idx, offset=0, length=None):
+        """ Retrieves a single item from the dataset with the option to only
+        return a portion of the item.
+
+        get(idx) is the same as [idx] but get() does not support slicing.
+        """
+        ptr, size = self._index[idx]
+        if length is None:
+            length = size - offset
+        ptr += offset * np.dtype(self._index.dtype).itemsize
+        np_array = np.frombuffer(self._bin_buffer, dtype=self._index.dtype, count=length, offset=ptr)
+        return np_array
+
+    @property
+    def sizes(self):
+        return self._index.sizes
+
+    def size(self, index):
+        return self._index.sizes[index]
+
+    @property
+    def doc_idx(self):
+        return self._index.doc_idx
+
+    def get_doc_idx(self):
+        return self._index._doc_idx
+
+    def set_doc_idx(self, doc_idx_):
+        self._index._doc_idx = doc_idx_
+
+    @property
+    def supports_prefetch(self):
+        return False
+
+    @staticmethod
+    def exists(path):
+        return (os.path.exists(index_file_path(path)) and os.path.exists(data_file_path(path)))
+
+    @property
+    def dtype(self):
+        return self._index.dtype
+
+
+class MMapIndexedDatasetBuilder(object):
+
+    def __init__(self, out_file, dtype=np.int64):
+        self._data_file = open(out_file, 'wb')
+        self._dtype = [np_dt for np_dt, torch_dt in dtypes.values() if dtype in [np_dt, torch_dt]][0]
+        self._sizes = []
+        self._doc_idx = [0]
+
+    def add_item(self, tensor):
+        """ write the tensor to the file and update its size in the index"""
+        np_array = np.array(tensor.numpy(), dtype=self._dtype)
+        self._data_file.write(np_array.tobytes(order='C'))
+        self._sizes.append(np_array.size)
+
+    def add_items(self, arr_list):
+        """ write a list of arrays to the file and update their sizes in the index"""
+        np_arrays = [arr.astype(self._dtype) for arr in arr_list]
+        self._data_file.writelines([arr.tobytes(order='C') for arr in np_arrays])
+        for arr in np_arrays:
+            self._sizes.append(arr.size)
+
+    def add_item_numpy(self, np_array):
+        if np_array.dtype != self._dtype:
+            np_array = np_array.astype(self._dtype)
+        self._data_file.write(np_array.tobytes(order='C'))
+        self._sizes.append(np_array.size)
+
+    def end_document(self):
+        self._doc_idx.append(len(self._sizes))
+
+    def merge_file_(self, another_file):
+        # Concatenate index
+        index = MMapIndexedDataset.Index(index_file_path(another_file))
+        assert index.dtype == self._dtype
+
+        total_len = len(index.sizes) + len(self._sizes)
+        print(f"    concat {another_file} size={len(index.sizes)} for a total size of {total_len}")
+
+        offset = len(self._sizes)
+        self._sizes.extend(index.sizes)
+        self._doc_idx.extend((offset + index.doc_idx)[1:])
+
+        # Concatenate data
+        with open(data_file_path(another_file), 'rb') as f:
+            shutil.copyfileobj(f, self._data_file)
+        self._data_file.flush()
+        assert os.stat(self._data_file.name).st_size != 0, f"Zero-sized file: {self._data_file.name}"
+
+    def finalize(self, index_file):
+        self._data_file.close()
+
+        with MMapIndexedDataset.Index.writer(index_file, self._dtype) as index:
+            index.write(self._sizes, self._doc_idx)

venv/lib/python3.10/site-packages/deepspeed/runtime/data_pipeline/data_sampling/utils.py

@@ -0,0 +1,52 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import numpy as np
+
+from deepspeed.utils import logger
+from .indexed_dataset import MMapIndexedDatasetBuilder
+
+
+def find_fit_int_dtype(min_value, max_value):
+    if min_value >= 0:
+        if max_value <= 255:
+            return np.uint8
+        elif max_value <= 65535:
+            return np.uint16
+        elif max_value <= 4294967295:
+            return np.uint32
+        else:
+            return np.uint64
+    else:
+        if max_value <= 127 and min_value >= -128:
+            return np.int8
+        elif max_value <= 32767 and min_value >= -32768:
+            return np.int16
+        elif max_value <= 2147483647 and min_value >= -2147483648:
+            return np.int32
+        else:
+            return np.int64
+
+
+def split_index(start_idx, end_idx, num_partitions):
+    partition_boundaries = np.linspace(start_idx, end_idx, dtype=int, num=num_partitions + 1)
+    return [(partition_boundaries[i], partition_boundaries[i + 1]) for i in range(num_partitions)]
+
+
+def split_dataset(dataset, num_workers, worker_id, num_threads):
+    worker_splits = split_index(0, len(dataset), num_workers)
+    thread_splits = split_index(worker_splits[worker_id][0], worker_splits[worker_id][1], num_threads)
+    return worker_splits, thread_splits
+
+
+def create_mmap_dataset_builder(fname, dtype):
+    logger.info(f"Creating mmap dataset builder at {fname}.")
+    return MMapIndexedDatasetBuilder(f"{fname}.bin", dtype=dtype)
+
+
+def close_mmap_dataset_builder(builder, fname):
+    builder.end_document()
+    builder.finalize(f"{fname}.idx")
+    logger.info(f"Finalized mmap dataset builder at {fname}.")

venv/lib/python3.10/site-packages/deepspeed/runtime/lr_schedules.py

@@ -0,0 +1,878 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""
+Implementation of learning rate schedules.
+
+Taken and modified from PyTorch v1.0.1 source
+https://github.com/pytorch/pytorch/blob/v1.1.0/torch/optim/lr_scheduler.py
+"""
+
+import argparse
+from torch.optim import Optimizer
+import math
+from deepspeed.utils import logger
+
+LR_SCHEDULE = 'lr_schedule'
+LR_RANGE_TEST = 'LRRangeTest'
+ONE_CYCLE = 'OneCycle'
+WARMUP_LR = 'WarmupLR'
+WARMUP_DECAY_LR = 'WarmupDecayLR'
+WARMUP_COSINE_LR = 'WarmupCosineLR'
+VALID_LR_SCHEDULES = [LR_RANGE_TEST, ONE_CYCLE, WARMUP_LR, WARMUP_DECAY_LR, WARMUP_COSINE_LR]
+
+LR_RANGE_TEST_MIN_LR = 'lr_range_test_min_lr'
+LR_RANGE_TEST_STEP_RATE = 'lr_range_test_step_rate'
+LR_RANGE_TEST_STEP_SIZE = 'lr_range_test_step_size'
+LR_RANGE_TEST_STAIRCASE = 'lr_range_test_staircase'
+
+EDGE_VALUE = 'edge_value'
+MID_VALUE = 'mid_value'
+
+CYCLE_FIRST_STEP_SIZE = 'cycle_first_step_size'
+CYCLE_FIRST_STAIR_COUNT = 'cycle_first_stair_count'
+CYCLE_SECOND_STEP_SIZE = 'cycle_second_step_size'
+CYCLE_SECOND_STAIR_COUNT = 'cycle_second_stair_count'
+DECAY_STEP_SIZE = 'decay_step_size'
+
+CYCLE_MIN_LR = 'cycle_min_lr'
+CYCLE_MAX_LR = 'cycle_max_lr'
+DECAY_LR_RATE = 'decay_lr_rate'
+
+CYCLE_MIN_MOM = 'cycle_min_mom'
+CYCLE_MAX_MOM = 'cycle_max_mom'
+DECAY_MOM_RATE = 'decay_mom_rate'
+
+WARMUP_MIN_LR = 'warmup_min_lr'
+WARMUP_MAX_LR = 'warmup_max_lr'
+WARMUP_NUM_STEPS = 'warmup_num_steps'
+WARMUP_TYPE = 'warmup_type'
+WARMUP_LOG_RATE = 'log'
+WARMUP_LINEAR_RATE = 'linear'
+
+WARMUP_MIN_RATIO = 'warmup_min_ratio'
+COS_MIN_RATIO = 'cos_min_ratio'
+
+TOTAL_NUM_STEPS = 'total_num_steps'
+
+
+def add_tuning_arguments(parser):
+    group = parser.add_argument_group('Convergence Tuning', 'Convergence tuning configurations')
+
+    # LR scheduler
+    group.add_argument('--lr_schedule', type=str, default=None, help='LR schedule for training.')
+
+    # Learning rate range test
+    group.add_argument("--lr_range_test_min_lr", type=float, default=0.001, help='Starting lr value.')
+    group.add_argument("--lr_range_test_step_rate", type=float, default=1.0, help='scaling rate for LR range test.')
+    group.add_argument("--lr_range_test_step_size", type=int, default=1000, help='training steps per LR change.')
+    group.add_argument("--lr_range_test_staircase",
+                       type=bool,
+                       default=False,
+                       help='use staircase scaling for LR range test.')
+
+    # OneCycle schedule
+    group.add_argument("--cycle_first_step_size",
+                       type=int,
+                       default=1000,
+                       help='size of first step of 1Cycle schedule (training steps).')
+    group.add_argument("--cycle_first_stair_count",
+                       type=int,
+                       default=-1,
+                       help='first stair count for 1Cycle schedule.')
+    group.add_argument("--cycle_second_step_size",
+                       type=int,
+                       default=-1,
+                       help='size of second step of 1Cycle schedule (default first_step_size).')
+    group.add_argument("--cycle_second_stair_count",
+                       type=int,
+                       default=-1,
+                       help='second stair count for 1Cycle schedule.')
+    group.add_argument("--decay_step_size",
+                       type=int,
+                       default=1000,
+                       help='size of intervals for applying post cycle decay (training steps).')
+
+    # 1Cycle LR
+    group.add_argument("--cycle_min_lr", type=float, default=0.01, help='1Cycle LR lower bound.')
+    group.add_argument("--cycle_max_lr", type=float, default=0.1, help='1Cycle LR upper bound.')
+    group.add_argument("--decay_lr_rate", type=float, default=0.0, help='post cycle LR decay rate.')
+
+    # 1Cycle Momentum
+    group.add_argument('--cycle_momentum', default=False, action='store_true', help='Enable 1Cycle momentum schedule.')
+    group.add_argument("--cycle_min_mom", type=float, default=0.8, help='1Cycle momentum lower bound.')
+    group.add_argument("--cycle_max_mom", type=float, default=0.9, help='1Cycle momentum upper bound.')
+    group.add_argument("--decay_mom_rate", type=float, default=0.0, help='post cycle momentum decay rate.')
+
+    # Warmup LR
+    group.add_argument('--warmup_min_lr', type=float, default=0, help='WarmupLR minimum/initial LR value')
+    group.add_argument('--warmup_max_lr', type=float, default=0.001, help='WarmupLR maximum LR value.')
+    group.add_argument('--warmup_num_steps', type=int, default=1000, help='WarmupLR step count for LR warmup.')
+    group.add_argument('--warmup_type',
+                       type=str,
+                       default=WARMUP_LOG_RATE,
+                       help='WarmupLR increasing function during warmup')
+
+    # WarmUP cos LR
+    group.add_argument("--warmup_min_ratio", type=float, default=0.01, help='Cosine LR lower bound.')
+    group.add_argument("--cos_min_ratio", type=float, default=0.01, help='Cosine LR lower bound.')
+
+    return parser
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+    parser = add_tuning_arguments(parser)
+
+    lr_sched_args, unknown_args = parser.parse_known_args()
+    return lr_sched_args, unknown_args
+
+
+def override_lr_range_test_params(args, params):
+    if hasattr(args, LR_RANGE_TEST_MIN_LR) and args.lr_range_test_min_lr is not None:
+        params[LR_RANGE_TEST_MIN_LR] = args.lr_range_test_min_lr
+
+    if hasattr(args, LR_RANGE_TEST_STEP_RATE) and args.lr_range_test_step_rate is not None:
+        params[LR_RANGE_TEST_STEP_RATE] = args.lr_range_test_step_rate
+
+    if hasattr(args, LR_RANGE_TEST_STEP_SIZE) and args.lr_range_test_step_size is not None:
+        params[LR_RANGE_TEST_STEP_SIZE] = args.lr_range_test_step_size
+
+    if hasattr(args, LR_RANGE_TEST_STAIRCASE) and args.lr_range_test_staircase is not None:
+        params[LR_RANGE_TEST_STAIRCASE] = args.lr_range_test_staircase
+
+
+def override_1cycle_params(args, params):
+    if hasattr(args, CYCLE_FIRST_STEP_SIZE) and args.cycle_first_step_size is not None:
+        params[CYCLE_FIRST_STEP_SIZE] = args.cycle_first_step_size
+
+    if hasattr(args, CYCLE_FIRST_STAIR_COUNT) and args.cycle_first_stair_count is not None:
+        params[CYCLE_FIRST_STAIR_COUNT] = args.cycle_first_stair_count
+
+    if hasattr(args, CYCLE_SECOND_STEP_SIZE) and args.cycle_second_step_size is not None:
+        params[CYCLE_SECOND_STEP_SIZE] = args.cycle_second_step_size
+
+    if hasattr(args, CYCLE_SECOND_STAIR_COUNT) and args.cycle_second_stair_count is not None:
+        params[CYCLE_SECOND_STAIR_COUNT] = args.cycle_second_stair_count
+
+    if hasattr(args, DECAY_STEP_SIZE) and args.decay_step_size is not None:
+        params[DECAY_STEP_SIZE] = args.decay_step_size
+
+    # 1Cycle LR params
+    if hasattr(args, CYCLE_MIN_LR) and args.cycle_min_lr is not None:
+        params[CYCLE_MIN_LR] = args.cycle_min_lr
+
+    if hasattr(args, CYCLE_MAX_LR) and args.cycle_max_lr is not None:
+        params[CYCLE_MAX_LR] = args.cycle_max_lr
+
+    if hasattr(args, DECAY_LR_RATE) and args.decay_lr_rate is not None:
+        params[DECAY_LR_RATE] = args.decay_lr_rate
+
+    # 1Cycle MOM params
+    if hasattr(args, CYCLE_MIN_MOM) and args.cycle_min_mom is not None:
+        params[CYCLE_MIN_MOM] = args.cycle_min_mom
+
+    if hasattr(args, CYCLE_MAX_MOM) and args.cycle_max_mom is not None:
+        params[CYCLE_MAX_MOM] = args.cycle_max_mom
+
+    if hasattr(args, DECAY_MOM_RATE) and args.decay_mom_rate is not None:
+        params[DECAY_MOM_RATE] = args.decay_mom_rate
+
+
+def override_warmupLR_params(args, params):
+    if hasattr(args, WARMUP_MIN_LR) and args.warmup_min_lr is not None:
+        params[WARMUP_MIN_LR] = args.warmup_min_lr
+
+    if hasattr(args, WARMUP_MAX_LR) and args.warmup_max_lr is not None:
+        params[WARMUP_MAX_LR] = args.warmup_max_lr
+
+    if hasattr(args, WARMUP_NUM_STEPS) and args.warmup_num_steps is not None:
+        params[WARMUP_NUM_STEPS] = args.warmup_num_steps
+
+    if hasattr(args, WARMUP_TYPE) and args.warmup_type is not None:
+        params[WARMUP_TYPE] = args.warmup_type
+
+
+def override_params(args, params):
+    # LR range test params
+    override_lr_range_test_params(args, params)
+
+    # 1Cycle params
+    override_1cycle_params(args, params)
+
+    # WarmupLR params
+    override_warmupLR_params(args, params)
+
+
+def get_config_from_args(args):
+    if not hasattr(args, LR_SCHEDULE) or args.lr_schedule is None:
+        return None, '--{} not specified on command line'.format(LR_SCHEDULE)
+
+    if not args.lr_schedule in VALID_LR_SCHEDULES:
+        return None, '{} is not supported LR schedule'.format(args.lr_schedule)
+
+    config = {}
+    config['type'] = args.lr_schedule
+    config['params'] = {}
+
+    if args.lr_schedule == LR_RANGE_TEST:
+        override_lr_range_test_params(args, config['params'])
+    elif args.lr_schedule == ONE_CYCLE:
+        override_1cycle_params(args, config['params'])
+    else:
+        override_warmupLR_params(args, config['params'])
+
+    return config, None
+
+
+def get_lr_from_config(config):
+    if not 'type' in config:
+        return None, 'LR schedule type not defined in config'
+
+    if not 'params' in config:
+        return None, 'LR schedule params not defined in config'
+
+    lr_schedule = config['type']
+    lr_params = config['params']
+
+    if not lr_schedule in VALID_LR_SCHEDULES:
+        return None, '{} is not a valid LR schedule'.format(lr_schedule)
+
+    if lr_schedule == LR_RANGE_TEST:
+        return lr_params[LR_RANGE_TEST_MIN_LR], ''
+    if lr_schedule == ONE_CYCLE:
+        return lr_params[CYCLE_MAX_LR], ''
+    # Warmup LR
+    return lr_params[WARMUP_MAX_LR], ''
+
+
+"""
+Only optimizers that are subclass of torch.optim.Optimizer are supported. So check the passed optimizer and wrapped
+optimizer to see if requirement is satisfied.
+TODO: Looking under the hood to examine the wrapped optimizer is a hack that requires a better long-term fix.
+"""
+
+
+def get_torch_optimizer(optimizer):
+    if isinstance(optimizer, Optimizer):
+        return optimizer
+
+    if hasattr(optimizer, 'optimizer') and isinstance(optimizer.optimizer, Optimizer):
+        return optimizer.optimizer
+
+    raise TypeError('{} is not a subclass of torch.optim.Optimizer'.format(type(optimizer).__name__))
+
+
+class LRRangeTest(object):
+    """Sets the learning rate of each parameter group according to
+    learning rate range test (LRRT) policy. The policy increases learning
+    rate starting from a base value with a constant frequency, as detailed in
+    the paper `A disciplined approach to neural network hyper-parameters: Part1`_.
+
+    LRRT policy is used for finding maximum LR that trains a model without divergence, and can be used to
+    configure the LR boundaries for Cyclic LR schedules.
+
+    LRRT changes the learning rate after every batch.
+    `step` should be called after a batch has been used for training.
+
+    Args:
+        optimizer (Optimizer): Wrapped optimizer.
+        lr_range_test_min_lr (float or list): Initial learning rate which is the
+            lower boundary in the range test for each parameter group.
+        lr_range_test_step_size (int): Interval of training steps to increase learning rate. Default: 2000
+        lr_range_test_step_rate (float): Scaling rate for range test. Default: 1.0
+        lr_range_test_staircase (bool): Scale in staircase fashion, rather than continuous. Default: False.
+        last_batch_iteration (int): The index of the last batch. This parameter is used when
+            resuming a training job. Since `step()` should be invoked after each
+            batch instead of after each epoch, this number represents the total
+            number of *batches* computed, not the total number of epochs computed.
+            When last_batch_iteration=-1, the schedule is started from the beginning.
+            Default: -1
+
+    Example:
+        >>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
+        >>> scheduler = LRRangeTest(optimizer)
+        >>> data_loader = torch.utils.data.DataLoader(...)
+        >>> for epoch in range(10):
+        >>>     for batch in data_loader:
+        >>>         train_batch(...)
+        >>>         scheduler.step()
+
+        _A disciplined approach to neural network hyper-parameters: Part 1 -- learning rate, batch size, momentum, and weight decay:
+        https://arxiv.org/abs/1803.09820
+"""
+
+    def __init__(self,
+                 optimizer: Optimizer,
+                 lr_range_test_min_lr: float = 1e-3,
+                 lr_range_test_step_size: int = 2000,
+                 lr_range_test_step_rate: float = 1.0,
+                 lr_range_test_staircase: bool = False,
+                 last_batch_iteration: int = -1):
+
+        self.optimizer = get_torch_optimizer(optimizer)
+
+        if isinstance(lr_range_test_min_lr, list) or isinstance(lr_range_test_min_lr, tuple):
+            if len(lr_range_test_min_lr) != len(self.optimizer.param_groups):
+                raise ValueError("expected {} lr_range_test_min_lr, got {}".format(len(self.optimizer.param_groups),
+                                                                                   len(lr_range_test_min_lr)))
+            self.min_lr = list(lr_range_test_min_lr)
+        else:
+            self.min_lr = [lr_range_test_min_lr] * len(self.optimizer.param_groups)
+
+        self.step_size = lr_range_test_step_size
+        self.step_rate = lr_range_test_step_rate
+        self.last_batch_iteration = last_batch_iteration
+        self.staircase = lr_range_test_staircase
+        self.interval_fn = self._staircase_interval if lr_range_test_staircase else self._continuous_interval
+
+        if last_batch_iteration == -1:
+            self._update_optimizer(self.min_lr)
+
+    def _staircase_interval(self):
+        return math.floor(float(self.last_batch_iteration + 1) / self.step_size)
+
+    def _continuous_interval(self):
+        return float(self.last_batch_iteration + 1) / self.step_size
+
+    def _get_increase(self):
+        return (1 + self.step_rate * self.interval_fn())
+
+    def get_lr(self):
+        lr_increase = self._get_increase()
+        return [lr_range_test_min_lr * lr_increase for lr_range_test_min_lr in self.min_lr]
+
+    def get_last_lr(self):
+        """ Return last computed learning rate by current scheduler.
+        """
+        assert getattr(self, '_last_lr', None) is not None, "need to call step() first"
+        return self._last_lr
+
+    def _update_optimizer(self, group_lrs):
+        for param_group, lr in zip(self.optimizer.param_groups, group_lrs):
+            param_group['lr'] = lr
+
+    def step(self, batch_iteration=None):
+        if batch_iteration is None:
+            batch_iteration = self.last_batch_iteration + 1
+        self.last_batch_iteration = batch_iteration
+        self._update_optimizer(self.get_lr())
+        self._last_lr = [group['lr'] for group in self.optimizer.param_groups]
+
+    def state_dict(self):
+        return {'last_batch_iteration': self.last_batch_iteration}
+
+    def load_state_dict(self, sd):
+        self.last_batch_iteration = sd['last_batch_iteration']
+
+
+class OneCycle(object):
+    """Sets the learning rate of each parameter group according to
+    1Cycle learning rate policy (1CLR). 1CLR is a variation of the
+    Cyclical Learning Rate (CLR) policy that involves one cycle followed by
+    decay. The policy simultaneously cycles the learning rate (and momentum)
+    between two boundaries with a constant frequency, as detailed in
+    the paper `A disciplined approach to neural network hyper-parameters`_.
+
+    1CLR policy changes the learning rate after every batch.
+    `step` should be called after a batch has been used for training.
+
+    This implementation was adapted from the github repo: `pytorch/pytorch`_
+
+    Args:
+        optimizer (Optimizer): Wrapped optimizer.
+        cycle_min_lr (float or list): Initial learning rate which is the
+            lower boundary in the cycle for each parameter group.
+        cycle_max_lr (float or list): Upper learning rate boundaries in the cycle
+            for each parameter group. Functionally,
+            it defines the cycle amplitude (cycle_max_lr - cycle_min_lr).
+            The lr at any cycle is the sum of cycle_min_lr
+            and some scaling of the amplitude; therefore
+            cycle_max_lr may not actually be reached depending on
+            scaling function.
+        decay_lr_rate(float): Decay rate for learning rate. Default: 0.
+        cycle_first_step_size (int): Number of training iterations in the
+            increasing half of a cycle. Default: 2000
+        cycle_second_step_size (int): Number of training iterations in the
+            decreasing half of a cycle. If cycle_second_step_size is None,
+            it is set to cycle_first_step_size. Default: None
+        cycle_first_stair_count(int): Number of stairs in first half of cycle phase. This means
+        lr/mom are changed in staircase fashion. Default 0, means staircase disabled.
+        cycle_second_stair_count(int): Number of stairs in second half of cycle phase. This means
+        lr/mom are changed in staircase fashion. Default 0, means staircase disabled.
+        decay_step_size (int): Intervals for applying decay in decay phase. Default: 0, means no decay.
+        cycle_momentum (bool): If ``True``, momentum is cycled inversely
+            to learning rate between 'cycle_min_mom' and 'cycle_max_mom'.
+            Default: True
+        cycle_min_mom (float or list): Initial momentum which is the
+            lower boundary in the cycle for each parameter group.
+            Default: 0.8
+        cycle_max_mom (float or list): Upper momentum boundaries in the cycle
+            for each parameter group. Functionally,
+            it defines the cycle amplitude (cycle_max_mom - cycle_min_mom).
+            The momentum at any cycle is the difference of cycle_max_mom
+            and some scaling of the amplitude; therefore
+            cycle_min_mom may not actually be reached depending on
+            scaling function. Default: 0.9
+        decay_mom_rate (float): Decay rate for momentum. Default: 0.
+        last_batch_iteration (int): The index of the last batch. This parameter is used when
+            resuming a training job. Since `step()` should be invoked after each
+            batch instead of after each epoch, this number represents the total
+            number of *batches* computed, not the total number of epochs computed.
+            When last_batch_iteration=-1, the schedule is started from the beginning.
+            Default: -1
+
+    Example:
+        >>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
+        >>> scheduler = OneCycle(optimizer, 0.0001, 0.0010)
+        >>> data_loader = torch.utils.data.DataLoader(...)
+        >>> for epoch in range(10):
+        >>>     for batch in data_loader:
+        >>>         train_batch(...)
+        >>>         scheduler.step()
+
+
+    .. _A disciplined approach to neural network hyper-parameters: Part 1 -- learning rate, batch size, momentum, and weight decay: https://arxiv.org/abs/1803.09820
+    """
+
+    def __init__(self,
+                 optimizer,
+                 cycle_min_lr,
+                 cycle_max_lr,
+                 decay_lr_rate=0.,
+                 cycle_first_step_size=2000,
+                 cycle_second_step_size=None,
+                 cycle_first_stair_count=0,
+                 cycle_second_stair_count=None,
+                 decay_step_size=0,
+                 cycle_momentum=True,
+                 cycle_min_mom=0.8,
+                 cycle_max_mom=0.9,
+                 decay_mom_rate=0.,
+                 last_batch_iteration=-1):
+
+        self.optimizer = get_torch_optimizer(optimizer)
+
+        # Initialize cycle shape
+        self._initialize_cycle(cycle_first_step_size, cycle_second_step_size, cycle_first_stair_count,
+                               cycle_second_stair_count, decay_step_size)
+
+        # Initialize cycle lr
+        self._initialize_lr(self.optimizer, cycle_min_lr, cycle_max_lr, decay_lr_rate, last_batch_iteration)
+
+        # Initialize cyclic momentum
+        self.cycle_momentum = cycle_momentum
+        if cycle_momentum:
+            self._initialize_momentum(self.optimizer, cycle_min_mom, cycle_max_mom, decay_mom_rate,
+                                      last_batch_iteration)
+        # Initialize batch iteration tracker
+        self.last_batch_iteration = last_batch_iteration
+
+    # Configure cycle shape
+
+    def _initialize_cycle(self, cycle_first_step_size, cycle_second_step_size, cycle_first_stair_count,
+                          cycle_second_stair_count, decay_step_size):
+        cycle_first_step_size = float(cycle_first_step_size)
+        cycle_second_step_size = float(
+            cycle_second_step_size) if cycle_second_step_size is not None else cycle_first_step_size
+
+        self.total_size = cycle_first_step_size + cycle_second_step_size
+        self.step_ratio = cycle_first_step_size / self.total_size
+        self.first_stair_count = cycle_first_stair_count
+        self.second_stair_count = cycle_first_stair_count if cycle_second_stair_count is None else cycle_second_stair_count
+        self.decay_step_size = decay_step_size
+
+        if math.isclose(self.decay_step_size, 0):
+            self.skip_lr_decay = True
+            self.skip_mom_decay = True
+        else:
+            self.skip_lr_decay = False
+            self.skip_mom_decay = False
+
+    # Configure lr schedule
+    def _initialize_lr(self, optimizer, cycle_min_lr, cycle_max_lr, decay_lr_rate, last_batch_iteration):
+        self.min_lrs = [cycle_min_lr] * len(optimizer.param_groups)
+        if last_batch_iteration == -1:
+            for lr, group in zip(self.min_lrs, optimizer.param_groups):
+                group['lr'] = lr
+
+        self.max_lrs = [cycle_max_lr] * len(optimizer.param_groups)
+        self.decay_lr_rate = decay_lr_rate
+
+        if math.isclose(self.decay_lr_rate, 0):
+            self.skip_lr_decay = True
+
+    # Configure momentum schedule
+    def _initialize_momentum(self, optimizer, cycle_min_mom, cycle_max_mom, decay_mom_rate, last_batch_iteration):
+        if 'betas' not in optimizer.defaults:
+            optimizer_name = type(optimizer).__name__
+            logger.warn(
+                f"cycle_momentum is disabled because optimizer {optimizer_name} does not support momentum, no betas attribute in defaults"
+            )
+            self.cycle_momentum = False
+            return
+
+        self.decay_mom_rate = decay_mom_rate
+        self.min_moms = [(cycle_min_mom, 0.99)] * len(optimizer.param_groups)
+        self.max_moms = [(cycle_max_mom, 0.99)] * len(optimizer.param_groups)
+
+        if last_batch_iteration == -1:
+            for momentum, group in zip(self.min_moms, optimizer.param_groups):
+                group['betas'] = momentum
+
+        if math.isclose(self.decay_mom_rate, 0):
+            self.skip_mom_decay = True
+
+    def _get_scale_factor(self):
+        batch_iteration = (self.last_batch_iteration + 1)
+        cycle = math.floor(1 + batch_iteration / self.total_size)
+        x = 1. + batch_iteration / self.total_size - cycle
+        if x <= self.step_ratio:
+            scale_factor = x / self.step_ratio
+        else:
+            scale_factor = (x - 1) / (self.step_ratio - 1)
+
+        return scale_factor
+
+    def _get_cycle_mom(self):
+        scale_factor = self._get_scale_factor()
+        momentums = []
+        for base_betas, max_betas in zip(self.min_moms, self.max_moms):
+            cycle_min_mom = base_betas[0]
+            cycle_max_mom = max_betas[0]
+            base_height = (cycle_max_mom - cycle_min_mom) * scale_factor
+            momentum = cycle_max_mom - base_height
+            momentums.append((momentum, base_betas[1]))
+        return momentums
+
+    def _get_cycle_lr(self):
+        scale_factor = self._get_scale_factor()
+        lrs = []
+        for cycle_min_lr, cycle_max_lr in zip(self.min_lrs, self.max_lrs):
+            base_height = (cycle_max_lr - cycle_min_lr) * scale_factor
+            lr = cycle_min_lr + base_height
+            lrs.append(lr)
+
+        return lrs
+
+    def _get_decay_mom(self, decay_batch_iteration):
+        if self.skip_mom_decay:
+            return self.max_moms
+
+        decay_interval = decay_batch_iteration / self.decay_step_size
+        mom_decay_factor = (1 + self.decay_mom_rate * decay_interval)
+        momentums = [(beta0 * mom_decay_factor, beta1) for beta0, beta1 in self.max_moms]
+
+        return momentums
+
+    def _get_decay_lr(self, decay_batch_iteration):
+        """Calculates the learning rate at batch index. This function is used
+        after the cycle completes and post cycle decaying of lr/mom is enabled.
+        This function treats `self.last_batch_iteration` as the last batch index.
+        """
+        if self.skip_lr_decay:
+            return self.min_lrs
+
+        decay_interval = decay_batch_iteration / self.decay_step_size
+        lr_decay_factor = (1 + self.decay_lr_rate * decay_interval)
+        lrs = [cycle_min_lr / lr_decay_factor for cycle_min_lr in self.min_lrs]
+
+        return lrs
+
+    def get_lr(self):
+        """Calculates the learning rate at batch index. This function treats
+        `self.last_batch_iteration` as the last batch index.
+        """
+        if self.last_batch_iteration < self.total_size:
+            return self._get_cycle_lr()
+        return self._get_decay_lr(self.last_batch_iteration - self.total_size + 1)
+
+    def get_mom(self):
+        """Calculates the momentum at batch index. This function treats
+        `self.last_batch_iteration` as the last batch index.
+        """
+        if not self.cycle_momentum:
+            return None
+
+        if self.last_batch_iteration < self.total_size:
+            return self._get_cycle_mom()
+        return self._get_decay_mom(self.last_batch_iteration - self.total_size + 1)
+
+    def get_last_lr(self):
+        """ Return last computed learning rate by current scheduler.
+        """
+        assert getattr(self, '_last_lr', None) is not None, "need to call step() first"
+        return self._last_lr
+
+    def step(self, batch_iteration=None):
+        """ Updates the optimizer with the learning rate for the last batch index.
+        `self.last_batch_iteration` is treated as the last batch index.
+
+        If self.cycle_momentum is true, also updates optimizer momentum.
+        """
+        if batch_iteration is None:
+            batch_iteration = self.last_batch_iteration + 1
+
+        self.last_batch_iteration = batch_iteration
+        for param_group, lr in zip(self.optimizer.param_groups, self.get_lr()):
+            param_group['lr'] = lr
+        self._last_lr = [group['lr'] for group in self.optimizer.param_groups]
+
+        if self.cycle_momentum:
+            momentums = self.get_mom()
+            for param_group, momentum in zip(self.optimizer.param_groups, momentums):
+                param_group['betas'] = momentum
+
+    def state_dict(self):
+        return {'last_batch_iteration': self.last_batch_iteration}
+
+    def load_state_dict(self, sd):
+        self.last_batch_iteration = sd['last_batch_iteration']
+
+
+class WarmupLR(object):
+    """Increase the learning rate of each parameter group from min lr to max lr
+        over warmup_num_steps steps, and then fix at max lr.
+
+        Args:
+            optimizer (Optimizer): Wrapped optimizer.
+            warmup_min_lr (float or list): minimum learning rate. Default: 0
+            warmup_max_lr (float or list): maximum learning rate. Default: 0.001
+            warmup_num_steps (int): number of steps to warm up from min_lr to max_lr. Default: 1000
+            warmup_type {‘log’, ‘linear’}: increasing function from min_lr to max_lr during warmup. Default: log
+            last_batch_iteration (int): The index of the last batch. Default: -1.
+        Example:
+            >>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
+            >>> scheduler = WarmupLR(optimizer)
+            >>> data_loader = torch.utils.data.DataLoader(...)
+            >>> for epoch in range(10):
+            >>>     for batch in data_loader:
+            >>>         train_batch(...)
+            >>>         scheduler.step()
+
+    """
+
+    def __init__(self,
+                 optimizer: Optimizer,
+                 warmup_min_lr: float = 0.0,
+                 warmup_max_lr: float = 0.001,
+                 warmup_num_steps: int = 1000,
+                 warmup_type: str = WARMUP_LOG_RATE,
+                 last_batch_iteration: int = -1):
+
+        self.optimizer = get_torch_optimizer(optimizer)
+
+        self.min_lrs = self._format_param(self.optimizer, warmup_min_lr, "min_lr")
+        self.max_lrs = self._format_param(self.optimizer, warmup_max_lr, "max_lr")
+        self.delta_lrs = [big - small for big, small in zip(self.max_lrs, self.min_lrs)]
+        self.warmup_num_steps = max(2, warmup_num_steps)
+        # Currently only support linear and log function
+        if warmup_type not in {WARMUP_LOG_RATE, WARMUP_LINEAR_RATE}:
+            logger.warning(f"Using unknown warmup_type: {warmup_type}. The increasing function "
+                           f"is set to default (log)")
+            warmup_type = WARMUP_LOG_RATE
+        self.warmup_type = warmup_type
+        self.inverse_log_warm_up = 1.0 / math.log(self.warmup_num_steps)
+        self.last_batch_iteration = last_batch_iteration
+
+    def get_lr(self):
+        if self.last_batch_iteration < 0:
+            logger.warning("Attempting to get learning rate from scheduler before it has started")
+            return [0.0]
+        gamma = self._get_gamma()
+        return [min_lr + (delta_lr * gamma) for min_lr, delta_lr in zip(self.min_lrs, self.delta_lrs)]
+
+    def get_last_lr(self):
+        """ Return last computed learning rate by current scheduler.
+        """
+        assert getattr(self, '_last_lr', None) is not None, "need to call step() first"
+        return self._last_lr
+
+    def step(self, last_batch_iteration=None):
+        if last_batch_iteration is None:
+            last_batch_iteration = self.last_batch_iteration + 1
+        self.last_batch_iteration = last_batch_iteration
+        for param_group, lr in zip(self.optimizer.param_groups, self.get_lr()):
+            param_group['lr'] = lr
+        self._last_lr = [group['lr'] for group in self.optimizer.param_groups]
+
+    def state_dict(self):
+        return {'last_batch_iteration': self.last_batch_iteration}
+
+    def load_state_dict(self, sd):
+        self.last_batch_iteration = sd['last_batch_iteration']
+
+    def _get_gamma(self):
+        if self.last_batch_iteration < self.warmup_num_steps:
+            if self.warmup_type == WARMUP_LOG_RATE:
+                return self.inverse_log_warm_up * math.log(self.last_batch_iteration + 1)
+            elif self.warmup_type == WARMUP_LINEAR_RATE:
+                return self.last_batch_iteration / self.warmup_num_steps
+        return 1.0
+
+    def _format_param(self, optimizer, param_value, param_name):
+        if isinstance(param_value, list) or isinstance(param_value, tuple):
+            if len(param_value) != len(optimizer.param_groups):
+                raise ValueError("expected {} value for {}, got {}".format(len(optimizer.param_groups), param_name,
+                                                                           FileNotFoundError(param_value)))
+            return list(param_value)
+        return [param_value] * len(optimizer.param_groups)
+
+
+class WarmupDecayLR(WarmupLR):
+    """Increase the learning rate of each parameter group from min lr to max lr
+        over warmup_num_steps steps, and then decay at linear rate over the remaining training steps.
+
+        Args:
+            optimizer (Optimizer): Wrapped optimizer.
+            total_num_steps (int): total number of training steps
+            warmup_min_lr (float or list): minimum learning rate. Default: 0
+            warmup_max_lr (float or list): maximum learning rate. Default: 0.001
+            warmup_num_steps (int): number of steps to warm up from min_lr to max_lr. Default: 1000
+            warmup_type {‘log’, ‘linear’}: increasing function from min_lr to max_lr during warmup. Default: log
+            last_batch_iteration (int): The index of the last batch. Default: -1.
+        Example:
+            >>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
+            >>> scheduler = WarmupDecayLR(optimizer, 1000000)
+            >>> data_loader = torch.utils.data.DataLoader(...)
+            >>> for epoch in range(10):
+            >>>     for batch in data_loader:
+            >>>         train_batch(...)
+            >>>         scheduler.step()
+
+    """
+
+    def __init__(self,
+                 optimizer: Optimizer,
+                 total_num_steps: int,
+                 warmup_min_lr: float = 0.0,
+                 warmup_max_lr: float = 0.001,
+                 warmup_num_steps: int = 1000,
+                 warmup_type: str = WARMUP_LOG_RATE,
+                 last_batch_iteration: int = -1):
+
+        self.total_num_steps = total_num_steps
+        super(WarmupDecayLR, self).__init__(optimizer, warmup_min_lr, warmup_max_lr, warmup_num_steps, warmup_type,
+                                            last_batch_iteration)
+        if self.total_num_steps < self.warmup_num_steps:
+            logger.warning('total_num_steps {} is less than warmup_num_steps {}'.format(
+                total_num_steps, warmup_num_steps))
+
+    def _get_gamma(self):
+        if self.last_batch_iteration < self.warmup_num_steps:
+            if self.warmup_type == WARMUP_LOG_RATE:
+                return self.inverse_log_warm_up * math.log(self.last_batch_iteration + 1)
+            elif self.warmup_type == WARMUP_LINEAR_RATE:
+                return self.last_batch_iteration / self.warmup_num_steps
+        return max(
+            0.0,
+            float(self.total_num_steps - self.last_batch_iteration) /
+            float(max(1.0, self.total_num_steps - self.warmup_num_steps)))
+
+
+class WarmupCosineLR(object):
+    """Increase the learning rate of each parameter group from min lr ratio to max lr ratio
+        over warmup_num_steps steps, and then decay at cosine rate over the remaining training steps to min cosine ratio.
+
+        Args:
+            optimizer (Optimizer): Wrapped optimizer.
+            total_num_steps (int): total number of training steps
+            warmup_min_ratio (float or list): warmup start learning rate ratio. Default: 0
+            warmup_num_steps (int): number of steps to warm up from warmup_min_ratio to 1.0. Default: 1000
+            warmup_type {‘log’, ‘linear’}: increasing function from min_lr to max_lr during warmup. Default: log
+            cos_min_ratio (float): cosine end learning rate ratio. Default: 0.0001
+            last_batch_iteration (int): The index of the last batch. Default: -1.
+        Example:
+            >>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
+            >>> scheduler = WarmupCosineLR(optimizer, 1000000)
+            >>> data_loader = torch.utils.data.DataLoader(...)
+            >>> for epoch in range(10):
+            >>>     for batch in data_loader:
+            >>>         train_batch(...)
+            >>>         scheduler.step()
+
+    """
+
+    def __init__(self,
+                 optimizer: Optimizer,
+                 total_num_steps: int,
+                 warmup_min_ratio: float = 0.0,
+                 warmup_num_steps: int = 1000,
+                 cos_min_ratio: float = 0.0001,
+                 warmup_type: str = WARMUP_LOG_RATE,
+                 last_batch_iteration: int = -1):
+
+        self.optimizer = get_torch_optimizer(optimizer)
+
+        self.total_num_steps = total_num_steps
+        self.last_batch_iteration = last_batch_iteration
+        self.cos_min_ratio = cos_min_ratio
+
+        self.warmup_type = warmup_type
+        self.warmup_min_ratio = warmup_min_ratio
+        self.warmup_num_steps = max(2, warmup_num_steps)
+        self.inverse_log_warm_up = 1.0 / math.log(self.warmup_num_steps)
+
+        if self.total_num_steps < self.warmup_num_steps:
+            logger.warning('total_num_steps {} is less than warmup_num_steps {}'.format(
+                total_num_steps, warmup_num_steps))
+        self.org_lrs = [group['lr'] for group in self.optimizer.param_groups]
+
+    def get_lr_ratio(self):
+        if self.last_batch_iteration < 0:
+            logger.warning("Attempting to get learning rate from scheduler before it has started")
+            return [0.0]
+
+        if self.last_batch_iteration < self.warmup_num_steps:
+            if self.warmup_type == WARMUP_LOG_RATE:
+                ratio = self.inverse_log_warm_up * math.log(self.last_batch_iteration + 1)
+            elif self.warmup_type == WARMUP_LINEAR_RATE:
+                ratio = self.last_batch_iteration / self.warmup_num_steps
+            ratio_delta = 1. - self.warmup_min_ratio
+            ratio = self.warmup_min_ratio + ratio * ratio_delta
+            return ratio
+
+        real_last_step = self.last_batch_iteration - self.warmup_num_steps + 1
+        real_total_steps = self.total_num_steps - self.warmup_num_steps
+        ratio_delta = 1. - self.cos_min_ratio
+        ratio = (1 + math.cos(math.pi * real_last_step / real_total_steps)) / 2
+        ratio = max(0.0, self.cos_min_ratio + ratio_delta * ratio)
+        return ratio
+
+    def step(self, last_batch_iteration=None):
+        if last_batch_iteration is None:
+            last_batch_iteration = self.last_batch_iteration + 1
+        self.last_batch_iteration = last_batch_iteration
+
+        lrs = self.get_lr()
+        for param_group, lr in zip(self.optimizer.param_groups, lrs):
+            param_group['lr'] = lr
+        self._last_lr = [group['lr'] for group in self.optimizer.param_groups]
+
+    def get_lr(self):
+        if self.last_batch_iteration < 0:
+            logger.warning("Attempting to get learning rate from scheduler before it has started")
+            return [0.0]
+        lr_ratio = self.get_lr_ratio()
+        return [org_lr * lr_ratio for org_lr in self.org_lrs]
+
+    def get_last_lr(self):
+        """ Return last computed learning rate by current scheduler.
+        """
+        assert getattr(self, '_last_lr', None) is not None, "need to call step() first"
+        return self._last_lr
+
+    def state_dict(self):
+        return {'last_batch_iteration': self.last_batch_iteration}
+
+    def load_state_dict(self, sd):
+        self.last_batch_iteration = sd['last_batch_iteration']
+
+    def _format_param(self, optimizer, param_value, param_name):
+        if isinstance(param_value, list) or isinstance(param_value, tuple):
+            if len(param_value) != len(optimizer.param_groups):
+                raise ValueError("expected {} value for {}, got {}".format(len(optimizer.param_groups), param_name,
+                                                                           FileNotFoundError(param_value)))
+            return list(param_value)
+        return [param_value] * len(optimizer.param_groups)

venv/lib/python3.10/site-packages/deepspeed/runtime/quantize.py

@@ -0,0 +1,180 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+import math
+from deepspeed.utils import logger
+from deepspeed.ops.quantizer import ds_quantizer
+
+TWO_D_PARAMS = 6
+
+
+class Quantizer(object):
+
+    def __init__(self,
+                 q_groups=1,
+                 q_mixed_fp16=False,
+                 q_change_ratio=0.01,
+                 q_type=0,
+                 q_rounding=0,
+                 q_verbose=False,
+                 q_eigenvalue=False,
+                 use_quantizer_kernel=False,
+                 layer_num=0):
+
+        self.q_groups = q_groups
+        self.q_mixed_fp16 = q_mixed_fp16
+        self.q_change_ratio = q_change_ratio
+        self.q_type = q_type
+        self.qsteps = 0
+        self.quantize_real_ratio = 1.000
+        self.q_verbose = q_verbose
+        self.q_eigenvalue = q_eigenvalue
+        self.use_quantizer_kernel = use_quantizer_kernel
+        self.q_rounding = q_rounding
+        self.layer_num = layer_num
+
+    def any_precision_switch(self):
+        # Temporary disabled functionality
+        if self.layer_num == 0:
+            return True
+        result = False
+        for index in range(self.layer_num):
+            if self.q_start_bits[index] != self.q_target_bits:
+                next_step = self.qsteps + (TWO_D_PARAMS * (self.layer_num if self.layer_num != 0 else 1))
+                if next_step >= self.q_period[index]:
+                    result = True
+        return result
+
+    def quantize(self, parameter_group, overflow, eigenvalue_enabled, block_eigenvalue={}):
+
+        if overflow and not eigenvalue_enabled:
+            return
+
+        self.step()
+
+        self.update_fp16_ratio()
+
+        for i in range(len(parameter_group)):
+            for p in parameter_group[i]:
+                if len(p.size()) > 1 and hasattr(p, "start_bits") and p.start_bits:
+                    param_id = id(p)
+                    if block_eigenvalue is None:
+                        eigenvalue, layer_id = None, 0
+                    else:
+                        eigenvalue, layer_id = block_eigenvalue[param_id] if param_id in block_eigenvalue else (None,
+                                                                                                                0)
+                    if eigenvalue is not None:
+                        factor = 1 + math.floor(eigenvalue * 4)
+                        p.data = self.compute_quantization(p.data, layer_id, factor)
+                    else:
+                        p.data = self.compute_quantization(p, layer_id)
+
+    def step(self):
+        self.qsteps += 1
+
+    def quantize_highbit(self, inputs, num_bits):
+
+        q_range = 2**num_bits
+        input_flat = inputs.reshape(self.q_groups, -1)
+        g_min = input_flat.amin(dim=-1, keepdim=True)
+        g_max = input_flat.amax(dim=-1, keepdim=True)
+
+        # Random number generator (Uniform)
+        if self.q_rounding == 'nearest':
+            p = 0.
+        else:
+            p = input_flat.new(input_flat.shape).uniform_(-0.5, 0.5)
+
+        if self.q_type == 'symmetric':
+            scale = 2 * torch.max(torch.abs(g_min), torch.abs(g_max)) / q_range
+            zero_point = 0.
+            input_flat = (input_flat / scale + p).round().clamp(-(q_range >> 1), (q_range >> 1) - 1) * scale
+        elif self.q_type == 'asymmetric':
+            scale = (g_max - g_min) / q_range
+            zero_point = (g_min / scale).round() * scale
+            input_flat = ((input_flat - zero_point) / scale + p).round().clamp(0, (q_range - 1)) * scale + zero_point
+        output = input_flat.reshape(inputs.shape).contiguous()
+        return output
+
+    def quantize_tenary(self, inputs):
+        input_flat = inputs.reshape(self.q_groups, -1)
+        n = input_flat.shape[1]
+        m = input_flat.norm(p=1, dim=1).div(n)
+        thres = (0.7 * m).view(-1, 1)  #.expand_as(input_flat)
+        pos = (input_flat > thres).type(inputs.type())
+        neg = (input_flat < -thres).type(inputs.type())
+        mask = (input_flat.abs() > thres).type(inputs.type())
+        alpha = ((mask * input_flat).abs().sum(dim=1) / mask.sum(dim=1)).view(-1, 1)
+        output = alpha * pos - alpha * neg
+        output = output.reshape(inputs.shape).contiguous()
+        return output
+
+    def quantize_binary(self, inputs):
+        input_flat = inputs.reshape(self.q_groups, -1)
+        n = input_flat.shape[1]
+        m = input_flat.norm(p=1, dim=1, keepdim=True).div(n)
+        output = input_flat.sign().mul(m)
+        output = output.reshape(inputs.shape).contiguous()
+        return output
+
+    def mixed_fp16_quantize(self, input, input_q, index):
+        if self.q_mixed_fp16 and self.q_start_bits[index] >= (self.q_target_bits - 1):
+            input_q = input * self.quantize_real_ratio + (1 - self.quantize_real_ratio) * input_q
+            return input_q
+        return input_q
+
+    def compute_quantization(self, input, index=0, factor=1):
+        # fixing the quantization bits based on the training steps
+        # when reducing 1 bit at each period, we increase the period
+        # to go slowly toward the target quantization bits
+        # the period and starting bit can be configured
+
+        if input.start_bits != input.target_bits:
+            if self.qsteps >= input.q_period:
+                self.quantize_real_ratio = 1.0
+                input.q_period <<= 1
+                input.q_period *= factor
+                input.start_bits -= 1
+                if self.q_verbose:
+                    logger.info(
+                        f'Quantization settings: current bit-precision = {input.start_bits}, step = {self.qsteps}, quantization period = {input.q_period}, index = {index}'
+                    )
+        assert (input.start_bits >= input.target_bits), \
+            'Quantization bit is lower than target precision bits!'
+
+        if self.use_quantizer_kernel:
+            if input.start_bits <= 2:
+                raise ValueError('Quantization bit is too low, please do it without quantization kernel!')
+            input_q = ds_quantizer(input.data.clone(),
+                                   self.q_groups,
+                                   input.start_bits,
+                                   asym=False if self.q_type == 'symmetric' else True,
+                                   sr=False if self.q_rounding == 'nearest_neighbor' else True)
+        else:
+            if input.start_bits >= 3:
+                input_flat = self.quantize_highbit(input.data, input.start_bits)
+            elif input.start_bits == 2:
+                assert self.q_type == 'symmetric', 'Quantization type is not symmetric!'
+                assert self.q_rounding == 'nearest', 'Quantization rounding is not nearest_neighbor!'
+                input_flat = self.quantize_tenary(input.data)
+            elif input.start_bits == 1:
+                assert self.q_type == 'symmetric', 'Quantization type is not symmetric!'
+                assert self.q_rounding == 'nearest', 'Quantization rounding is not nearest_neighbor!'
+                input_flat = self.quantize_binary(input.data)
+        if self.use_quantizer_kernel:
+            return self.mixed_fp16_quantize(input.data, input_q, index)
+        else:
+            if self.q_mixed_fp16 and input.start_bits >= input.target_bits - 1:
+                input_flat = self.quantize_real_ratio * input.data + \
+                              (1 - self.quantize_real_ratio) * input_flat
+            return input_flat
+
+    def update_fp16_ratio(self):
+        if self.q_mixed_fp16:
+            if self.quantize_real_ratio > 0:
+                self.quantize_real_ratio -= self.q_change_ratio
+            else:
+                self.quantize_real_ratio = 0.000

venv/lib/python3.10/site-packages/deepspeed/utils/__init__.py

@@ -0,0 +1,22 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .logging import logger, log_dist
+from .comms_logging import get_caller_func
+#from .distributed import init_distributed
+from .init_on_device import OnDevice
+from .groups import *
+from .nvtx import instrument_w_nvtx
+# TODO: Move tensor fragment and mixed precision to zero utils
+from .tensor_fragment import tensor_fragment, get_full_hp_param, get_hp_fragment_mapping, fragment_address, get_full_hp_grad, map_to_flat_opt_states
+from .tensor_fragment import safe_get_full_fp32_param, safe_get_full_grad, safe_get_full_optimizer_state
+from .tensor_fragment import set_full_hp_param
+from .tensor_fragment import safe_set_full_fp32_param, safe_set_full_optimizer_state
+from .tensor_fragment import safe_get_local_fp32_param, safe_get_local_grad, safe_get_local_optimizer_state
+from .tensor_fragment import safe_set_local_fp32_param, safe_set_local_optimizer_state
+from .z3_leaf_module import set_z3_leaf_modules, unset_z3_leaf_modules, get_z3_leaf_modules, z3_leaf_module, z3_leaf_parameter
+from .mixed_precision_linkage import link_hp_params, lazy_init_hp_params_optimizer_state
+from deepspeed.runtime.dataloader import RepeatingLoader
+from .numa import get_numactl_cmd