Add files using upload-large-folder tool

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

@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .abstract_accelerator import DeepSpeedAccelerator
+from .real_accelerator import get_accelerator, set_accelerator, is_current_accelerator_supported

venv/lib/python3.10/site-packages/deepspeed/accelerator/abstract_accelerator.py

@@ -0,0 +1,297 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import abc
+from abc import ABC
+
+
+class DeepSpeedAccelerator(ABC):
+
+    def __init__(self):
+        self._name = None
+        self._communication_backend_name = None
+
+    @abc.abstractmethod
+    def is_synchronized_device(self):
+        ...
+
+    @abc.abstractmethod
+    def use_host_timers(self):
+        ...
+
+    @abc.abstractmethod
+    def resolves_data_dependency(self):
+        ...
+
+    @abc.abstractmethod
+    def handles_memory_backpressure(self):
+        ...
+
+    # Device APIs
+    @abc.abstractmethod
+    def device_name(self, device_index):
+        ...
+
+    @abc.abstractmethod
+    def device(self, device_index):
+        ...
+
+    @abc.abstractmethod
+    def set_device(self, device_index):
+        ...
+
+    @abc.abstractmethod
+    def current_device(self):
+        ...
+
+    @abc.abstractmethod
+    def current_device_name(self):
+        ...
+
+    @abc.abstractmethod
+    def device_count(self):
+        ...
+
+    @abc.abstractmethod
+    def synchronize(self, device_index=None):
+        ...
+
+    # RNG APIs
+    @abc.abstractmethod
+    def random(self):
+        ...
+
+    @abc.abstractmethod
+    def set_rng_state(self, new_state, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def get_rng_state(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def manual_seed(self, seed):
+        ...
+
+    @abc.abstractmethod
+    def manual_seed_all(self, seed):
+        ...
+
+    @abc.abstractmethod
+    def initial_seed(self, seed):
+        ...
+
+    @abc.abstractmethod
+    def default_generator(self, device_index):
+        ...
+
+    # Streams/Events
+    @property
+    @abc.abstractmethod
+    def Stream(self):
+        ...
+
+    @abc.abstractmethod
+    def stream(self, stream):
+        ...
+
+    @abc.abstractmethod
+    def current_stream(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def default_stream(self, device_index=None):
+        ...
+
+    @property
+    @abc.abstractmethod
+    def Event(self):
+        ...
+
+    # Memory management
+    @abc.abstractmethod
+    def empty_cache(self):
+        ...
+
+    @abc.abstractmethod
+    def memory_allocated(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def max_memory_allocated(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def reset_max_memory_allocated(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def memory_cached(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def max_memory_cached(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def reset_max_memory_cached(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def memory_stats(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def reset_peak_memory_stats(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def memory_reserved(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def max_memory_reserved(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def total_memory(self, device_index=None):
+        ...
+
+    @abc.abstractmethod
+    def available_memory(self, device_index=None):
+        ...
+
+    # Data types
+    @abc.abstractmethod
+    def is_bf16_supported(self):
+        ...
+
+    @abc.abstractmethod
+    def is_fp16_supported(self):
+        ...
+
+    @abc.abstractmethod
+    def supported_dtypes(self):
+        ...
+
+    # Misc
+    @abc.abstractmethod
+    def amp(self):
+        ...
+
+    @abc.abstractmethod
+    def is_available(self):
+        ...
+
+    @abc.abstractmethod
+    def range_push(self, msg):
+        ...
+
+    @abc.abstractmethod
+    def range_pop(self):
+        ...
+
+    @abc.abstractmethod
+    def lazy_call(self, callback):
+        ...
+
+    @abc.abstractmethod
+    def communication_backend_name(self):
+        ...
+
+    @abc.abstractmethod
+    def is_triton_supported(self):
+        ...
+
+    # Graph operations
+    @abc.abstractmethod
+    def create_graph(self):
+        ...
+
+    @abc.abstractmethod
+    def capture_to_graph(self, graph, pool=None, stream=None):
+        ...
+
+    @abc.abstractmethod
+    def replay_graph(self, graph):
+        ...
+
+    # Tensor operations
+    @property
+    @abc.abstractmethod
+    def BFloat16Tensor(self):
+        ...
+
+    @property
+    @abc.abstractmethod
+    def ByteTensor(self):
+        ...
+
+    @property
+    @abc.abstractmethod
+    def DoubleTensor(self):
+        ...
+
+    @property
+    @abc.abstractmethod
+    def FloatTensor(self):
+        ...
+
+    @property
+    @abc.abstractmethod
+    def HalfTensor(self):
+        ...
+
+    @property
+    @abc.abstractmethod
+    def IntTensor(self):
+        ...
+
+    @property
+    @abc.abstractmethod
+    def LongTensor(self):
+        ...
+
+    @abc.abstractmethod
+    def pin_memory(self, tensor, align_bytes=1):
+        ...
+
+    @abc.abstractmethod
+    def is_pinned(self, tensor):
+        ...
+
+    @abc.abstractmethod
+    def on_accelerator(self, tensor):
+        ...
+
+    @abc.abstractmethod
+    def op_builder_dir(self):
+        ...
+
+    # create an instance of op builder, specified by class_name
+    @abc.abstractmethod
+    def create_op_builder(self, class_name):
+        ...
+
+    # return an op builder class, specified by class_name
+    @abc.abstractmethod
+    def get_op_builder(self, class_name):
+        ...
+
+    @abc.abstractmethod
+    def build_extension(self):
+        ...
+
+    @abc.abstractmethod
+    def export_envs(self):
+        ...
+
+    @abc.abstractmethod
+    def visible_devices_envs(self):
+        ...
+
+    @abc.abstractmethod
+    def set_visible_devices_envs(self, current_env, local_accelerator_ids):
+        ...

venv/lib/python3.10/site-packages/deepspeed/accelerator/cpu_accelerator.py

@@ -0,0 +1,332 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+from .abstract_accelerator import DeepSpeedAccelerator
+
+try:
+    import oneccl_bindings_for_pytorch  # noqa: F401 # type: ignore
+    oneccl_imported_p = True
+except ImportError as e:
+    oneccl_imported_p = False
+
+import os
+
+
+# accelerator for Intel CPU
+class CPU_Accelerator(DeepSpeedAccelerator):
+
+    def __init__(self):
+        self._name = 'cpu'
+        if oneccl_imported_p:
+            self._communication_backend_name = 'ccl'
+        else:
+            # fallback to gloo if oneccl_binding_for_pytorch is not installed
+            self._communication_backend_name = 'gloo'
+        try:
+            import psutil
+            mem = psutil.Process().memory_info().rss
+            self.max_mem = mem
+        except ImportError as e:
+            self.max_mem = 0
+
+    def is_synchronized_device(self):
+        return True
+
+    def use_host_timers(self):
+        return self.is_synchronized_device()
+
+    def resolves_data_dependency(self):
+        return self.is_synchronized_device()
+
+    def handles_memory_backpressure(self):
+        return self.is_synchronized_device()
+
+    # Device APIs
+    def device_name(self, device_index=None):
+        return 'cpu'
+
+    def device(self, device_index=None):
+        return None
+
+    def set_device(self, device_index):
+        return
+
+    def current_device(self):
+        return os.environ.get('LOCAL_RANK', 0)
+
+    def current_device_name(self):
+        return 'cpu'
+
+    def device_count(self):
+        device_count = int(os.environ.get('LOCAL_SIZE', 0))
+        if device_count > 0:
+            return device_count
+        else:
+            from deepspeed.utils.numa import get_numa_cores
+            # Count NUMA node for number of cpu accelerators. On machine with HBM
+            # In flat mode, HBM is in separate NUMA node with no cores on this node.
+            # Ignore these NUMA nodes with no cores.
+            numa_core_lists = get_numa_cores()
+            numa_count = 0
+            prev_core_list = []
+            for core_list in numa_core_lists:
+                if len(core_list) > 0 and core_list != prev_core_list:
+                    numa_count += 1
+                    prev_core_list = core_list
+            return numa_count
+
+    def synchronize(self, device_index=None):
+        return
+
+    # RNG APIs
+    def random(self):
+        return torch.random
+
+    def set_rng_state(self, new_state, device_index=None):
+        if device_index is None:
+            return torch.set_rng_state(new_state)
+        return torch.set_rng_state(new_state, device_index)
+
+    def get_rng_state(self, device_index=None):
+        return torch.get_rng_state()
+
+    def manual_seed(self, seed):
+        return torch.manual_seed(seed)
+
+    def manual_seed_all(self, seed):
+        return torch.manual_seed(seed)
+
+    def initial_seed(self, seed):
+        return torch.initial_seed(seed)
+
+    def default_generator(self, device_index):
+        return torch.default_generator
+
+    # Streams/Events
+    @property
+    def Stream(self):
+        return None
+
+    def stream(self, stream):
+        from deepspeed.runtime.utils import noop_context
+        return noop_context()
+
+    def current_stream(self, device_index=None):
+        return None
+
+    def default_stream(self, device_index=None):
+        return None
+
+    @property
+    def Event(self):
+        return None
+
+    # Memory management
+    def empty_cache(self):
+        return
+
+    def get_rss(self):
+        import psutil
+        mem = psutil.Process().memory_info().rss
+        if mem > self.max_mem:
+            self.max_mem = mem
+        return mem
+
+    def reset_rss(self):
+        import psutil
+        mem = psutil.Process().memory_info().rss
+        self.max_mem = mem
+        return mem
+
+    def memory_allocated(self, device_index=None):
+        return self.get_rss()
+
+    def max_memory_allocated(self, device_index=None):
+        self.get_rss()
+        return self.max_mem
+
+    def reset_max_memory_allocated(self, device_index=None):
+        self.reset_rss()
+        return
+
+    def memory_cached(self, device_index=None):
+        return self.get_rss()
+
+    def max_memory_cached(self, device_index=None):
+        self.get_rss()
+        return self.max_mem
+
+    def reset_max_memory_cached(self, device_index=None):
+        self.reset_rss()
+        return
+
+    def memory_stats(self, device_index=None):
+        mem = self.get_rss()
+        mem_stat = {}
+        mem_stat['allocated_bytes.all.current'] = mem
+        mem_stat['allocated_bytes.all.peak'] = self.max_mem
+        return mem_stat
+
+    def reset_peak_memory_stats(self, device_index=None):
+        self.reset_rss()
+        return
+
+    def memory_reserved(self, device_index=None):
+        return self.get_rss()
+
+    def max_memory_reserved(self, device_index=None):
+        self.get_rss()
+        return self.max_mem
+
+    def total_memory(self, device_index=None):
+        import psutil
+        return psutil.virtual_memory().total
+
+    def available_memory(self, device_index=None):
+        import psutil
+        return psutil.virtual_memory().available
+
+    # Misc
+    def amp(self):
+        return torch.cpu.amp
+
+    def is_available(self):
+        return True
+
+    def range_push(self, msg):
+        # TODO itt is currently not supported yet
+        # return torch.profiler.itt.range_push(msg)
+        return
+
+    def range_pop(self):
+        # TODO itt is currently not supported yet
+        # return torch.profiler.itt.range_pop()
+        return
+
+    def lazy_call(self, callback):
+        return callback()
+
+    def communication_backend_name(self):
+        return self._communication_backend_name
+
+    def is_triton_supported(self):
+        return False
+
+    # Data types
+    def is_bf16_supported(self):
+        return True
+
+    def is_fp16_supported(self):
+        return False
+
+    def supported_dtypes(self):
+        return [torch.float, torch.bfloat16]
+
+    # Graph operations
+    def create_graph(self):
+        return None
+
+    def capture_to_graph(self, graph, pool=None, stream=None):
+        from deepspeed.runtime.utils import noop_context
+        return noop_context()
+
+    def replay_graph(self, graph):
+        return
+
+    # Tensor operations
+    @property
+    def BFloat16Tensor(self):
+        return torch.BFloat16Tensor
+
+    @property
+    def ByteTensor(self):
+        return torch.ByteTensor
+
+    @property
+    def DoubleTensor(self):
+        return torch.DoubleTensor
+
+    @property
+    def FloatTensor(self):
+        return torch.FloatTensor
+
+    @property
+    def HalfTensor(self):
+        return torch.HalfTensor
+
+    @property
+    def IntTensor(self):
+        return torch.IntTensor
+
+    @property
+    def LongTensor(self):
+        return torch.LongTensor
+
+    def pin_memory(self, tensor, align_bytes=1):
+        return tensor
+
+    def is_pinned(self, tensor):
+        return tensor.is_pinned()
+
+    def op_builder_dir(self):
+        try:
+            # is op_builder from deepspeed or a 3p version? this should only succeed if it's deepspeed
+            # if successful this also means we're doing a local install and not JIT compile path
+            from op_builder import __deepspeed__  # noqa: F401 # type: ignore
+            return "op_builder.cpu"
+        except ImportError:
+            return "deepspeed.ops.op_builder.cpu"
+
+    def on_accelerator(self, tensor):
+        device_str = str(tensor.device)
+        if device_str.startswith('cpu'):
+            return True
+        else:
+            return False
+
+    # create an instance of op builder and return, name specified by class_name
+    def create_op_builder(self, op_name):
+        builder_class = self.get_op_builder(op_name)
+        if builder_class is not None:
+            return builder_class()
+        return None
+
+    # return an op builder class, name specified by class_name
+    def get_op_builder(self, class_name):
+        try:
+            # is op_builder from deepspeed or a 3p version? this should only succeed if it's deepspeed
+            # if successful this also means we're doing a local install and not JIT compile path
+            from op_builder import __deepspeed__  # noqa: F401 # type: ignore
+            from op_builder.cpu import CCLCommBuilder, ShareMemCommBuilder, FusedAdamBuilder, CPUAdamBuilder, NotImplementedBuilder
+        except ImportError:
+            from deepspeed.ops.op_builder.cpu import CCLCommBuilder, ShareMemCommBuilder, FusedAdamBuilder, CPUAdamBuilder, NotImplementedBuilder
+
+        if class_name == "CCLCommBuilder":
+            return CCLCommBuilder
+        elif class_name == "ShareMemCommBuilder":
+            return ShareMemCommBuilder
+        elif class_name == "FusedAdamBuilder":
+            return FusedAdamBuilder
+        elif class_name == "CPUAdamBuilder":
+            return CPUAdamBuilder
+        else:
+            # return a NotImplementedBuilder to avoid get NoneType[Name] in unit tests
+            return NotImplementedBuilder
+
+    def build_extension(self):
+        from torch.utils.cpp_extension import BuildExtension
+        return BuildExtension
+
+    def export_envs(self):
+        return []
+
+    # TODO: cpu's visible envs is confirmed, keep as CUDA_VISIBLE_DEVICES
+    def visible_devices_envs(self):
+        return ['CUDA_VISIBLE_DEVICES']
+
+    def set_visible_devices_envs(self, current_env, local_accelerator_ids):
+        for env in self.visible_devices_envs():
+            current_env[env] = ",".join(map(str, local_accelerator_ids))

venv/lib/python3.10/site-packages/deepspeed/accelerator/cuda_accelerator.py

@@ -0,0 +1,369 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import functools
+import os
+import pkgutil
+import importlib
+
+from .abstract_accelerator import DeepSpeedAccelerator
+# During setup stage torch may not be installed, pass on no torch will
+# allow op builder related API to be executed.
+try:
+    import torch.cuda
+except ImportError:
+    pass
+
+# Delay import pynvml to avoid import error when CUDA is not available
+pynvml = None
+
+
+class CUDA_Accelerator(DeepSpeedAccelerator):
+
+    def __init__(self):
+        self._name = 'cuda'
+        self._communication_backend_name = 'nccl'
+        if pynvml is None:
+            self._init_pynvml()
+
+    def _init_pynvml(self):
+        global pynvml
+        try:
+            import pynvml
+        except ImportError:
+            return
+        try:
+            pynvml.nvmlInit()
+        except pynvml.NVMLError:
+            pynvml = None
+            return
+
+    def is_synchronized_device(self):
+        return False
+
+    def use_host_timers(self):
+        return self.is_synchronized_device()
+
+    def resolves_data_dependency(self):
+        return self.is_synchronized_device()
+
+    def handles_memory_backpressure(self):
+        return self.is_synchronized_device()
+
+    # Device APIs
+    def device_name(self, device_index=None):
+        if device_index is None:
+            return 'cuda'
+        return 'cuda:{}'.format(device_index)
+
+    def device(self, device_index=None):
+        return torch.cuda.device(device_index)
+
+    def set_device(self, device_index):
+        torch.cuda.set_device(device_index)
+
+    def current_device(self):
+        return torch.cuda.current_device()
+
+    def current_device_name(self):
+        return 'cuda:{}'.format(torch.cuda.current_device())
+
+    def device_count(self):
+        return torch.cuda.device_count()
+
+    def synchronize(self, device_index=None):
+        return torch.cuda.synchronize(device_index)
+
+    # RNG APIs
+    def random(self):
+        return torch.random
+
+    def set_rng_state(self, new_state, device_index=None):
+        if device_index is None:
+            return torch.cuda.set_rng_state(new_state)
+
+        return torch.cuda.set_rng_state(new_state, device_index)
+
+    def get_rng_state(self, device_index=None):
+        if device_index is None:
+            return torch.cuda.get_rng_state()
+
+        return torch.cuda.get_rng_state(device_index)
+
+    def manual_seed(self, seed):
+        return torch.cuda.manual_seed(seed)
+
+    def manual_seed_all(self, seed):
+        return torch.cuda.manual_seed_all(seed)
+
+    def initial_seed(self, seed):
+        return torch.cuda.initial_seed(seed)
+
+    def default_generator(self, device_index):
+        return torch.cuda.default_generators[device_index]
+
+    # Streams/Events
+    @property
+    def Stream(self):
+        return torch.cuda.Stream
+
+    def stream(self, stream):
+        return torch.cuda.stream(stream)
+
+    def current_stream(self, device_index=None):
+        return torch.cuda.current_stream(device_index)
+
+    def default_stream(self, device_index=None):
+        return torch.cuda.default_stream(device_index)
+
+    @property
+    def Event(self):
+        return torch.cuda.Event
+
+    # Memory management
+    def empty_cache(self):
+        return torch.cuda.empty_cache()
+
+    def memory_allocated(self, device_index=None):
+        return torch.cuda.memory_allocated(device_index)
+
+    def max_memory_allocated(self, device_index=None):
+        return torch.cuda.max_memory_allocated(device_index)
+
+    def reset_max_memory_allocated(self, device_index=None):
+        return torch.cuda.reset_max_memory_allocated(device_index)
+
+    def memory_cached(self, device_index=None):
+        return torch.cuda.memory_cached(device_index)
+
+    def max_memory_cached(self, device_index=None):
+        return torch.cuda.max_memory_cached(device_index)
+
+    def reset_max_memory_cached(self, device_index=None):
+        return torch.cuda.reset_max_memory_cached(device_index)
+
+    def memory_stats(self, device_index=None):
+        if hasattr(torch.cuda, 'memory_stats'):
+            return torch.cuda.memory_stats(device_index)
+
+    def reset_peak_memory_stats(self, device_index=None):
+        if hasattr(torch.cuda, 'reset_peak_memory_stats'):
+            return torch.cuda.reset_peak_memory_stats(device_index)
+
+    def memory_reserved(self, device_index=None):
+        if hasattr(torch.cuda, 'memory_reserved'):
+            return torch.cuda.memory_reserved(device_index)
+
+    def max_memory_reserved(self, device_index=None):
+        if hasattr(torch.cuda, 'max_memory_reserved'):
+            return torch.cuda.max_memory_reserved(device_index)
+
+    def total_memory(self, device_index=None):
+        return torch.cuda.get_device_properties(device_index).total_memory
+
+    def _get_nvml_gpu_id(self, torch_gpu_id):
+        """
+        credit: https://discuss.pytorch.org/t/making-pynvml-match-torch-device-ids-cuda-visible-devices/103020
+
+        Remap torch device id to nvml device id, respecting CUDA_VISIBLE_DEVICES.
+
+        If the latter isn't set return the same id
+        """
+        # if CUDA_VISIBLE_DEVICES is used automagically remap the id since pynvml ignores this env var
+        if "CUDA_VISIBLE_DEVICES" in os.environ:
+            ids = list(map(int, os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",")))
+            return ids[torch_gpu_id]  # remap
+        else:
+            return torch_gpu_id
+
+    def available_memory(self, device_index=None):
+        if pynvml:
+            if device_index is None:
+                device_index = self.current_device()
+            handle = pynvml.nvmlDeviceGetHandleByIndex(self._get_nvml_gpu_id(device_index))
+            info = pynvml.nvmlDeviceGetMemoryInfo(handle)
+            return info.free
+        else:
+            return self.total_memory(device_index) - self.memory_allocated(device_index)
+
+    # Data types
+    def is_bf16_supported(self):
+        if not torch.cuda.is_available():
+            return True
+        return torch.cuda.is_bf16_supported()
+
+    def is_fp16_supported(self):
+        if not torch.cuda.is_available():
+            return True
+        # See https://docs.nvidia.com/deeplearning/tensorrt/support-matrix/index.html#hardware-precision-matrix
+        # FP16 on compute capability 6.x is deprecated
+        allow_deprecated_fp16 = os.environ.get('DS_ALLOW_DEPRECATED_FP16', '0') == '1'
+        major, _ = torch.cuda.get_device_capability()
+        if major >= 7:
+            return True
+        elif major == 6 and allow_deprecated_fp16:
+            return True
+        else:
+            return False
+
+    def supported_dtypes(self):
+        supported_dtypes = [torch.float]
+        if self.is_fp16_supported():
+            supported_dtypes.append(torch.half)
+        if self.is_bf16_supported():
+            supported_dtypes.append(torch.bfloat16)
+        return supported_dtypes
+
+    # Misc
+    def amp(self):
+        if hasattr(torch.cuda, 'amp'):
+            return torch.cuda.amp
+        return None
+
+    def is_available(self):
+        return torch.cuda.is_available()
+
+    def range_push(self, msg):
+        if hasattr(torch.cuda.nvtx, 'range_push'):
+            return torch.cuda.nvtx.range_push(msg)
+
+    def range_pop(self):
+        if hasattr(torch.cuda.nvtx, 'range_pop'):
+            return torch.cuda.nvtx.range_pop()
+
+    def lazy_call(self, callback):
+        return torch.cuda._lazy_call(callback)
+
+    def communication_backend_name(self):
+        return self._communication_backend_name
+
+    def is_triton_supported(self):
+        major, _ = torch.cuda.get_device_capability()
+        if major >= 8:
+            return True
+        else:
+            return False
+
+    # Graph operations
+    def create_graph(self):
+        return torch.cuda.CUDAGraph()
+
+    def capture_to_graph(self, graph, pool=None, stream=None):
+        return torch.cuda.graph(graph, pool, stream)
+
+    def replay_graph(self, graph):
+        graph.replay()
+        return
+
+    # Tensor operations
+
+    @property
+    def BFloat16Tensor(self):
+        return functools.partial(torch.tensor, dtype=torch.bfloat16, device='cuda')
+
+    @property
+    def ByteTensor(self):
+        return functools.partial(torch.tensor, dtype=torch.uint8, device='cuda')
+
+    @property
+    def DoubleTensor(self):
+        return functools.partial(torch.tensor, dtype=torch.double, device='cuda')
+
+    @property
+    def FloatTensor(self):
+        return functools.partial(torch.tensor, dtype=torch.float, device='cuda')
+
+    @property
+    def HalfTensor(self):
+        return functools.partial(torch.tensor, dtype=torch.half, device='cuda')
+
+    @property
+    def IntTensor(self):
+        return functools.partial(torch.tensor, dtype=torch.int, device='cuda')
+
+    @property
+    def LongTensor(self):
+        return functools.partial(torch.tensor, dtype=torch.long, device='cuda')
+
+    def pin_memory(self, tensor, align_bytes=1):
+        return tensor.pin_memory()
+
+    def is_pinned(self, tensor):
+        return tensor.is_pinned()
+
+    def on_accelerator(self, tensor):
+        device_str = str(tensor.device)
+        if device_str.startswith('cuda:'):
+            return True
+        else:
+            return False
+
+    def op_builder_dir(self):
+        try:
+            # is op_builder from deepspeed or a 3p version? this should only succeed if it's deepspeed
+            # if successful this also means we're doing a local install and not JIT compile path
+            from op_builder import __deepspeed__  # noqa: F401 # type: ignore
+            return "op_builder"
+        except ImportError:
+            return "deepspeed.ops.op_builder"
+
+    # dict that holds class name <--> class type mapping i.e.
+    # 'AsyncIOBuilder': <class 'op_builder.async_io.AsyncIOBuilder'>
+    # this dict will be filled at init stage
+    class_dict = None
+
+    def _lazy_init_class_dict(self):
+        if self.class_dict is not None:
+            return
+        else:
+            self.class_dict = {}
+            # begin initialize for create_op_builder()
+            # put all valid class name <--> class type mapping into class_dict
+            op_builder_dir = self.op_builder_dir()
+            op_builder_module = importlib.import_module(op_builder_dir)
+            op_builder_absolute_path = os.path.dirname(op_builder_module.__file__)
+            for _, module_name, _ in pkgutil.iter_modules([op_builder_absolute_path]):
+                # avoid self references,
+                # skip sub_directories which contains ops for other backend(cpu, npu, etc.).
+                if module_name != 'all_ops' and module_name != 'builder' and not os.path.isdir(
+                        os.path.join(op_builder_absolute_path, module_name)):
+                    module = importlib.import_module("{}.{}".format(op_builder_dir, module_name))
+                    for member_name in module.__dir__():
+                        if member_name.endswith(
+                                'Builder'
+                        ) and member_name != "OpBuilder" and member_name != "CUDAOpBuilder" and member_name != "TorchCPUOpBuilder":  # avoid abstract classes
+                            if not member_name in self.class_dict:
+                                self.class_dict[member_name] = getattr(module, member_name)
+            # end initialize for create_op_builder()
+
+    # create an instance of op builder and return, name specified by class_name
+    def create_op_builder(self, class_name):
+        self._lazy_init_class_dict()
+        if class_name in self.class_dict:
+            return self.class_dict[class_name]()
+        else:
+            return None
+
+    # return an op builder class, name specified by class_name
+    def get_op_builder(self, class_name):
+        self._lazy_init_class_dict()
+        if class_name in self.class_dict:
+            return self.class_dict[class_name]
+        else:
+            return None
+
+    def build_extension(self):
+        from torch.utils.cpp_extension import BuildExtension
+        return BuildExtension
+
+    def export_envs(self):
+        return ['NCCL']
+
+    def visible_devices_envs(self):
+        return ['CUDA_VISIBLE_DEVICES']
+
+    def set_visible_devices_envs(self, current_env, local_accelerator_ids):
+        for env in self.visible_devices_envs():
+            current_env[env] = ",".join(map(str, local_accelerator_ids))

venv/lib/python3.10/site-packages/deepspeed/accelerator/hpu_accelerator.py

@@ -0,0 +1,303 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import os
+import pkgutil
+import importlib
+import torch
+
+from .abstract_accelerator import DeepSpeedAccelerator
+
+
+class HPU_Accelerator(DeepSpeedAccelerator):
+
+    def __init__(self):
+        self._name = 'hpu'
+        self._communication_backend_name = 'hccl'
+        try:
+            import habana_frameworks.torch.hpu as hpu
+            hpu.setDeterministic(True)
+            self.hpu = hpu
+        except ImportError as e:
+            raise ValueError(
+                f"HPU_Accelerator requires habana_frameworks.torch.hpu, which is not installed on this system.")
+
+        self.fp16_supported = None
+
+    # Device APIs
+    def is_synchronized_device(self):
+        return False
+
+    def use_host_timers(self):
+        return False
+
+    def resolves_data_dependency(self):
+        return True
+
+    def handles_memory_backpressure(self):
+        return True
+
+    def device_name(self, device_index=None):
+        if device_index is None:
+            return 'hpu'
+        return 'hpu:{}'.format(device_index)
+
+    def device(self, device_index=None):
+        return torch.device(self.device_name(device_index))
+
+    def set_device(self, device_index):
+        self.hpu.set_device(device_index)
+
+    def current_device(self):
+        return (self.hpu.current_device())
+
+    def current_device_name(self):
+        return 'hpu:{}'.format(self.current_device())
+
+    def device_count(self):
+        return self.hpu.device_count()
+
+    def synchronize(self, device_index=None):
+        return self.hpu.synchronize()
+
+    # RNG APIs
+    def random(self):
+        return torch.random
+
+    def set_rng_state(self, new_state, device_index=None):
+        self.hpu.random.set_rng_state(new_state)
+
+    def get_rng_state(self, device_index=None):
+        return self.hpu.random.get_rng_state()
+
+    def manual_seed(self, seed):
+        self.hpu.random.manual_seed(seed)
+
+    def manual_seed_all(self, seed):
+        self.hpu.random.manual_seed_all(seed)
+
+    def initial_seed(self, seed):
+        self.hpu.random.initial_seed(seed)
+
+    def default_generator(self, device_index):
+        return self.hpu.random.default_generators[device_index]
+
+    # Streams/Events
+    @property
+    def Stream(self):
+        return self.hpu.Stream
+
+    def stream(self, stream):
+        return self.hpu.stream(stream)
+
+    def current_stream(self, device_index=None):
+        return self.hpu.current_stream()
+
+    def default_stream(self, device_index=None):
+        return self.hpu.default_stream()
+
+    @property
+    def Event(self):
+        import habana_frameworks.torch.core as htcore
+        return htcore.hpu.Event
+
+    # Memory management
+    def empty_cache(self):
+        return
+
+    def memory_allocated(self, device_index=None):
+        return self.hpu.memory_allocated()
+
+    def max_memory_allocated(self, device_index=None):
+        return self.hpu.max_memory_allocated()
+
+    def reset_max_memory_allocated(self, device_index=None):
+        return self.hpu.reset_max_memory_allocated()
+
+    def memory_cached(self, device_index=None):
+        return self.hpu.memory_cached(device_index)
+
+    def max_memory_cached(self, device_index=None):
+        return self.hpu.max_memory_cached(device_index)
+
+    def reset_max_memory_cached(self, device_index=None):
+        return None
+
+    def memory_stats(self, device_index=None):
+        return self.hpu.memory_stats(device_index)
+
+    def reset_peak_memory_stats(self, device_index=None):
+        self.hpu.reset_peak_memory_stats(device_index)
+
+    def memory_reserved(self, device_index=None):
+        return self.hpu.memory_reserved(device_index)
+
+    def max_memory_reserved(self, device_index=None):
+        return self.hpu.max_memory_reserved(device_index)
+
+    def total_memory(self, device_index=None):
+        return self.memory_stats(device_index)['Limit']
+
+    def available_memory(self, device_index=None):
+        return self.total_memory(device_index) - self.memory_allocated(device_index)
+
+    # Data types
+    def is_bf16_supported(self):
+        return True
+
+    def is_fp16_supported(self):
+        if self.fp16_supported is None:
+            import habana_frameworks.torch.utils.experimental as htexp
+            self.fp16_supported = htexp._is_fp16_supported()
+        return self.fp16_supported
+
+    def supported_dtypes(self):
+        supported_dtypes = [torch.float, torch.bfloat16]
+        if self.is_fp16_supported():
+            supported_dtypes.append(torch.half)
+        return supported_dtypes
+
+    # Misc
+    def amp(self):
+        return None
+
+    def is_available(self):
+        return self.hpu.is_available()
+
+    def range_push(self, msg):
+        return
+
+    def range_pop(self):
+        return
+
+    def lazy_call(self, callback):
+        callback()
+
+    def communication_backend_name(self):
+        return self._communication_backend_name
+
+    def is_triton_supported(self):
+        return False
+
+    # Graph operations
+    def create_graph(self):
+        return self.hpu.HPUGraph()
+
+    def capture_to_graph(self, graph, pool=None, stream=None):
+        return self.hpu.graph(graph, stream=stream)
+
+    def replay_graph(self, graph):
+        graph.replay()
+        return
+
+    # Tensor operations
+    @property
+    def BFloat16Tensor(self):
+        return self.hpu.BFloat16Tensor
+
+    @property
+    def ByteTensor(self):
+        return self.hpu.ByteTensor
+
+    @property
+    def DoubleTensor(self):
+        return self.hpu.DoubleTensor
+
+    @property
+    def FloatTensor(self):
+        return self.hpu.FloatTensor
+
+    @property
+    def HalfTensor(self):
+        return self.hpu.HalfTensor
+
+    @property
+    def IntTensor(self):
+        return self.hpu.IntTensor
+
+    @property
+    def LongTensor(self):
+        return self.hpu.LongTensor
+
+    def pin_memory(self, tensor, align_bytes=1):
+        return tensor.pin_memory(self.device())
+
+    def is_pinned(self, tensor):
+        return tensor.is_pinned()
+
+    def on_accelerator(self, tensor):
+        device_str = str(tensor.device)
+        if device_str.startswith('hpu:'):
+            return True
+        else:
+            return False
+
+    def op_builder_dir(self):
+        try:
+            # is op_builder from deepspeed or a 3p version? this should only succeed if it's deepspeed
+            # if successful this also means we're doing a local install and not JIT compile path
+            from op_builder import __deepspeed__  # noqa: F401 # type: ignore
+            return "op_builder.hpu"
+        except ImportError:
+            return "deepspeed.ops.op_builder.hpu"
+
+    # dict that holds class name <--> class type mapping i.e.
+    # 'AsyncIOBuilder': <class 'op_builder.async_io.AsyncIOBuilder'>
+    # this dict will be filled at init stage
+    class_dict = None
+
+    def _lazy_init_class_dict(self):
+        if self.class_dict is not None:
+            return
+        else:
+            self.class_dict = {}
+            # begin initialize for create_op_builder()
+            # put all valid class name <--> class type mapping into class_dict
+            op_builder_dir = self.op_builder_dir()
+            op_builder_module = importlib.import_module(op_builder_dir)
+            op_builder_absolute_path = os.path.dirname(op_builder_module.__file__)
+            for _, module_name, _ in pkgutil.iter_modules([op_builder_absolute_path]):
+                # avoid self references,
+                # skip sub_directories which contains ops for other backend(cpu, npu, etc.).
+                if module_name != 'all_ops' and module_name != 'builder' and not os.path.isdir(
+                        os.path.join(op_builder_absolute_path, module_name)):
+                    module = importlib.import_module("{}.{}".format(op_builder_dir, module_name))
+                    for member_name in module.__dir__():
+                        if member_name.endswith(
+                                'Builder'
+                        ) and member_name != "OpBuilder" and member_name != "CPUOpBuilder" and member_name != "TorchCPUOpBuilder":  # avoid abstract classes
+                            if not member_name in self.class_dict:
+                                self.class_dict[member_name] = getattr(module, member_name)
+            # end initialize for create_op_builder()
+
+    # create an instance of op builder and return, name specified by class_name
+    def create_op_builder(self, class_name):
+        self._lazy_init_class_dict()
+        if class_name in self.class_dict:
+            return self.class_dict[class_name]()
+        else:
+            return None
+
+    # return an op builder class, name specified by class_name
+    def get_op_builder(self, class_name):
+        self._lazy_init_class_dict()
+        if class_name in self.class_dict:
+            return self.class_dict[class_name]
+        else:
+            return self.class_dict['NotImplementedBuilder'] if 'NotImplementedBuilder' in self.class_dict else None
+
+    def build_extension(self):
+        from torch.utils.cpp_extension import BuildExtension
+        return BuildExtension
+
+    def export_envs(self):
+        return []
+
+    def visible_devices_envs(self):
+        return ['HABANA_VISIBLE_MODULES']
+
+    def set_visible_devices_envs(self, current_env, local_accelerator_ids):
+        for env in self.visible_devices_envs():
+            current_env[env] = ",".join(map(str, local_accelerator_ids))

venv/lib/python3.10/site-packages/deepspeed/accelerator/mps_accelerator.py

@@ -0,0 +1,269 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from .abstract_accelerator import DeepSpeedAccelerator
+
+# During setup stage torch may not be installed, pass on no torch will
+# allow op builder related API to be executed.
+try:
+    import torch.mps
+except ImportError:
+    pass
+
+
+class MPS_Accelerator(DeepSpeedAccelerator):
+
+    def __init__(self):
+        self._name = "mps"
+        self._communication_backend_name = None
+
+    def is_synchronized_device(self):
+        return False
+
+    def use_host_timers(self):
+        return self.is_synchronized_device()
+
+    def resolves_data_dependency(self):
+        return self.is_synchronized_device()
+
+    def handles_memory_backpressure(self):
+        return self.is_synchronized_device()
+
+    # Device APIs
+    def device_name(self, device_index=None):
+        if device_index is None:
+            return "mps"
+        return "mps:{}".format(device_index)
+
+    def device(self, device_index):
+        return torch.device("mps", index=0)
+
+    def set_device(self, device_index):
+        return
+
+    def current_device(self):
+        return torch.device("mps", index=0)
+
+    def current_device_name(self):
+        return "mps:0"
+
+    def device_count(self):
+        return 1
+
+    def synchronize(self, device_index=None):
+        return torch.mps.synchronize()
+
+    # RNG APIs
+    def random(self):
+        return torch.random
+
+    def set_rng_state(self, new_state, device_index=None):
+        return torch.mps.set_rng_state(new_state)
+
+    def get_rng_state(self, device_index=None):
+        return torch.mps.get_rng_state()
+
+    def manual_seed(self, seed):
+        return torch.mps.manual_seed(seed)
+
+    def manual_seed_all(self, seed):
+        return torch.mps.manual_seed(seed)
+
+    def seed(self):
+        return torch.mps.seed()
+
+    def initial_seed(self, seed):
+        return
+
+    def default_generator(self, device_index):
+        return
+
+    # Streams/Events
+    @property
+    def Stream(self):
+        return None
+
+    def stream(self, stream):
+        return None
+
+    def current_stream(self, device_index=None):
+        return None
+
+    def default_stream(self, device_index=None):
+        return None
+
+    @property
+    def Event(self):
+        return None
+
+    # Memory management
+    def empty_cache(self):
+        return torch.mps.empty_cache()
+
+    def memory_allocated(self, device_index=None):
+        return torch.mps.current_allocated_memory()
+
+    def max_memory_allocated(self, device_index=None):
+        return torch.mps.driver_allocated_memory()
+
+    def set_per_process_memory_fraction(self, fraction):
+        return torch.mps.set_per_process_memory_fraction(fraction)
+
+    def reset_max_memory_allocated(self, device_index=None):
+        return
+
+    def memory_cached(self, device_index=None):
+        return
+
+    def max_memory_cached(self, device_index=None):
+        return
+
+    def reset_max_memory_cached(self, device_index=None):
+        return
+
+    def memory_stats(self, device_index=None):
+        return
+
+    def reset_peak_memory_stats(self, device_index=None):
+        return
+
+    def memory_reserved(self, device_index=None):
+        return
+
+    def max_memory_reserved(self, device_index=None):
+        return
+
+    def total_memory(self, device_index=None):
+        return
+
+    def available_memory(self, device_index=None):
+        return
+
+    # Data types
+    def is_bf16_supported(self):
+        return False
+
+    def is_fp16_supported(self):
+        return False
+
+    def supported_dtypes(self):
+        return [torch.float]
+
+    # Misc
+    def amp(self):
+        return
+
+    def is_available(self):
+        return hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+
+    def range_push(self, msg):
+        return
+
+    def range_pop(self):
+        return
+
+    def lazy_call(self, callback):
+        return
+
+    def communication_backend_name(self):
+        return self._communication_backend_name
+
+    def is_triton_supported(self):
+        return False
+
+    # Graph operations
+    def create_graph(self):
+        return None
+
+    def capture_to_graph(self, graph, pool=None, stream=None):
+        from deepspeed.runtime.utils import noop_context
+        return noop_context()
+
+    def replay_graph(self, graph):
+        return
+
+    # Tensor operations
+    @property
+    def BFloat16Tensor(self):
+        return
+
+    @property
+    def ByteTensor(self):
+        return
+
+    @property
+    def DoubleTensor(self):
+        return
+
+    @property
+    def FloatTensor(self):
+        return
+
+    @property
+    def HalfTensor(self):
+        return
+
+    @property
+    def IntTensor(self):
+        return
+
+    @property
+    def LongTensor(self):
+        return
+
+    def pin_memory(self, tensor, align_bytes=1):
+        return tensor.pin_memory()
+
+    def is_pinned(self, tensor):
+        return tensor.is_pinned()
+
+    def on_accelerator(self, tensor):
+        device_str = str(tensor.device)
+        if device_str.startswith("mps"):
+            return True
+        else:
+            return False
+
+    def op_builder_dir(self):
+        try:
+            # is op_builder from deepspeed or a 3p version? this should only succeed if it's deepspeed
+            # if successful this also means we're doing a local install and not JIT compile path
+            from op_builder import __deepspeed__  # noqa: F401 # type: ignore
+
+            return "op_builder"
+        except ImportError:
+            return "deepspeed.ops.op_builder"
+
+    # create an instance of op builder, specified by class_name
+    def create_op_builder(self, op_name):
+        builder_class = self.get_op_builder(op_name)
+        if builder_class is not None:
+            return builder_class()
+        return None
+
+    # return an op builder class, specified by class_name
+    def get_op_builder(self, class_name):
+        from deepspeed.ops.op_builder.cpu import NotImplementedBuilder
+
+        return NotImplementedBuilder
+
+    def build_extension(self):
+        from torch.utils.cpp_extension import BuildExtension
+
+        return BuildExtension
+
+    def export_envs(self):
+        return []
+
+    # TODO: mpu's visible envs is confirmed, keep as CUDA_VISIBLE_DEVICES
+    def visible_devices_envs(self):
+        # TODO: could not find visible devices env for mps
+        return ['CUDA_VISIBLE_DEVICES']
+
+    def set_visible_devices_envs(self, current_env, local_accelerator_ids):
+        for env in self.visible_devices_envs():
+            current_env[env] = ",".join(map(str, local_accelerator_ids))

venv/lib/python3.10/site-packages/deepspeed/accelerator/npu_accelerator.py

@@ -0,0 +1,287 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+import importlib
+import inspect
+
+from .abstract_accelerator import DeepSpeedAccelerator
+# During setup stage torch may not be installed, pass on no torch will
+# allow op builder related API to be executed.
+try:
+    import torch.npu
+except ImportError:
+    pass
+
+
+class NPU_Accelerator(DeepSpeedAccelerator):
+
+    def __init__(self):
+        super().__init__()
+        self._name = 'npu'
+        self._communication_backend_name = 'hccl'
+        # dict that holds class name <--> class type mapping i.e.
+        # 'AsyncIOBuilder': <class 'op_builder.async_io.AsyncIOBuilder'>
+        # this dict will be filled at init stage
+        self.class_dict = None
+
+    def is_synchronized_device(self):
+        return False
+
+    def use_host_timers(self):
+        return self.is_synchronized_device()
+
+    def resolves_data_dependency(self):
+        return self.is_synchronized_device()
+
+    def handles_memory_backpressure(self):
+        return self.is_synchronized_device()
+
+    # Device APIs
+    def device_name(self, device_index=None):
+        if device_index is None:
+            return 'npu'
+        return 'npu:{}'.format(device_index)
+
+    def device(self, device_index=None):
+        return torch.npu.device(device_index)
+
+    def set_device(self, device_index):
+        torch.npu.set_device(device_index)
+
+    def current_device(self):
+        return torch.npu.current_device()
+
+    def current_device_name(self):
+        return 'npu:{}'.format(torch.npu.current_device())
+
+    def device_count(self):
+        return torch.npu.device_count()
+
+    def synchronize(self, device_index=None):
+        return torch.npu.synchronize(device_index)
+
+    # RNG APIs
+    def random(self):
+        return torch.random
+
+    def set_rng_state(self, new_state, device_index=None):
+        if device_index is None:
+            return torch.npu.set_rng_state(new_state)
+
+        return torch.npu.set_rng_state(new_state, device_index)
+
+    def get_rng_state(self, device_index=None):
+        if device_index is None:
+            return torch.npu.get_rng_state()
+
+        return torch.npu.get_rng_state(device_index)
+
+    def manual_seed(self, seed):
+        return torch.npu.manual_seed(seed)
+
+    def manual_seed_all(self, seed):
+        return torch.npu.manual_seed_all(seed)
+
+    def initial_seed(self, seed):
+        return torch.npu.initial_seed(seed)
+
+    def default_generator(self, device_index):
+        return torch.npu.default_generators[device_index]
+
+    # Streams/Events
+    @property
+    def Stream(self):
+        return torch.npu.Stream
+
+    def stream(self, stream):
+        return torch.npu.stream(stream)
+
+    def current_stream(self, device_index=None):
+        return torch.npu.current_stream(device_index)
+
+    def default_stream(self, device_index=None):
+        return torch.npu.default_stream(device_index)
+
+    @property
+    def Event(self):
+        return torch.npu.Event
+
+    # Memory management
+    def empty_cache(self):
+        return torch.npu.empty_cache()
+
+    def memory_allocated(self, device_index=None):
+        return torch.npu.memory_allocated(device_index)
+
+    def max_memory_allocated(self, device_index=None):
+        return torch.npu.max_memory_allocated(device_index)
+
+    def reset_max_memory_allocated(self, device_index=None):
+        return torch.npu.reset_max_memory_allocated(device_index)
+
+    def memory_cached(self, device_index=None):
+        return torch.npu.memory_cached(device_index)
+
+    def max_memory_cached(self, device_index=None):
+        return torch.npu.max_memory_cached(device_index)
+
+    def reset_max_memory_cached(self, device_index=None):
+        return torch.npu.reset_max_memory_cached(device_index)
+
+    def memory_stats(self, device_index=None):
+        if hasattr(torch.npu, 'memory_stats'):
+            return torch.npu.memory_stats(device_index)
+
+    def reset_peak_memory_stats(self, device_index=None):
+        if hasattr(torch.npu, 'reset_peak_memory_stats'):
+            return torch.npu.reset_peak_memory_stats(device_index)
+
+    def memory_reserved(self, device_index=None):
+        if hasattr(torch.npu, 'memory_reserved'):
+            return torch.npu.memory_reserved(device_index)
+
+    def max_memory_reserved(self, device_index=None):
+        if hasattr(torch.npu, 'max_memory_reserved'):
+            return torch.npu.max_memory_reserved(device_index)
+
+    def total_memory(self, device_index=None):
+        return torch.npu.get_device_properties(device_index).total_memory
+
+    def available_memory(self, device_index=None):
+        return self.total_memory(device_index) - self.memory_allocated(device_index)
+
+    # Data types
+    def is_bf16_supported(self):
+        return torch.npu.is_bf16_supported()
+
+    def is_fp16_supported(self):
+        return True
+
+    def supported_dtypes(self):
+        return [torch.float, torch.half, torch.bfloat16]
+
+    # Misc
+    def amp(self):
+        if hasattr(torch.npu, 'amp'):
+            return torch.npu.amp
+        return None
+
+    def is_available(self):
+        return torch.npu.is_available()
+
+    def range_push(self, msg):
+        return
+
+    def range_pop(self):
+        return
+
+    def lazy_call(self, callback):
+        return torch.npu._lazy_call(callback)
+
+    def communication_backend_name(self):
+        return self._communication_backend_name
+
+    def is_triton_supported(self):
+        return False
+
+    # Graph operations
+    def create_graph(self):
+        return None
+
+    def capture_to_graph(self, graph, pool=None, stream=None):
+        from deepspeed.runtime.utils import noop_context
+        return noop_context()
+
+    def replay_graph(self, graph):
+        return
+
+    # Tensor operations
+
+    @property
+    def BFloat16Tensor(self):
+        return torch.npu.BFloat16Tensor
+
+    @property
+    def ByteTensor(self):
+        return torch.npu.ByteTensor
+
+    @property
+    def DoubleTensor(self):
+        return torch.npu.DoubleTensor
+
+    @property
+    def FloatTensor(self):
+        return torch.npu.FloatTensor
+
+    @property
+    def HalfTensor(self):
+        return torch.npu.HalfTensor
+
+    @property
+    def IntTensor(self):
+        return torch.npu.IntTensor
+
+    @property
+    def LongTensor(self):
+        return torch.npu.LongTensor
+
+    def pin_memory(self, tensor, align_bytes=1):
+        return tensor.pin_memory()
+
+    def is_pinned(self, tensor):
+        return tensor.is_pinned()
+
+    def on_accelerator(self, tensor):
+        device_str = str(tensor.device)
+        if device_str.startswith('npu:'):
+            return True
+        else:
+            return False
+
+    def op_builder_dir(self):
+        try:
+            # is op_builder from deepspeed or a 3p version? this should only succeed if it's deepspeed
+            # if successful this also means we're doing a local install and not JIT compile path
+            from op_builder import __deepspeed__  # noqa: F401 # type: ignore
+            return "op_builder.npu"
+        except ImportError:
+            return "deepspeed.ops.op_builder.npu"
+
+    def _lazy_init_class_dict(self):
+        if self.class_dict:
+            return
+
+        op_builder_module = importlib.import_module(self.op_builder_dir())
+
+        # get op builder class from op_builder/npu/__init__.py
+        self.class_dict = {}
+        for class_name, class_obj in inspect.getmembers(op_builder_module, inspect.isclass):
+            self.class_dict[class_name] = class_obj
+
+    # create an instance of op builder and return, name specified by class_name
+    def create_op_builder(self, class_name):
+        builder_class = self.get_op_builder(class_name)
+        return None if builder_class is None else builder_class()
+
+    # return an op builder class, name specified by class_name
+    def get_op_builder(self, class_name):
+        self._lazy_init_class_dict()
+        if class_name in self.class_dict:
+            return self.class_dict[class_name]
+        else:
+            return self.class_dict['NotImplementedBuilder'] if 'NotImplementedBuilder' in self.class_dict else None
+
+    def build_extension(self):
+        from torch.utils.cpp_extension import BuildExtension
+        return BuildExtension
+
+    def export_envs(self):
+        return ['ASCEND', 'HCCL', 'LD_LIBRARY', 'PATH']
+
+    def visible_devices_envs(self):
+        return ['ASCEND_RT_VISIBLE_DEVICES']
+
+    def set_visible_devices_envs(self, current_env, local_accelerator_ids):
+        for env in self.visible_devices_envs():
+            current_env[env] = ",".join(map(str, local_accelerator_ids))

venv/lib/python3.10/site-packages/deepspeed/accelerator/real_accelerator.py

@@ -0,0 +1,257 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+import os
+
+try:
+    # Importing logger currently requires that torch is installed, hence the try...except
+    # TODO: Remove logger dependency on torch.
+    from deepspeed.utils import logger as accel_logger
+except ImportError as e:
+    accel_logger = None
+
+try:
+    from accelerator.abstract_accelerator import DeepSpeedAccelerator as dsa1
+except ImportError as e:
+    dsa1 = None
+try:
+    from deepspeed.accelerator.abstract_accelerator import DeepSpeedAccelerator as dsa2
+except ImportError as e:
+    dsa2 = None
+
+SUPPORTED_ACCELERATOR_LIST = ['cuda', 'cpu', 'xpu', 'xpu.external', 'npu', 'mps', 'hpu']
+
+ds_accelerator = None
+
+
+def _validate_accelerator(accel_obj):
+    # because abstract_accelerator has different path during
+    # build time (accelerator.abstract_accelerator)
+    # and run time (deepspeed.accelerator.abstract_accelerator)
+    # and extension would import the
+    # run time abstract_accelerator/DeepSpeedAccelerator as its base
+    # class, so we need to compare accel_obj with both base class.
+    # if accel_obj is instance of DeepSpeedAccelerator in one of
+    # accelerator.abstractor_accelerator
+    # or deepspeed.accelerator.abstract_accelerator, consider accel_obj
+    # is a conforming object
+    if not ((dsa1 is not None and isinstance(accel_obj, dsa1)) or (dsa2 is not None and isinstance(accel_obj, dsa2))):
+        raise AssertionError(f"{accel_obj.__class__.__name__} accelerator is not subclass of DeepSpeedAccelerator")
+
+    # TODO: turn off is_available test since this breaks tests
+    # assert accel_obj.is_available(), \
+    #    f'{accel_obj.__class__.__name__} accelerator fails is_available() test'
+
+
+def is_current_accelerator_supported():
+    return get_accelerator().device_name() in SUPPORTED_ACCELERATOR_LIST
+
+
+def get_accelerator():
+    global ds_accelerator
+    if ds_accelerator is not None:
+        return ds_accelerator
+
+    accelerator_name = None
+    ds_set_method = None
+    # 1. Detect whether there is override of DeepSpeed accelerators from environment variable.
+    if "DS_ACCELERATOR" in os.environ.keys():
+        accelerator_name = os.environ["DS_ACCELERATOR"]
+        if accelerator_name == "xpu":
+            try:
+                import intel_extension_for_pytorch as ipex
+                assert ipex._C._has_xpu(), "XPU_Accelerator requires an intel_extension_for_pytorch that supports XPU."
+            except ImportError as e:
+                raise ValueError(
+                    f"XPU_Accelerator requires intel_extension_for_pytorch, which is not installed on this system.")
+        elif accelerator_name == "xpu.external":
+            try:
+                import intel_extension_for_deepspeed  # noqa: F401 # type: ignore
+            except ImportError as e:
+                raise ValueError(
+                    f"XPU_Accelerator external requires intel_extension_for_deepspeed, which is not installed on this system."
+                )
+        elif accelerator_name == "cpu":
+            pass
+        elif accelerator_name == "npu":
+            try:
+                import torch_npu  # noqa: F401 # type: ignore
+            except ImportError as e:
+                raise ValueError(f"NPU_Accelerator requires torch_npu, which is not installed on this system.")
+            pass
+        elif accelerator_name == "mps":
+            try:
+                import torch.mps
+
+                # should use torch.mps.is_available() if it exists someday but this is used as proxy
+                torch.mps.current_allocated_memory()
+            except (RuntimeError, ImportError) as e:
+                raise ValueError(f"MPS_Accelerator requires torch.mps, which is not installed on this system.")
+        elif accelerator_name == "hpu":
+            try:
+                import habana_frameworks.torch.hpu  # noqa: F401
+            except ImportError as e:
+                raise ValueError(
+                    f"HPU_Accelerator requires habana_frameworks.torch.hpu, which is not installed on this system.")
+        elif accelerator_name not in SUPPORTED_ACCELERATOR_LIST:
+            raise ValueError(f'DS_ACCELERATOR must be one of {SUPPORTED_ACCELERATOR_LIST}. '
+                             f'Value "{accelerator_name}" is not supported')
+        ds_set_method = "override"
+
+    # 2. If no override, detect which accelerator to use automatically
+    if accelerator_name is None:
+        # We need a way to choose among different accelerator types.
+        # Currently we detect which accelerator extension is installed
+        # in the environment and use it if the installing answer is True.
+        # An alternative might be detect whether CUDA device is installed on
+        # the system but this comes with two pitfalls:
+        # 1. the system may not have torch pre-installed, so
+        #    get_accelerator().is_available() may not work.
+        # 2. Some scenario like install on login node (without CUDA device)
+        #    and run on compute node (with CUDA device) may cause mismatch
+        #    between installation time and runtime.
+
+        try:
+            from intel_extension_for_deepspeed import XPU_Accelerator  # noqa: F401,F811 # type: ignore
+            accelerator_name = "xpu.external"
+        except ImportError as e:
+            pass
+        if accelerator_name is None:
+            try:
+                import intel_extension_for_pytorch as ipex
+                if ipex._C._has_xpu():
+                    accelerator_name = "xpu"
+                else:
+                    accelerator_name = "cpu"
+            except ImportError as e:
+                pass
+        if accelerator_name is None:
+            try:
+                import torch_npu  # noqa: F401,F811 # type: ignore
+
+                accelerator_name = "npu"
+            except ImportError as e:
+                pass
+        if accelerator_name is None:
+            try:
+                import torch.mps
+
+                # should use torch.mps.is_available() if it exists someday but this is used as proxy
+                torch.mps.current_allocated_memory()
+                accelerator_name = "mps"
+            except (RuntimeError, ImportError) as e:
+                pass
+        if accelerator_name is None:
+            try:
+                import habana_frameworks.torch.hpu  # noqa: F401,F811
+
+                accelerator_name = "hpu"
+            except ImportError as e:
+                pass
+        if accelerator_name is None:
+            # borrow this log from PR#5084
+            try:
+                import torch
+
+                # Determine if we are on a GPU or x86 CPU with torch.
+                if torch.cuda.is_available():  #ignore-cuda
+                    accelerator_name = "cuda"
+                else:
+                    if accel_logger is not None:
+                        accel_logger.warn(
+                            "Setting accelerator to CPU. If you have GPU or other accelerator, we were unable to detect it."
+                        )
+                    accelerator_name = "cpu"
+            except (RuntimeError, ImportError) as e:
+                # TODO need a more decent way to detect which accelerator to use, consider using nvidia-smi command for detection
+                accelerator_name = "cuda"
+                pass
+
+        ds_set_method = "auto detect"
+
+    # 3. Set ds_accelerator accordingly
+    if accelerator_name == "cuda":
+        from .cuda_accelerator import CUDA_Accelerator
+
+        ds_accelerator = CUDA_Accelerator()
+    elif accelerator_name == "cpu":
+        from .cpu_accelerator import CPU_Accelerator
+
+        ds_accelerator = CPU_Accelerator()
+    elif accelerator_name == "xpu.external":
+        # XPU_Accelerator is already imported in detection stage
+        ds_accelerator = XPU_Accelerator()
+    elif accelerator_name == "xpu":
+        from .xpu_accelerator import XPU_Accelerator
+
+        ds_accelerator = XPU_Accelerator()
+    elif accelerator_name == "npu":
+        from .npu_accelerator import NPU_Accelerator
+
+        ds_accelerator = NPU_Accelerator()
+    elif accelerator_name == "mps":
+        from .mps_accelerator import MPS_Accelerator
+
+        ds_accelerator = MPS_Accelerator()
+    elif accelerator_name == 'hpu':
+        from .hpu_accelerator import HPU_Accelerator
+
+        ds_accelerator = HPU_Accelerator()
+    _validate_accelerator(ds_accelerator)
+    if accel_logger is not None:
+        accel_logger.info(f"Setting ds_accelerator to {ds_accelerator._name} ({ds_set_method})")
+    return ds_accelerator
+
+
+def set_accelerator(accel_obj):
+    global ds_accelerator
+    _validate_accelerator(accel_obj)
+    if accel_logger is not None:
+        accel_logger.info(f"Setting ds_accelerator to {accel_obj._name} (model specified)")
+    ds_accelerator = accel_obj
+
+
+"""
+-----------[code] test_get.py -----------
+from deepspeed.accelerator import get_accelerator
+my_accelerator = get_accelerator()
+logger.info(f'{my_accelerator._name=}')
+logger.info(f'{my_accelerator._communication_backend=}')
+logger.info(f'{my_accelerator.HalfTensor().device=}')
+logger.info(f'{my_accelerator.total_memory()=}')
+-----------[code] test_get.py -----------
+
+---[output] python test_get.py---------
+my_accelerator.name()='cuda'
+my_accelerator.communication_backend='nccl'
+my_accelerator.HalfTensor().device=device(type='cuda', index=0)
+my_accelerator.total_memory()=34089730048
+---[output] python test_get.py---------
+
+**************************************************************************
+-----------[code] test_set.py -----------
+from deepspeed.accelerator.cuda_accelerator import CUDA_Accelerator
+cu_accel = CUDA_Accelerator()
+logger.info(f'{id(cu_accel)=}')
+from deepspeed.accelerator import set_accelerator, get_accelerator
+set_accelerator(cu_accel)
+
+my_accelerator = get_accelerator()
+logger.info(f'{id(my_accelerator)=}')
+logger.info(f'{my_accelerator._name=}')
+logger.info(f'{my_accelerator._communication_backend=}')
+logger.info(f'{my_accelerator.HalfTensor().device=}')
+logger.info(f'{my_accelerator.total_memory()=}')
+-----------[code] test_set.py -----------
+
+
+---[output] python test_set.py---------
+id(cu_accel)=139648165478304
+my_accelerator=<deepspeed.accelerator.cuda_accelerator.CUDA_Accelerator object at 0x7f025f4bffa0>
+my_accelerator.name='cuda'
+my_accelerator.communication_backend='nccl'
+my_accelerator.HalfTensor().device=device(type='cuda', index=0)
+my_accelerator.total_memory()=34089730048
+---[output] python test_set.py---------
+"""

venv/lib/python3.10/site-packages/deepspeed/accelerator/xpu_accelerator.py

@@ -0,0 +1,298 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+from deepspeed.accelerator.abstract_accelerator import DeepSpeedAccelerator
+import intel_extension_for_pytorch as ipex  # noqa: F401 # type: ignore
+import oneccl_bindings_for_pytorch  # noqa: F401 # type: ignore
+
+
+class XPU_Accelerator(DeepSpeedAccelerator):
+
+    def __init__(self):
+        self._name = 'xpu'
+        self._communication_backend_name = 'ccl'
+        self.aligned_tensors = []
+
+    def is_synchronized_device(self):
+        return False
+
+    def use_host_timers(self):
+        return self.is_synchronized_device()
+
+    def resolves_data_dependency(self):
+        return self.is_synchronized_device()
+
+    def handles_memory_backpressure(self):
+        return self.is_synchronized_device()
+
+    # Device APIs
+    def device_name(self, device_index=None):
+        if device_index == None:
+            return 'xpu'
+        return 'xpu:{}'.format(device_index)
+
+    def device(self, device_index=None):
+        return torch.xpu.device(device_index)
+
+    def set_device(self, device_index):
+        torch.xpu.set_device(device_index)
+
+    def current_device(self):
+        return torch.xpu.current_device()
+
+    def current_device_name(self):
+        return 'xpu:{}'.format(torch.xpu.current_device())
+
+    def device_count(self):
+        return torch.xpu.device_count()
+
+    def synchronize(self, device_index=None):
+        return torch.xpu.synchronize(device_index)
+
+    # RNG APIs
+    def random(self):
+        return torch.xpu.random
+
+    def set_rng_state(self, new_state, device_index=None):
+        if device_index == None:
+            return torch.xpu.set_rng_state(new_state)
+        return torch.xpu.set_rng_state(new_state, device_index)
+
+    def get_rng_state(self, device_index=None):
+        if device_index == None:
+            return torch.xpu.get_rng_state()
+        return torch.xpu.get_rng_state(device_index)
+
+    def manual_seed(self, seed):
+        return torch.xpu.manual_seed(seed)
+
+    def manual_seed_all(self, seed):
+        return torch.xpu.manual_seed_all(seed)
+
+    def initial_seed(self, seed):
+        return torch.xpu.initial_seed(seed)
+
+    def default_generator(self, device_index):
+        return torch.xpu.default_generators[device_index]
+
+    # Streams/Events
+    @property
+    def Stream(self):
+        return torch.xpu.Stream
+
+    def stream(self, stream):
+        return torch.xpu.stream(stream)
+
+    def current_stream(self, device_index=None):
+        return torch.xpu.current_stream(device_index)
+
+    def default_stream(self, device_index=None):
+        # torch.xpu does not support the sync behavior of default stream as cuda
+        # use current_stream as workaround
+        # see https://pytorch.org/docs/stable/notes/cuda.html#cuda-streams
+        return torch.xpu.current_stream(device_index)
+
+    @property
+    def Event(self):
+        return torch.xpu.Event
+
+    # Memory management
+    def empty_cache(self):
+        return torch.xpu.empty_cache()
+
+    def memory_allocated(self, device_index=None):
+        return torch.xpu.memory_allocated(device_index)
+
+    def max_memory_allocated(self, device_index=None):
+        return torch.xpu.max_memory_allocated(device_index)
+
+    def reset_max_memory_allocated(self, device_index=None):
+        return torch.xpu.reset_max_memory_allocated(device_index)
+
+    def memory_cached(self, device_index=None):
+        return torch.xpu.memory_reserved(device_index)
+
+    def max_memory_cached(self, device_index=None):
+        return torch.xpu.max_memory_reserved(device_index)
+
+    def reset_max_memory_cached(self, device_index=None):
+        return torch.xpu.reset_max_memory_reserved(device_index)
+
+    def memory_stats(self, device_index=None):
+        return torch.xpu.memory_stats(device_index)
+
+    def reset_peak_memory_stats(self, device_index=None):
+        return torch.xpu.reset_peak_memory_stats(device_index)
+
+    def memory_reserved(self, device_index=None):
+        return torch.xpu.memory_reserved(device_index)
+
+    def max_memory_reserved(self, device_index=None):
+        return torch.xpu.max_memory_reserved(device_index)
+
+    def total_memory(self, device_index=None):
+        return torch.xpu.get_device_properties(device_index).total_memory
+
+    def available_memory(self, device_index=None):
+        return self.total_memory(device_index) - self.memory_allocated(device_index)
+
+    # Misc
+    def amp(self):
+        return torch.xpu.amp
+
+    def is_available(self):
+        return torch.xpu.is_available()
+
+    def range_push(self, msg):
+        # TODO itt is currently not supported yet
+        # return torch.profiler.itt.range_push(msg)
+        return
+
+    def range_pop(self):
+        # TODO itt is currently not supported yet
+        # return torch.profiler.itt.range_pop()
+        return
+
+    def lazy_call(self, callback):
+        return torch.xpu.lazy_init._lazy_call(callback)
+
+    def communication_backend_name(self):
+        return self._communication_backend_name
+
+    def is_triton_supported(self):
+        return False
+
+    # Graph operations
+    def create_graph(self):
+        return None
+
+    def capture_to_graph(self, graph, pool=None, stream=None):
+        from deepspeed.runtime.utils import noop_context
+        return noop_context()
+
+    def replay_graph(self, graph):
+        return
+
+    # Data types
+    def is_bf16_supported(self):
+        return True
+
+    def is_fp16_supported(self):
+        return True
+
+    def supported_dtypes(self):
+        return [torch.float, torch.half, torch.bfloat16]
+
+    # Tensor operations
+
+    @property
+    def BFloat16Tensor(self):
+        return torch.xpu.BFloat16Tensor
+
+    @property
+    def ByteTensor(self):
+        return torch.xpu.ByteTensor
+
+    @property
+    def DoubleTensor(self):
+        return torch.xpu.DoubleTensor
+
+    @property
+    def FloatTensor(self):
+        return torch.xpu.FloatTensor
+
+    @property
+    def HalfTensor(self):
+        return torch.xpu.HalfTensor
+
+    @property
+    def IntTensor(self):
+        return torch.xpu.IntTensor
+
+    @property
+    def LongTensor(self):
+        return torch.xpu.LongTensor
+
+    def pin_memory(self, tensor, align_bytes=1):
+        if align_bytes == 1:
+            return tensor.pin_memory(device=self.current_device_name())
+        elif align_bytes == 0:
+            from intel_extension_for_deepspeed.op_builder.async_io import AsyncIOBuilder
+            self.aio_handle = AsyncIOBuilder().load().aio_handle(128 * 1024, 8, False, False, False)
+            aligned_t = self.aio_handle.new_cpu_locked_tensor(tensor.numel(), tensor)
+            aligned_t = aligned_t[:tensor.numel()].copy_(tensor)
+            self.aligned_tensors.append([aligned_t.data_ptr(), aligned_t[-1].data_ptr()])
+            return aligned_t
+
+    def is_pinned(self, tensor):
+        if tensor.is_pinned(device=self.current_device_name()):
+            return True
+        else:
+            for begin, end in self.aligned_tensors:
+                if begin <= tensor.data_ptr() and tensor.data_ptr() <= end:
+                    return True
+        return False
+
+    def op_builder_dir(self):
+        try:
+            # is op_builder from deepspeed or a 3p version? this should only succeed if it's deepspeed
+            # if successful this also means we're doing a local install and not JIT compile path
+            from op_builder import __deepspeed__  # noqa: F401 # type: ignore
+            return "op_builder.xpu"
+        except ImportError:
+            return "deepspeed.ops.op_builder.xpu"
+
+    def on_accelerator(self, tensor):
+        device_str = str(tensor.device)
+        if device_str.startswith('xpu:'):
+            return True
+        else:
+            return False
+
+    # create an instance of op builder and return, name specified by class_name
+    def create_op_builder(self, op_name):
+        builder_class = self.get_op_builder(op_name)
+        if builder_class != None:
+            return builder_class()
+        return None
+
+    # return an op builder class, name specified by class_name
+    def get_op_builder(self, class_name):
+        try:
+            # is op_builder from deepspeed or a 3p version? this should only succeed if it's deepspeed
+            # if successful this also means we're doing a local install and not JIT compile path
+            from op_builder import __deepspeed__  # noqa: F401 # type: ignore
+            from op_builder.xpu import CPUAdagradBuilder, CPUAdamBuilder, FusedAdamBuilder, AsyncIOBuilder
+        except ImportError:
+            from deepspeed.ops.op_builder.xpu import CPUAdagradBuilder, CPUAdamBuilder, FusedAdamBuilder, AsyncIOBuilder
+
+        if class_name == "AsyncIOBuilder":
+            return AsyncIOBuilder
+        elif class_name == "CPUAdagradBuilder":
+            return CPUAdagradBuilder
+        elif class_name == "CPUAdamBuilder":
+            return CPUAdamBuilder
+        elif class_name == "FusedAdamBuilder":
+            return FusedAdamBuilder
+        else:
+            return None
+
+    def build_extension(self):
+        try:
+            from intel_extension_for_pytorch.xpu.cpp_extension import DpcppBuildExtension
+        except ImportError:
+            from intel_extension_for_pytorch.xpu.utils import DpcppBuildExtension
+        return DpcppBuildExtension
+
+    def export_envs(self):
+        return []
+
+    def visible_devices_envs(self):
+        return ['ZE_AFFINITY_MASK']
+
+    def set_visible_devices_envs(self, current_env, local_accelerator_ids):
+        for env in self.visible_devices_envs():
+            current_env[env] = ",".join(map(str, local_accelerator_ids))

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

@@ -0,0 +1,6 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .autotuner import Autotuner

venv/lib/python3.10/site-packages/deepspeed/autotuning/autotuner.py

@@ -0,0 +1,1113 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import shutil
+import subprocess
+import time
+import datetime
+import math
+import hjson
+
+from ..runtime.config_utils import dict_raise_error_on_duplicate_keys
+from ..runtime.constants import *
+
+from ..runtime.zero.config import ZERO_OPTIMIZATION, ZeroStageEnum
+from ..utils import logger
+from .config import DeepSpeedAutotuningConfig
+from .constants import *
+from .scheduler import ResourceManager
+from .tuner import GridSearchTuner, RandomTuner, ModelBasedTuner
+from .utils import *
+from deepspeed.accelerator import get_accelerator
+
+try:
+    from tabulate import tabulate
+except ImportError:
+    tabulate = None
+
+try:
+    import mlflow
+    has_mlflow = True
+except Exception as e:
+    has_mlflow = False
+
+ZERO_OPTIMIZATION_STAGE = "stage"
+OFFLOAD_OPTIMIZER = "offload_optimizer"
+OFFLOAD_PARAM = "offload_param"
+ZERO_OPTIMIZATION_STAGE_DEFAULT = ZeroStageEnum.disabled
+
+
+class Autotuner:
+    """The DeepSpeed Autotuner automatically discovers the optimal DeepSpeed configuration that delivers good training speed. The Autotuner uses model information, system information, and heuristics to efficiently tune system knobs that affect compute and memory efficiencies, such as ZeRO optimization stages, micro-batch sizes, and many other ZeRO optimization configurations. It not only reduces the time and resources user spend on tuning, but also can discover configurations better than hand-tuned methods.
+    Autotuning with DeepSpeed requires no code change from DeepSpeed users. Please refer to the README for usage details.
+    """
+
+    def __init__(self, args, active_resources):
+        self.args = args
+        self.selected_exp_dir = None
+
+        assert tabulate is not None, "Missing required package `tabulate`, please install with `pip install deepspeed[autotuning]`."
+
+        logger.debug(f"autotuning args={args}")
+
+        self.user_config = self._get_user_config(args.user_args)
+        assert self.user_config is not None, "DeepSpeed configuration is not provided"
+
+        self.autotuning_config = DeepSpeedAutotuningConfig(self.user_config)
+        if self.user_config[AUTOTUNING]:
+            if AUTOTUNING_EXPS_DIR in self.user_config[AUTOTUNING].keys():
+                del self.user_config[AUTOTUNING][AUTOTUNING_EXPS_DIR]
+            if AUTOTUNING_RESULTS_DIR in self.user_config[AUTOTUNING].keys():
+                del self.user_config[AUTOTUNING][AUTOTUNING_RESULTS_DIR]
+
+        self.exps_dir = self.autotuning_config.exps_dir
+        if self.autotuning_config.overwrite and os.path.exists(self.exps_dir):
+            shutil.rmtree(self.exps_dir, ignore_errors=True)
+        if not os.path.exists(self.exps_dir):
+            try:
+                os.makedirs(self.exps_dir, exist_ok=True)
+                logger.info(f"Created autotuning experiments directory: {self.exps_dir}")
+            except:
+                logger.error(
+                    f"Failed to create {self.exps_dir}, please check `exps_dir` in the autotuning config file is accessible by all the nodes in the job."
+                )
+                exit(-1)
+
+        self.results_dir = self.autotuning_config.results_dir
+        if self.autotuning_config.overwrite and os.path.exists(self.results_dir):
+            shutil.rmtree(self.results_dir, ignore_errors=True)
+        if not os.path.exists(self.results_dir):
+            try:
+                os.makedirs(self.results_dir, exist_ok=True)
+                logger.info(f"Created autotuning results directory: {self.exps_dir}")
+            except:
+                logger.error(
+                    f"Failed to create {self.results_dir}, please check `results_dir` in the autotuning config file is accessible by all the nodes in the job."
+                )
+                exit(-1)
+
+        # set the active resource for the autotuner resource manager
+        self.rm = self._get_resource_manager(active_resources)
+
+        # get resource requirement for each autotuning experiment
+        self.exp_num_nodes, self.exp_num_gpus = self._get_exp_resources(args)
+
+        assert self.exp_num_gpus <= self.rm.num_gpus_per_node, "num_gpus in the autotuning configuration must not be less than the --num_gpus value in the train script if any"
+        assert self.exp_num_nodes <= len(
+            self.rm.nodes
+        ), "num_nodes in the autotuning configuration must not be less than the --num_nodes value in the train script if any"
+
+        self.records = {}
+        self.optimal_cmd = None
+        self.optimal_ds_config = None
+
+        self.mlflow_parent_id = None
+
+    def print_tuning_results(self):
+        """Print the autotuning results in tabular format.
+        """
+        best_space_records = self.get_best_space_records()
+        tab = []
+        if best_space_records:
+            for key, val in best_space_records.items():
+                if not val:
+                    continue
+                row = []
+                row.append(key)
+                num_exps = 0
+                if key == GLOBAL_TUNING_SPACE:
+                    cnt = 0
+                    for k, v in best_space_records.items():
+                        if k != GLOBAL_TUNING_SPACE:
+                            cnt += v[2]
+                    num_exps = cnt
+                else:
+                    num_exps = val[2]
+                row.append(num_exps)
+                row.append(val[1])
+                row.append(val[0]['name'])
+                tab.append(row)
+            summary = tabulate(tab,
+                               headers=["tuning_space", "num_experiments", "best_metric_val", "best_exp_name"],
+                               tablefmt="pipe")
+            print(summary)
+            with open(os.path.join(self.results_dir, 'summary.txt'), 'w', buffering=BUFSIZE) as fd:
+                fd.write(summary)
+                fd.flush()
+                os.fsync(fd)
+
+        if GLOBAL_TUNING_SPACE in best_space_records:
+            best_exp, best_metric_val, total_num_exps = best_space_records[GLOBAL_TUNING_SPACE]
+            if best_exp:
+                logger.info(
+                    f"{best_exp['name']} is the optimal setup after tuning. The exp result is at {best_exp['result_dir']}."
+                )
+            else:
+                logger.info(f"No optimal setup is found. Please check that experiments were run successfully.")
+            tuning_duration = datetime.timedelta(seconds=(time.time() - self.start_time))
+
+            logger.info(f"Tuning completed in {tuning_duration}")
+            with open(os.path.join(self.results_dir, 'summary.txt'), 'a') as f:
+                f.write(
+                    f"\n\nTuning completed in {tuning_duration}. Total number of experiments: {self.rm.experiment_count - 1}."
+                )
+                f.flush()
+
+    def _get_user_config(self, user_args):
+        """Get DeepSpeed configuration from the user arguments passed to the launcher.
+
+        Args:
+            user_args ([list]): user arguments passed to the DeepSpeed launcher
+
+        Returns:
+            [dict]: DeepSpeed configuration dictionary
+        """
+        user_config_file = None
+        if "--deepspeed_config" in user_args:
+            idx = user_args.index("--deepspeed_config")
+            assert ".json" in user_args[
+                idx + 1], "DeepSpeed --deepspeed_config requires a json file to specify the configuration"
+
+            user_config_file = user_args[idx + 1]
+        elif "--deepspeed" in user_args:
+            idx = user_args.index("--deepspeed")
+            if ".json" in user_args[idx + 1]:
+                user_config_file = user_args[idx + 1]
+
+        logger.debug(f"user_config_file = {user_config_file}")
+        if user_config_file is not None:
+            assert os.path.isfile(user_config_file), "DeepSpeed configuration file: {} is not an existing file".format(
+                user_config_file)
+            if os.path.exists(user_config_file):
+                return json.load(open(user_config_file, "r"), object_pairs_hook=dict_raise_error_on_duplicate_keys)
+
+        return None
+
+    def _get_resource_manager(self, active_resources):
+        """Initialize and return a resource manager
+
+        Args:
+            active_resources ([dict]): A dictionary of hostname and its slots (GPUs), e.g. {"worker-0": "0,1,2,3,4,5,6,7,8"}
+
+        Raises:
+            RuntimeError: raises the error if no GPU is available
+
+        Returns:
+            [ResourceManager]: A resource manager that schedules and runs autotuning experiments.
+        """
+        logger.info(f"active_resources = {active_resources}")
+
+        hosts = []
+        ngpus_per_node = 100
+        for hostname, slots in active_resources.items():
+            hosts.append(hostname)
+            ngpus_per_node = min(len(slots), ngpus_per_node)
+
+        assert ngpus_per_node > 0, "no gpu is available"
+
+        return ResourceManager(args=self.args,
+                               hosts=hosts,
+                               num_gpus_per_node=ngpus_per_node,
+                               results_dir=self.results_dir,
+                               exps_dir=self.exps_dir,
+                               arg_mappings=self.autotuning_config.arg_mappings)
+
+    def _get_exp_resources(self, args):
+        """Get resource requirement for each autotuning experiment
+
+        Args:
+            args (dict): user args
+
+        Returns:
+            num_nodes, num_gpus: the number of gpus and number of nodes used in the autotuning experiments
+        """
+        if args.num_nodes > 0:
+            num_nodes = args.num_nodes
+        else:
+            num_nodes = len(self.rm.nodes)
+
+        if args.num_gpus > 0:
+            num_gpus = args.num_gpus
+        else:
+            num_gpus = self.rm.num_gpus_per_node
+
+        return num_nodes, num_gpus
+
+    def metric(self):
+        return self.autotuning_config.metric
+
+    def fast_enabled(self):
+        return self.autotuning_config.fast
+
+    def max_train_batch_size(self):
+        return self.autotuning_config.max_train_batch_size
+
+    def mp_size(self):
+        return self.autotuning_config.mp_size
+
+    def max_train_micro_batch_size_per_gpu(self):
+        if self.max_train_batch_size(
+        ) and self.max_train_batch_size() > 0:  # if the user specifies a max_train_batch_size
+            max_train_micro_batch_size = self.max_train_batch_size() * self.mp_size() // (
+                self.exp_num_gpus * self.exp_num_nodes)  # gradient accumulation steps >=1
+            return min(self.autotuning_config.max_train_micro_batch_size_per_gpu, max_train_micro_batch_size)
+        else:
+            return self.autotuning_config.max_train_micro_batch_size_per_gpu
+
+    def min_train_micro_batch_size_per_gpu(self):
+        return self.autotuning_config.min_train_micro_batch_size_per_gpu
+
+    def num_tuning_micro_batch_sizes(self):
+        return self.autotuning_config.num_tuning_micro_batch_sizes
+
+    def fp16_enabled(self):
+        if FP16 in self.user_config.keys():
+            return self.user_config[FP16].get(FP16_ENABLED, FP16_ENABLED_DEFAULT)
+        else:
+            return False
+
+    def get_gpu_memory_info(self):
+        return get_accelerator().total_memory()
+
+    def get_activation_memory_per_gpu(self):
+        if self.model_info and "activation_mem_per_gpu" in self.model_info:
+            return self.model_info["activation_mem_per_gpu"]
+
+    def get_instantiation_memory_required_per_gpu(self, zero_stage):
+        num_params = self.get_model_num_params()
+        total_gpus = self.exp_num_nodes * self.exp_num_gpus
+        fp16_enabled = self.fp16_enabled()
+
+        if not num_params:
+            return 0
+        # assume the model uses Adam optimizer
+        # ZeroStageEnum.disabled:
+        params_mem = num_params * (2 if fp16_enabled else 4)
+        gradients_mem = num_params * (2 if fp16_enabled else 4)
+        optimizer_mem = num_params * (16 if fp16_enabled else 8)
+
+        if zero_stage >= ZeroStageEnum.optimizer_states:
+            optimizer_mem = optimizer_mem / total_gpus
+
+        if zero_stage >= ZeroStageEnum.gradients:
+            gradients_mem = gradients_mem / total_gpus
+
+        if zero_stage >= ZeroStageEnum.weights:
+            params_mem = params_mem / total_gpus
+
+        mem_per_gpu = (params_mem + gradients_mem + optimizer_mem) / self.mp_size()
+
+        return mem_per_gpu
+
+    def _generate_experiments(self, tuning_space, max_train_batch_size_per_gpu):
+        """Generates a list of autotuning experiments given a tuning_space.
+            The corresponding parameter values are replaced by user-defined values in the DeepSpeed configuration file.
+        Args:
+            tuning_space ([dict]): A DeepSpeed configuration dictionary where a value can be a list (called a tuning parameter). For example,
+                {
+                    "zero_optimization": {
+                        "stage": 1,
+                        "reduce_bucket_size": [5e7,
+                                            5e8,
+                                            1e9],
+                        "allgather_bucket_size": [5e7,
+                                                5e8,
+                                                1e9],
+                    }
+                }
+                reduce_bucket_size and allgather_bucket_size are the tuning parameters in this tuning space.
+        Returns:
+            [list]: a list of experiments generated by taking combinations of values of the tuning space. The above tuning space generates 3*3 = 9 experiments if the user DeepSpeed configuration file does not overwrite the two tuning parameters or define more tuning parameters.
+        """
+        exps = []
+
+        # each zero stage uses a different template configuration file
+        config_zero = tuning_space.get(ZERO_OPTIMIZATION, {})
+        stage = config_zero.get(ZERO_OPTIMIZATION_STAGE, ZERO_OPTIMIZATION_STAGE_DEFAULT)
+        template_config = {}
+        if stage == 0:
+            template_path = DEFAULT_TEMPLATE_PATH_ZERO_0
+            template_config = hjson.load(open(template_path, 'r'))
+            prefix = "z0_"
+
+        elif stage == 1:
+            template_path = DEFAULT_TEMPLATE_PATH_ZERO_1
+            template_config = hjson.load(open(template_path, 'r'))
+            prefix = "z1_"
+
+        elif stage == 2:
+            template_path = DEFAULT_TEMPLATE_PATH_ZERO_2
+            template_config = hjson.load(open(template_path, 'r'))
+            prefix = "z2_"
+
+        elif stage == 3:
+            template_path = DEFAULT_TEMPLATE_PATH_ZERO_3
+            template_config = hjson.load(open(template_path, 'r'))
+            model_info = self.model_info
+            if model_info and "hidden_size" in model_info:
+                hs = model_info["hidden_size"]
+                template_config[ZERO_OPTIMIZATION]['reduce_bucket_size'] = hs * hs
+                template_config[ZERO_OPTIMIZATION]['stage3_prefetch_bucket_size'] = 0.9 * hs * hs
+                template_config[ZERO_OPTIMIZATION]['stage3_param_persistence_threshold'] = 10 * hs
+            prefix = "z3_"
+        else:
+            return exps
+
+        # replace the corresponding parameter values if the user specifies them in the DeepSpeed configuration file
+        replace_dict(tuning_space, self.user_config, [ZERO_OPTIMIZATION, TRAIN_MICRO_BATCH_SIZE_PER_GPU])
+
+        logger.debug(f"tuning_space = {json.dumps(tuning_space)}")
+
+        all_configs = get_all_configs(tuning_space, ignore_keys=["optimizer"])
+
+        tuning_keys = get_tuning_keys(tuning_space)
+
+        logger.debug(f"tuning_keys = {tuning_keys}")
+
+        logger.debug(f"before pruning total configs = {len(all_configs)}")
+
+        pruned_list = prune_configs(all_configs)
+
+        logger.debug(f"after pruning total configs = {len(pruned_list)}")
+
+        for config in pruned_list:
+            exp_config = copy.deepcopy(template_config)
+            # fill the template with the expr config
+            replace_dict(exp_config, config)
+
+            # if the config does not use offloading, remove the offloading section
+            config_zero = config.get(ZERO_OPTIMIZATION, None)
+            if config_zero:
+                if OFFLOAD_OPTIMIZER not in config_zero and OFFLOAD_OPTIMIZER in exp_config[ZERO_OPTIMIZATION]:
+                    del exp_config[ZERO_OPTIMIZATION][OFFLOAD_OPTIMIZER]
+                if OFFLOAD_PARAM not in config_zero and OFFLOAD_PARAM in exp_config[ZERO_OPTIMIZATION]:
+                    del exp_config[ZERO_OPTIMIZATION][OFFLOAD_PARAM]
+            # set gradient accumulation steps according to max_train_batch_size_per_gpu
+            mbs = exp_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU]
+            gas = max_train_batch_size_per_gpu // mbs
+            exp_config[GRADIENT_ACCUMULATION_STEPS] = gas
+            exp_config[TRAIN_BATCH_SIZE] = mbs * gas * \
+                self.exp_num_gpus * self.exp_num_nodes // self.mp_size()
+            exp = {}
+            # generate the expr name
+            exp_name = canonical_name(exp_config, tuning_keys, prefix)
+            exp['name'] = exp_name
+            exp[DS_CONFIG] = exp_config
+            exp['num_gpus'] = self.exp_num_gpus
+            exp['num_nodes'] = self.exp_num_nodes
+            exps.append(exp)
+
+        return exps
+
+    def tune(self):
+        """ Tunes Zero stages, micro batch size per GPU, and other Zero configurations. Performance metrics of different tuning spaces are recorded in self.records.
+        """
+        if has_mlflow:
+            self.mlflow_parent_id = os.environ['MLFLOW_RUN_ID']
+            mlflow.start_run(run_id=self.mlflow_parent_id)
+
+        self.start_time = time.time()
+        if self.fast_enabled():
+            logger.info(f"Fast mode is enabled. Tuning micro batch size only.")
+
+        # model info profile run with DEFAULT_MIN_MEM_CONFIG
+        model_info = self.model_info_profile_run()
+        if model_info:
+            self.model_info = model_info
+        else:
+            return
+
+        logger.info(f"The model has {number_to_string(self.get_model_num_params())} parameters.")
+
+        self.gpu_mem = self.get_gpu_memory_info()
+        logger.info(f"Memory per GPU in the system is {memory_to_string(self.gpu_mem, postfix='B')}.")
+
+        self.activation_mem = self.get_activation_memory_per_gpu()
+        logger.info(
+            f"The model requires at least {memory_to_string(self.activation_mem, postfix='B')} activation memory for micro batch size 1."
+        )
+
+        stage = self.user_config.get(ZERO_OPTIMIZATION, {}).get(ZERO_OPTIMIZATION_STAGE, 0)
+
+        user_zero_stages = [stage] if not isinstance(stage, list) else stage
+        logger.info(f"User-defined zero stages are {stage}.")
+
+        mbs = 0
+        max_mbs = 0
+        metric_val = 0
+
+        required_gpu_mem = self.get_instantiation_memory_required_per_gpu(ZeroStageEnum.disabled) + self.activation_mem
+        if self.gpu_mem > required_gpu_mem:
+            if "all" in user_zero_stages or ZeroStageEnum.disabled in user_zero_stages:
+                logger.info(
+                    f"The model might be runable with ZERO 0 (which requires at least {memory_to_string(required_gpu_mem, postfix='B')} memory with mbs = 1), adding DEFAULT_TUNING_SPACE_ZERO_0 to the global tuning space"
+                )
+                next_max_mbs, next_mbs, next_metric_val = self.tune_space(DEFAULT_TUNING_SPACE_ZERO_0)
+                if next_mbs > mbs:
+                    mbs = next_mbs
+                    max_mbs = next_max_mbs
+                    metric_val = next_metric_val
+                if has_mlflow:
+                    mlflow.log_metric(f"z0{self.metric()}", next_metric_val)
+        else:
+            logger.info(
+                f"The model is not runable with ZERO stage {ZeroStageEnum.disabled} (which requires at least {memory_to_string(required_gpu_mem, postfix='B')} memory with mbs = 1)"
+            )
+
+        required_gpu_mem = self.get_instantiation_memory_required_per_gpu(
+            ZeroStageEnum.optimizer_states) + self.activation_mem
+        if self.gpu_mem > required_gpu_mem:
+            if "all" in user_zero_stages or ZeroStageEnum.optimizer_states in user_zero_stages:
+                logger.info(
+                    f"The model might be runable with ZERO 1 (which requires at least {memory_to_string(required_gpu_mem, postfix='B')} memory), adding DEFAULT_TUNING_SPACE_ZERO_1 to the global tuning space"
+                )
+                next_max_mbs, next_mbs, next_metric_val = self.tune_space(DEFAULT_TUNING_SPACE_ZERO_1,
+                                                                          prev_max_mbs=max_mbs,
+                                                                          prev_best_mbs=mbs,
+                                                                          prev_best_metric_val=metric_val)
+                if next_mbs > mbs:
+                    mbs = next_mbs
+                    max_mbs = next_max_mbs
+                    metric_val = next_metric_val
+                if has_mlflow:
+                    mlflow.log_metric(f"z1{self.metric()}", next_metric_val)
+        else:
+            logger.info(
+                f"The model is not runable with ZERO stage {ZeroStageEnum.optimizer_states} (which requires at least {memory_to_string(required_gpu_mem, postfix='B')} memory with mbs = 1)"
+            )
+
+        required_gpu_mem = self.get_instantiation_memory_required_per_gpu(
+            ZeroStageEnum.gradients) + self.activation_mem
+        if self.gpu_mem > required_gpu_mem:
+            if "all" in user_zero_stages or ZeroStageEnum.gradients in user_zero_stages:
+                logger.info(
+                    f"The model might be runable with ZERO 2 (which requires at least {memory_to_string(required_gpu_mem, postfix='B')} memory), adding DEFAULT_TUNING_SPACE_ZERO_2 to the global tuning space"
+                )
+                next_max_mbs, next_mbs, next_metric_val = self.tune_space(DEFAULT_TUNING_SPACE_ZERO_2,
+                                                                          prev_max_mbs=max_mbs,
+                                                                          prev_best_mbs=mbs,
+                                                                          prev_best_metric_val=metric_val)
+                if next_mbs > mbs:
+                    mbs = next_mbs
+                    max_mbs = next_max_mbs
+                    metric_val = next_metric_val
+                if has_mlflow:
+                    mlflow.log_metric(f"z2{self.metric()}", next_metric_val)
+        else:
+            logger.info(
+                f"The model is not runable with ZERO stage {ZeroStageEnum.gradients} (which requires at least {memory_to_string(required_gpu_mem, postfix='B')} memory with mbs = 1)"
+            )
+
+        required_gpu_mem = self.get_instantiation_memory_required_per_gpu(ZeroStageEnum.weights) + self.activation_mem
+        if self.gpu_mem > required_gpu_mem:
+            if "all" in user_zero_stages or ZeroStageEnum.weights in user_zero_stages:
+                logger.info(
+                    f"The model might be runable with ZERO 3 (which requires at least {memory_to_string(required_gpu_mem, postfix='B')} memory), adding DEFAULT_TUNING_SPACE_ZERO_3 to the global tuning space"
+                )
+                _, _, next_metric_val = self.tune_space(DEFAULT_TUNING_SPACE_ZERO_3,
+                                                        prev_max_mbs=max_mbs,
+                                                        prev_best_mbs=mbs,
+                                                        prev_best_metric_val=metric_val)
+                if has_mlflow:
+                    mlflow.log_metric(f"z3{self.metric()}", next_metric_val)
+        else:
+            logger.info(
+                f"The model has {self.get_model_num_params()} parameters and requires at least {memory_to_string(required_gpu_mem, postfix='B')} memory per GPU with DeepSpeed Zero stage {ZeroStageEnum.weights} optimization. Memory per GPU in system is {memory_to_string(self.gpu_mem)}. No tuning is performed."
+            )
+            return
+        if has_mlflow:
+            mlflow.end_run()
+
+    def tune_space(self, tuning_space, prev_max_mbs=0, prev_best_mbs=0, prev_best_metric_val=0):
+        config_zero = tuning_space.get(ZERO_OPTIMIZATION, {})
+        stage = config_zero.get(ZERO_OPTIMIZATION_STAGE, None)
+        tuning_space_name = TUNING_MICRO_BATCH_SIZE_PREFIX + str(stage)
+        tuning_micro_batch_sizes = []
+        max_train_batch_size_per_gpu = 0
+        tuning_micro_batch_sizes_overwritten = False
+
+        # calculate max micro batch size using gpu memory, model instantiation memory and activation memory
+        # calculated_max_micro_batch_size = (memory_per_gpu - instantiation_memory) // activation_memory_micro_batch_size_1
+        calculated_max_micro_batch_size = int(
+            self.gpu_mem - self.get_instantiation_memory_required_per_gpu(stage)) // self.activation_mem
+        logger.info(
+            f"Start tuning for space {tuning_space_name}, calculated_max_micro_batch_size = {calculated_max_micro_batch_size}"
+        )
+
+        if calculated_max_micro_batch_size < prev_max_mbs:
+            logger.info(f"No need to tune Zero stage {stage}. End tuning for space {tuning_space_name}")
+            return 0, 0, 0
+
+        if TRAIN_MICRO_BATCH_SIZE_PER_GPU in self.user_config and isinstance(
+                self.user_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU], list):
+            # user-specified micro batch size per gpu is a list which overwrites the default tuning behavior
+            tuning_micro_batch_sizes = [
+                s for s in self.user_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU] if isinstance(s, int)
+            ]
+            gas = self.get_gas_from_user_config()
+            min_micro_batch_size = min(tuning_micro_batch_sizes)
+            max_micro_batch_size = max(tuning_micro_batch_sizes)
+            max_train_batch_size_per_gpu = max_micro_batch_size * gas
+            tuning_micro_batch_sizes_overwritten = True
+        else:
+            # auto-detects the list of micro batch sizes to tune
+            min_micro_batch_size, max_micro_batch_size = self.get_min_max_micro_batch_size(
+                stage, prev_max_mbs, calculated_max_micro_batch_size)
+
+            if max_micro_batch_size < prev_max_mbs:
+                logger.info(f"No need to tune Zero stage {stage}. End tuning for space {tuning_space_name}")
+                return 0, 0, 0
+
+            tuning_micro_batch_sizes, max_train_batch_size_per_gpu = self.get_tuning_micro_batch_size_list(
+                min_micro_batch_size,
+                max_micro_batch_size,
+                num_tuning_micro_batch_sizes=self.num_tuning_micro_batch_sizes())
+
+        logger.info(
+            f"tuning_micro_batch_sizes = {tuning_micro_batch_sizes}, max_train_batch_size_per_gpu = {max_train_batch_size_per_gpu}"
+        )
+
+        # return if the tuning_micro_batch_sizes list is empty
+        if not tuning_micro_batch_sizes:
+            logger.info(f"End tuning for space {tuning_space_name}")
+            return 0, 0, 0
+
+        # tune micro batch sizes and gradient accumulation steps given max_train_batch_size_per_gpu
+        tuning_micro_batch_sizes = self.run_tuning_micro_batch_sizes(tuning_micro_batch_sizes,
+                                                                     max_train_batch_size_per_gpu,
+                                                                     min_micro_batch_size, stage,
+                                                                     tuning_micro_batch_sizes_overwritten)
+
+        fast_best_record = self.get_best_space_record(tuning_space_name)
+        fast_best_metric_val = fast_best_record[1] if fast_best_record else 0
+        fast_best_mbs = fast_best_record[0][DS_CONFIG][TRAIN_MICRO_BATCH_SIZE_PER_GPU] if fast_best_record else 0
+        logger.info(f"fast_best_mbs = {fast_best_mbs}, name = {fast_best_record[0]['name']}")
+
+        if self.fast_enabled() or stage == 0:
+            logger.info(f"End tuning for space: {tuning_space_name}")
+            return max_micro_batch_size, fast_best_mbs, fast_best_metric_val
+
+        # if the best metric or the micro batch size for that best metric in the current Zero stage after tuning micro batch size is less than the corresponding value in the previous Zero stage, return, do not tune other Zero configuration parameters
+        if stage > 0:
+            if fast_best_mbs <= prev_best_mbs or fast_best_metric_val < prev_best_metric_val:
+                logger.info(
+                    f"End tuning for space: {tuning_space_name}. No need to tune other Zero configuration parameters.")
+                return max_micro_batch_size, fast_best_mbs, fast_best_metric_val
+
+        tuning_space[TRAIN_MICRO_BATCH_SIZE_PER_GPU] = tuning_micro_batch_sizes
+        tuning_space_name = canonical_name(tuning_space,
+                                           tuning_keys=get_tuning_keys(tuning_space),
+                                           prefix="z" + str(stage) + "_",
+                                           omit_val=True)
+
+        logger.info(f'Tuning space is {tuning_space}')
+        logger.info(f'Tuning space name is {tuning_space_name}')
+
+        exps = self._generate_experiments(tuning_space, max_train_batch_size_per_gpu)
+
+        logger.info(f'Tuner type is {self.autotuning_config.tuner_type}')
+        if self.autotuning_config.tuner_type == AUTOTUNING_TUNER_MODELBASED:
+            t = ModelBasedTuner(exps, self.rm, self.metric(), tuning_space)
+        elif self.autotuning_config.tuner_type == AUTOTUNING_TUNER_RANDOM:
+            t = RandomTuner(exps, self.rm, self.metric())
+        else:
+            t = GridSearchTuner(exps, self.rm, self.metric())
+
+        sample_size = len(self.rm.nodes) * self.rm.num_gpus_per_node // (self.exp_num_gpus * self.exp_num_nodes)
+        num_exps = t.tune(sample_size=sample_size,
+                          n_trials=self.autotuning_config.tuner_num_trials,
+                          early_stopping=self.autotuning_config.tuner_early_stopping)
+        exp = t.best_exp
+        metric_val = t.best_metric_val
+        if exp:
+            self.update_records(tuning_space_name, exp, metric_val, num_exps)
+
+        full_best_record = self.get_best_space_record(tuning_space_name)
+        full_best_metric_val = full_best_record[1] if full_best_record else -1
+
+        if full_best_metric_val > fast_best_metric_val:
+            best_metric_val = full_best_metric_val
+            best_mbs = full_best_record[0][DS_CONFIG][TRAIN_MICRO_BATCH_SIZE_PER_GPU] if full_best_record else -1
+        else:
+            best_metric_val = fast_best_metric_val
+            best_mbs = fast_best_mbs
+
+        logger.info(f"End tuning for space: {tuning_space_name}")
+        return max_micro_batch_size, best_mbs, best_metric_val
+
+    def get_plateau_mbs(self, tuning_space_name):
+        if tuning_space_name not in self.records:
+            return 0
+        space_records = self.records[tuning_space_name]
+        sorted_space_records = sorted(space_records, key=lambda x: x[0][DS_CONFIG][TRAIN_MICRO_BATCH_SIZE_PER_GPU])
+        prev_metric_val = None
+        prev_micro_batch_size = 0
+        for (exp, metric_val, _) in sorted_space_records:
+            if prev_metric_val:
+                if metric_val < prev_metric_val:
+                    break
+                if (metric_val >= prev_metric_val
+                        and (metric_val - prev_metric_val) / prev_metric_val < METRIC_PERCENT_DIFF_CONST):
+                    break
+            prev_metric_val = metric_val
+            prev_micro_batch_size = exp[DS_CONFIG][TRAIN_MICRO_BATCH_SIZE_PER_GPU]
+        plateau_mbs = prev_micro_batch_size
+        return plateau_mbs
+
+    def get_model_num_params(self):
+        if self.model_info and "num_params" in self.model_info:
+            return self.model_info["num_params"]
+
+    def model_info_profile_run(self):
+        """Does a model information profiling experiment that collects the number of model parameters and activation memory.\
+            The experiment produces a "profile_model_info" folder under self.results_dir.
+        Returns:
+            [dict]: a model information dictionary, e.g., {"num_params": 335144976, "trainable_num_params": 335144976, "activation_mem_per_gpu": 324358144, "rank": 0}
+        """
+        logger.info("Starting model info profile run.")
+        model_info = self.autotuning_config.model_info
+        if model_info and MODEL_INFO_NUM_PARAMS in model_info:
+            return model_info
+
+        ds_config = copy.deepcopy(self.user_config)
+        replace_dict(ds_config, DEFAULT_MIN_MEM_CONFIG)
+
+        model_info_path = os.path.join(self.results_dir, "profile_model_info", "model_info.json")
+        ds_config[AUTOTUNING] = {"enabled": True, "model_info_path": model_info_path, "model_info": {"profile": True}}
+
+        exp_config = {}
+        exp_name = "profile_model_info"
+        exp_config['name'] = exp_name
+        exp_config[DS_CONFIG] = ds_config
+        exp_config['num_gpus'] = self.exp_num_gpus
+        exp_config['num_nodes'] = self.exp_num_nodes
+        exp_config['hostfile'] = self.args.hostfile
+        exp_path = os.path.join(self.exps_dir, f'{exp_name}.json')
+
+        with open(exp_path, 'w', buffering=BUFSIZE) as fd:
+            json.dump(exp_config, fd)
+            fd.flush()
+            os.fsync(fd)
+
+        self.rm.schedule_experiments([exp_path])
+        self.rm.run()
+
+        for exp_id, (exp_json, err) in self.rm.finished_experiments.items():
+            self.rm.clear()
+            if err:
+                logger.error(f"The model is not runnable with DeepSpeed with error = {err}")
+                return None
+
+        if os.path.exists(model_info_path):
+            with open(model_info_path, 'r') as f:
+                model_info = hjson.load(f)
+                return model_info
+
+    def update_records(self, space_name, exp, metric_val, num_exps):
+        if space_name not in self.records:
+            self.records[space_name] = [(exp, metric_val, num_exps)]
+        else:
+            self.records[space_name].append((exp, metric_val, num_exps))
+
+    def get_best_space_record(self, space_name):
+        if space_name not in self.records:
+            return None
+        space_records = self.records[space_name]
+        best_space_record = None
+        space_num_exps = 0
+        for (exp, metric_val, num_exps) in space_records:
+            space_num_exps += num_exps
+            if best_space_record is None or metric_val > best_space_record[1]:
+                best_space_record = (exp, metric_val)
+        if best_space_record:
+            best_space_record = best_space_record + (space_num_exps, )
+        return best_space_record
+
+    def get_best_space_records(self):
+        best_space_records = {}
+        global_best_record = None
+        for space_name, space_records in self.records.items():
+            best_space_record = self.get_best_space_record(space_name)
+            if best_space_record:
+                best_space_records[space_name] = best_space_record
+                if not global_best_record or best_space_record[1] > global_best_record[1]:
+                    global_best_record = best_space_record
+        if global_best_record:
+            best_space_records[GLOBAL_TUNING_SPACE] = global_best_record
+        return best_space_records
+
+    def run_tuning_micro_batch_sizes(self, tuning_micro_batch_sizes, max_train_batch_size_per_gpu,
+                                     min_micro_batch_size, stage, tuning_micro_batch_sizes_overwritten):
+        assert tuning_micro_batch_sizes, "the tuning micro batch size list is empty"
+        tuning_micro_batch_sizes.sort()
+        max_micro_batch_size = tuning_micro_batch_sizes[-1]
+        max_micro_batch_size_metric_val = 0
+
+        ds_config = get_first_config(self.user_config)
+        ds_config[ZERO_OPTIMIZATION] = {ZERO_OPTIMIZATION_STAGE: stage}
+        tuning_space_name = TUNING_MICRO_BATCH_SIZE_PREFIX + str(stage)
+
+        exp_paths = []
+        for mbs in tuning_micro_batch_sizes:
+            ds_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU] = mbs
+            gas = max_train_batch_size_per_gpu // mbs
+            ds_config[GRADIENT_ACCUMULATION_STEPS] = gas
+            ds_config[TRAIN_BATCH_SIZE] = mbs * gas * \
+                self.exp_num_gpus * self.exp_num_nodes // self.mp_size()
+            exp_name = tuning_space_name + "_gas" + str(gas) + "_tmbspg" + str(mbs)
+            exp_config = {}
+            exp_config['name'] = exp_name
+            exp_config[DS_CONFIG] = ds_config
+            exp_config['num_gpus'] = self.exp_num_gpus
+            exp_config['num_nodes'] = self.exp_num_nodes
+            exp_config['hostfile'] = self.args.hostfile
+            exp_path = os.path.join(self.exps_dir, f'{exp_name}.json')
+
+            with open(exp_path, 'w', buffering=BUFSIZE) as fd:
+                json.dump(exp_config, fd)
+                fd.flush()
+                os.fsync(fd)
+            exp_paths.append(exp_path)
+
+        self.rm.schedule_experiments(exp_paths)
+        self.rm.run()
+
+        for exp_id, (exp, err) in self.rm.finished_experiments.items():
+            if exp:
+                metric_file = exp[DS_CONFIG][AUTOTUNING][AUTOTUNING_METRIC_PATH]
+                if os.path.exists(metric_file):
+
+                    with open(metric_file, 'r') as f:
+                        results = hjson.load(f)
+                        metric_val = results[self.metric()]
+                        self.update_records(tuning_space_name, exp, metric_val, 1)
+                        if max_micro_batch_size == exp[DS_CONFIG][TRAIN_MICRO_BATCH_SIZE_PER_GPU]:
+                            max_micro_batch_size_metric_val = metric_val
+                        if has_mlflow:
+                            os.environ.pop('MLFLOW_RUN_ID')
+                            mlflow.start_run(nested=True, run_name=exp['name'])
+                            for metric in results:
+                                mlflow.log_metric(metric, results[metric])
+                            mlflow.end_run()
+                            os.environ['MLFLOW_RUN_ID'] = self.mlflow_parent_id
+                else:
+                    self.update_records(tuning_space_name, exp, 0, 1)
+            else:
+                mbs = exp[DS_CONFIG][TRAIN_MICRO_BATCH_SIZE_PER_GPU]
+                logger.info(f"micro batch size = {mbs} was not run successfully")
+
+        self.rm.clear()
+
+        if tuning_micro_batch_sizes_overwritten:
+            return tuning_micro_batch_sizes
+
+        # in a auto-detected tuning_micro_batch_sizes list, max_micro_batch_size might not be performant as the memory consumption is close to max
+        # try smaller values while gas stays the same
+        # if finding a more performant mbs value, use it to replace max_micro_batch_size in the list
+        min_micro_batch_size_with_same_gas = (tuning_micro_batch_sizes[-2] +
+                                              1) if len(tuning_micro_batch_sizes) > 1 else min_micro_batch_size
+
+        prev_best_metric_val = max_micro_batch_size_metric_val
+        prev_best_mbs = max_micro_batch_size
+
+        stride = (max_micro_batch_size - min_micro_batch_size_with_same_gas) // 3
+        if stride == 0:
+            stride = 1
+        for mbs in reversed(range(min_micro_batch_size_with_same_gas, max_micro_batch_size, stride)):
+            ds_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU] = mbs
+            gas = max_train_batch_size_per_gpu // mbs
+            ds_config[GRADIENT_ACCUMULATION_STEPS] = gas
+            ds_config[TRAIN_BATCH_SIZE] = mbs * gas * \
+                self.exp_num_gpus * self.exp_num_nodes // self.mp_size()
+            exp_name = tuning_space_name + "_gas" + str(gas) + "_tmbspg" + str(mbs)
+            exp, metric_val = self.run_ds_config(ds_config, exp_name)
+
+            if metric_val:
+                with open(metric_file, 'r') as f:
+                    results = hjson.load(f)
+                    metric_val = results[self.metric()]
+                    if has_mlflow:
+                        os.environ.pop('MLFLOW_RUN_ID')
+                        mlflow.start_run(nested=True, run_name=exp_name)
+                        for metric in results:
+                            mlflow.log_metric(metric, results[metric])
+                        mlflow.end_run()
+                        os.environ['MLFLOW_RUN_ID'] = self.mlflow_parent_id
+                self.update_records(tuning_space_name, exp, metric_val, 1)
+                if metric_val > prev_best_metric_val * (1 + METRIC_PERCENT_DIFF_CONST):
+                    prev_best_metric_val = metric_val
+                    prev_best_mbs = mbs
+                else:
+                    break
+            else:
+                self.update_records(tuning_space_name, exp, 0, 1)
+                break
+        if prev_best_mbs != max_micro_batch_size:
+            tuning_micro_batch_sizes[-1] = prev_best_mbs
+        return tuning_micro_batch_sizes
+
+    def get_min_max_micro_batch_size(self, stage, min_micro_batch_size, calculated_max_micro_batch_size):
+        # get min and max micro batch size with gradient accumulation steps = 1
+        if min_micro_batch_size > calculated_max_micro_batch_size:
+            return -1, -1
+
+        used_micro_batch_sizes = []
+        tuning_space_name = TUNING_MICRO_BATCH_SIZE_PREFIX + str(stage)
+
+        ds_config = get_first_config(self.user_config)
+        ds_config[ZERO_OPTIMIZATION] = {ZERO_OPTIMIZATION_STAGE: stage}
+        gas = self.get_gas_from_user_config()
+        ds_config[GRADIENT_ACCUMULATION_STEPS] = gas
+
+        # search for the min micro batch size
+        if min_micro_batch_size < 1:
+            if TRAIN_MICRO_BATCH_SIZE_PER_GPU in self.user_config and isinstance(
+                    self.user_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU], int):
+                # user specifies train_micro_batch_size_per_gpu as an int
+                mbs = int(self.user_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU])
+            else:
+                # user does not specify train_micro_batch_size_per_gpu or sets it to "auto" when using Hugging Face
+                val = self.get_val_from_user_args(TRAIN_MICRO_BATCH_SIZE_PER_GPU)
+                if val:
+                    mbs = int(val)
+                else:
+                    mbs = 1
+            assert mbs > 0, "The micro batch size per GPU must be greater than 0."
+            ds_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU] = mbs
+            ds_config[GRADIENT_ACCUMULATION_STEPS] = gas
+            ds_config[TRAIN_BATCH_SIZE] = mbs * gas * \
+                self.exp_num_gpus * self.exp_num_nodes // self.mp_size()
+            exp_name = tuning_space_name + "_gas" + str(gas) + "_tmbspg" + str(mbs)
+            exp, metric_val = self.run_ds_config(ds_config, exp_name)
+            if metric_val:
+                self.update_records(tuning_space_name, exp, metric_val, 1)
+                used_micro_batch_sizes.append(mbs)
+                min_micro_batch_size = mbs
+            else:
+                self.update_records(tuning_space_name, exp, 0, 1)
+                logger.info(f"User-specified micro batch size per GPU {mbs} does not run")
+                if self.min_train_micro_batch_size_per_gpu() == mbs:
+                    return -1, -1
+                mbs = self.min_train_micro_batch_size_per_gpu()
+                ds_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU] = mbs
+                ds_config[GRADIENT_ACCUMULATION_STEPS] = gas
+                ds_config[TRAIN_BATCH_SIZE] = mbs * gas * \
+                    self.exp_num_gpus * self.exp_num_nodes // self.mp_size()
+                exp_name = tuning_space_name + "_gas" + str(gas) + "_tmbspg" + str(mbs)
+                exp, metric_val = self.run_ds_config(ds_config, exp_name)
+                if not metric_val:
+                    self.update_records(tuning_space_name, exp, 0, 1)
+                    logger.info(f"min_train_micro_batch_size_per_gpu {mbs} is not runnable.")
+                    return -1, -1
+                self.update_records(tuning_space_name, exp, metric_val, 1)
+                min_micro_batch_size = mbs
+                used_micro_batch_sizes.append(mbs)
+        else:
+            ds_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU] = min_micro_batch_size
+            ds_config[GRADIENT_ACCUMULATION_STEPS] = gas
+            ds_config[TRAIN_BATCH_SIZE] = min_micro_batch_size * gas * \
+                self.exp_num_gpus * self.exp_num_nodes // self.mp_size()
+            exp_name = tuning_space_name + "_gas" + str(gas) + "_tmbspg" + str(min_micro_batch_size)
+            exp, metric_val = self.run_ds_config(ds_config, exp_name)
+            if metric_val:
+                self.update_records(tuning_space_name, exp, metric_val, 1)
+                used_micro_batch_sizes.append(min_micro_batch_size)
+            else:
+                self.update_records(tuning_space_name, exp, 0, 1)
+                return -1, -1
+
+        # search for the max micro batch size
+        max_micro_batch_size = min(calculated_max_micro_batch_size, self.max_train_micro_batch_size_per_gpu())
+        for mbs in [math.ceil(1.05 * max_micro_batch_size), max_micro_batch_size, int(0.95 * max_micro_batch_size)]:
+            if mbs > self.max_train_micro_batch_size_per_gpu():
+                continue
+            if mbs in used_micro_batch_sizes:
+                return min_micro_batch_size, mbs
+            ds_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU] = mbs
+            ds_config[TRAIN_BATCH_SIZE] = mbs * gas * \
+                self.exp_num_gpus * self.exp_num_nodes // self.mp_size()
+            exp_name = tuning_space_name + "_gas" + str(gas) + "_tmbspg" + str(mbs)
+            exp, metric_val = self.run_ds_config(ds_config, exp_name)
+
+            if metric_val:
+                logger.info(f"mbs = {mbs} is found as max mbs")
+                self.update_records(tuning_space_name, exp, metric_val, 1)
+                used_micro_batch_sizes.append(mbs)
+                return min_micro_batch_size, mbs
+            else:
+                self.update_records(tuning_space_name, exp, 0, 1)
+
+        space_records = self.records[tuning_space_name] if tuning_space_name in self.records else []
+        if space_records:
+            prev_idx = min(range(len(space_records)),
+                           key=lambda i: abs(space_records[i][0][DS_CONFIG][TRAIN_MICRO_BATCH_SIZE_PER_GPU] -
+                                             min_micro_batch_size))
+            prev_metric_val = space_records[prev_idx][1]
+        else:
+            prev_metric_val = None
+
+        low = min_micro_batch_size
+        high = max_micro_batch_size
+        # binary search until low is the smallest micro batch size that OOMs.
+        while low <= high:
+            mid = int((low + high) // 2)
+            logger.debug(f"trying mbs = {mid}, low = {low}, high = {high}")
+            if mid not in used_micro_batch_sizes:
+                ds_config[TRAIN_MICRO_BATCH_SIZE_PER_GPU] = mid
+                ds_config[TRAIN_BATCH_SIZE] = mid * gas * \
+                    self.exp_num_gpus * self.exp_num_nodes // self.mp_size()
+                exp_name = tuning_space_name + "_gas" + str(gas) + "_tmbspg" + str(mid)
+                exp, metric_val = self.run_ds_config(ds_config, exp_name)
+                if metric_val:
+                    low = mid + 1
+                    self.update_records(tuning_space_name, exp, metric_val, 1)
+                    used_micro_batch_sizes.append(mid)
+                    if prev_metric_val and (
+                        (metric_val - prev_metric_val) / prev_metric_val) < METRIC_PERCENT_DIFF_CONST:
+                        logger.info(f"performance plateaus at mbs = {low}")
+                        break
+                    prev_metric_val = metric_val
+                else:
+                    self.update_records(tuning_space_name, exp, 0, 1)
+                    high = mid - 1
+            else:
+                low = mid + 1
+        max_micro_batch_size = low - 1
+
+        logger.info(f"min_micro_batch_size = {min_micro_batch_size}, max_micro_batch_size = {max_micro_batch_size}.")
+
+        return min_micro_batch_size, max_micro_batch_size
+
+    def get_gas_from_user_config(self):
+        gas = 1
+        if GRADIENT_ACCUMULATION_STEPS in self.user_config:
+            gas_in_config = self.user_config[GRADIENT_ACCUMULATION_STEPS]
+            if isinstance(gas_in_config, int):
+                gas = gas_in_config
+            elif gas_in_config == "auto":  # GRADIENT_ACCUMULATION_STEPS: "auto"
+                val = self.get_val_from_user_args(GRADIENT_ACCUMULATION_STEPS)
+                if val:
+                    gas = int(val)
+            elif isinstance(gas_in_config, list):
+                logger.info(
+                    f"Specifying a list of {GRADIENT_ACCUMULATION_STEPS} to tune is not supported. 1 would be used.")
+        assert gas > 0, "Gradient accumulation steps must be positive."
+        return gas
+
+    def get_val_from_user_args(self, ds_name):
+        arg_mappings = self.autotuning_config.arg_mappings
+        user_args = self.args.user_args
+        if arg_mappings and ds_name in arg_mappings:
+            arg_name = arg_mappings[ds_name]
+            if arg_name in user_args:
+                idx = user_args.index(arg_name)
+                if user_args[idx + 1].isnumeric():
+                    return (user_args[idx + 1])
+        return None
+
+    def get_tuning_micro_batch_size_list(self, min_micro_batch_size, max_micro_batch_size,
+                                         num_tuning_micro_batch_sizes):
+        """Get a list of micro batch sizes to tune based on min and max values, as well as the size of the list.
+        Args:
+            min_micro_batch_size ([int]): min micro batch size per GPU
+            max_micro_batch_size ([int]): max micro batch size per GPU
+            num_tuning_micro_batch_sizes (int): the number of items in the returned list
+
+        Returns:
+            [list]: a list of micro batch sizes to tune.
+        """
+        if min_micro_batch_size <= 0 or max_micro_batch_size <= 0:
+            logger.info(
+                f"min_micro_batch_size = {min_micro_batch_size}, max_micro_batch_size = {max_micro_batch_size}")
+            return [], 0
+
+        # NUM_GPUS=$(( ${NUM_WORKERS} * ${NUM_GPUS_PER_WORKER} ))
+        # DP_SIZE=$(( ${NUM_GPUS} / (${PP_SIZE} * ${MP_SIZE}) ))
+        # GRAD_ACC_STEPS=$(( ${TARGET_GLOBAL_BATCH_SIZE} / (${BATCH_SIZE} * ${DP_SIZE}) ))
+        if self.max_train_batch_size(
+        ) and self.max_train_batch_size() > 0:  # if the user specifies a max_train_batch_size
+            max_train_batch_size_per_gpu = self.max_train_batch_size() * self.mp_size() // (self.exp_num_gpus *
+                                                                                            self.exp_num_nodes)
+        else:
+            gas = self.get_gas_from_user_config()
+            max_train_batch_size_per_gpu = max_micro_batch_size * gas // self.mp_size()
+        logger.info(f"max_train_batch_size_per_gpu = {max_train_batch_size_per_gpu}")
+        if min_micro_batch_size < max_micro_batch_size // 2:
+            min_micro_batch_size = max_micro_batch_size // 2
+
+        # constant stride
+        stride = (max_micro_batch_size - min_micro_batch_size) // num_tuning_micro_batch_sizes
+        if stride == 0:
+            stride = 1
+        ls = []
+        min_gas = max_train_batch_size_per_gpu // max_micro_batch_size
+        # if gas is the same as min_gas, do not add mbs to the tuning list
+        for mbs in range(min_micro_batch_size, max_micro_batch_size, stride):
+            if max_train_batch_size_per_gpu // mbs != min_gas:
+                ls.append(mbs)
+        ls.append(max_micro_batch_size)
+
+        return ls, max_train_batch_size_per_gpu
+
+    def run_ds_config(self, ds_config, exp_name):
+        exp_config = {}
+        exp_config['name'] = exp_name
+        exp_config[DS_CONFIG] = ds_config
+        exp_config['num_gpus'] = self.exp_num_gpus
+        exp_config['num_nodes'] = self.exp_num_nodes
+        exp_config['hostfile'] = self.args.hostfile
+        exp_path = os.path.join(self.exps_dir, f'{exp_name}.json')
+
+        logger.debug(f'run_ds_config exp_name = {exp_name}')
+
+        with open(exp_path, 'w', buffering=BUFSIZE) as fd:
+            json.dump(exp_config, fd)
+            fd.flush()
+            os.fsync(fd)
+        self.rm.schedule_experiments([exp_path])
+        self.rm.run()
+        exp, metric_val = self.rm.parse_results(self.metric())
+        self.rm.clear()
+        return exp, metric_val
+
+    def write_optimal_config(self):
+        best_space_records = self.get_best_space_records()
+        if GLOBAL_TUNING_SPACE not in best_space_records:
+            return
+        best_exp, best_metric_val, _ = best_space_records[GLOBAL_TUNING_SPACE]
+        if best_exp:
+            exp_dir = best_exp["result_dir"]
+            cmd = None
+            with open(os.path.join(exp_dir, "cmd.txt"), "r") as f:
+                cmd = [str(i) for i in f.read().split()]
+
+            ds_config = hjson.load(open(os.path.join(exp_dir, "ds_config.json"), "r"))
+            ds_config.pop(AUTOTUNING)
+
+            ds_config_path = os.path.join(self.results_dir, "ds_config_optimal.json")
+            json.dump(ds_config, open(ds_config_path, "w"))
+
+            cmd_path = os.path.join(self.results_dir, "cmd_optimal.txt")
+            with open(cmd_path, "w") as fd:
+                fd.write(" ".join(cmd))
+                fd.write("\n")
+                fd.flush()
+            self.optimal_cmd = cmd
+            self.optimal_ds_config = ds_config
+            logger.info(
+                f"Wrote the optimal DeepSpeed configuration found by autotuning to {ds_config_path}, and the corresponding DeepSpeed command to {cmd_path}"
+            )
+
+    def run_after_tuning(self):
+        """ Launches the training with the optimal DeepSpeed configuration found through the autotuning process.
+            "ds_config_optimal.json" describing the optimal DeepSpeed configuration as well the command used to launch training "cmd_optimal.txt" are saved to self.results_dir.
+        """
+        if self.optimal_cmd:
+            result = subprocess.Popen(self.optimal_cmd)
+            result.wait()
+
+            logger.info(f"Done running with the optimal DeepSpeed configuration using {self.optimal_cmd}")
+        else:
+            logger.info(f"No optimal DeepSpeed configuration found by autotuning.")

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

@@ -0,0 +1,98 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from deepspeed.runtime.config_utils import get_scalar_param, get_dict_param, DeepSpeedConfigObject
+from deepspeed.autotuning.constants import *
+
+
+class DeepSpeedAutotuningConfig(DeepSpeedConfigObject):
+
+    def __init__(self, param_dict):
+        super(DeepSpeedAutotuningConfig, self).__init__()
+
+        self.enabled = None
+        self.start_step = None
+        self.end_step = None
+        self.metric_path = None
+        self.arg_mappings = None
+        self.metric = None
+        self.model_info = None
+        self.results_dir = None
+        self.exps_dir = None
+        self.overwrite = None
+
+        if param_dict and AUTOTUNING in param_dict.keys():
+            autotuning_dict = param_dict[AUTOTUNING]
+        else:
+            autotuning_dict = {}
+
+        self._initialize(autotuning_dict)
+
+    def _initialize(self, autotuning_dict):
+        self.enabled = get_scalar_param(autotuning_dict, AUTOTUNING_ENABLED, AUTOTUNING_ENABLED_DEFAULT)
+
+        self.fast = get_scalar_param(autotuning_dict, AUTOTUNING_FAST, AUTOTUNING_FAST_DEFAULT)
+
+        self.results_dir = get_scalar_param(autotuning_dict, AUTOTUNING_RESULTS_DIR, AUTOTUNING_RESULTS_DIR_DEFAULT)
+        assert self.results_dir, "results_dir cannot be empty"
+        self.exps_dir = get_scalar_param(autotuning_dict, AUTOTUNING_EXPS_DIR, AUTOTUNING_EXPS_DIR_DEFAULT)
+        assert self.exps_dir, "exps_dir cannot be empty"
+        self.overwrite = get_scalar_param(autotuning_dict, AUTOTUNING_OVERWRITE, AUTOTUNING_OVERWRITE_DEFAULT)
+
+        self.start_profile_step = get_scalar_param(autotuning_dict, AUTOTUNING_START_PROFILE_STEP,
+                                                   AUTOTUNING_START_PROFILE_STEP_DEFAULT)
+
+        self.end_profile_step = get_scalar_param(autotuning_dict, AUTOTUNING_END_PROFILE_STEP,
+                                                 AUTOTUNING_END_PROFILE_STEP_DEFAULT)
+
+        self.metric = get_scalar_param(autotuning_dict, AUTOTUNING_METRIC, AUTOTUNING_METRIC_DEFAULT)
+
+        self.metric_path = get_scalar_param(autotuning_dict, AUTOTUNING_METRIC_PATH, AUTOTUNING_METRIC_PATH_DEFAULT)
+
+        self.tuner_type = get_scalar_param(autotuning_dict, AUTOTUNING_TUNER_TYPE, AUTOTUNING_TUNER_TYPE_DEFAULT)
+
+        self.tuner_early_stopping = get_scalar_param(autotuning_dict, AUTOTUNING_TUNER_EARLY_STOPPING,
+                                                     AUTOTUNING_TUNER_EARLY_STOPPING_DEFAULT)
+
+        self.tuner_num_trials = get_scalar_param(autotuning_dict, AUTOTUNING_TUNER_NUM_TRIALS,
+                                                 AUTOTUNING_TUNER_NUM_TRIALS_DEFAULT)
+
+        self.arg_mappings = get_dict_param(autotuning_dict, AUTOTUNING_ARG_MAPPINGS, AUTOTUNING_ARG_MAPPINGS_DEFAULT)
+
+        self.model_info = get_model_info_config(autotuning_dict)
+
+        self.model_info_path = get_scalar_param(autotuning_dict, AUTOTUNING_MODEL_INFO_PATH,
+                                                AUTOTUNING_MODEL_INFO_PATH_DEFAULT)
+        self.mp_size = get_scalar_param(autotuning_dict, AUTOTUNING_MP_SIZE, AUTOTUNING_MP_SIZE_DEFAULT)
+
+        self.max_train_batch_size = get_dict_param(autotuning_dict, AUTOTUNING_MAX_TRAIN_BATCH_SIZE,
+                                                   AUTOTUNING_MAX_TRAIN_BATCH_SIZE_DEFAULT)
+
+        self.min_train_batch_size = get_dict_param(autotuning_dict, AUTOTUNING_MIN_TRAIN_BATCH_SIZE,
+                                                   AUTOTUNING_MIN_TRAIN_BATCH_SIZE_DEFAULT)
+
+        self.max_train_micro_batch_size_per_gpu = get_dict_param(
+            autotuning_dict, AUTOTUNING_MAX_TRAIN_MICRO_BATCH_SIZE_PER_GPU,
+            AUTOTUNING_MAX_TRAIN_MICRO_BATCH_SIZE_PER_GPU_DEFAULT)
+
+        self.min_train_micro_batch_size_per_gpu = get_dict_param(
+            autotuning_dict, AUTOTUNING_MIN_TRAIN_MICRO_BATCH_SIZE_PER_GPU,
+            AUTOTUNING_MIN_TRAIN_MICRO_BATCH_SIZE_PER_GPU_DEFAULT)
+
+        self.num_tuning_micro_batch_sizes = get_dict_param(autotuning_dict, AUTOTUNING_NUM_TUNING_MICRO_BATCH_SIZES,
+                                                           AUTOTUNING_NUM_TUNING_MICRO_BATCH_SIZES_DEFAULT)
+
+
+def get_model_info_config(param_dict):
+    if MODEL_INFO in param_dict and param_dict[MODEL_INFO] is not None:
+        model_info_config = {}
+        for key, default_value in MODEL_INFO_KEY_DEFAULT_DICT.items():
+            model_info_config[key] = get_scalar_param(param_dict[MODEL_INFO], key, default_value)
+        return model_info_config
+    return None
+
+
+def get_default_model_info_config():
+    return MODEL_INFO_KEY_DEFAULT_DICT

venv/lib/python3.10/site-packages/deepspeed/autotuning/config_templates/template_zero0.json

@@ -0,0 +1,5 @@
+{
+  "zero_optimization": {
+    "stage": 0
+  }
+}

venv/lib/python3.10/site-packages/deepspeed/autotuning/config_templates/template_zero1.json

@@ -0,0 +1,7 @@
+{
+  "zero_optimization": {
+    "stage": 1,
+    "reduce_bucket_size": 5e8,
+    "allgather_bucket_size": 5e8
+  }
+}

venv/lib/python3.10/site-packages/deepspeed/autotuning/config_templates/template_zero2.json

@@ -0,0 +1,11 @@
+{
+  "zero_optimization": {
+    "stage": 2,
+    "allgather_partitions": true,
+    "allgather_bucket_size": 5e8,
+    "overlap_comm": false,
+    "reduce_scatter": true,
+    "reduce_bucket_size": 5e8,
+    "contiguous_gradients": false
+  }
+}

venv/lib/python3.10/site-packages/deepspeed/autotuning/config_templates/template_zero3.json

@@ -0,0 +1,17 @@
+{
+  "zero_optimization": {
+    "stage": 3,
+    "allgather_partitions": true,
+    "allgather_bucket_size": 5e8,
+    "overlap_comm": false,
+    "reduce_scatter": true,
+    "reduce_bucket_size": 5e8,
+    "contiguous_gradients": false,
+    "stage3_max_live_parameters": 1e9,
+    "stage3_max_reuse_distance": 1e9,
+    "stage3_prefetch_bucket_size": 5e8,
+    "stage3_param_persistence_threshold": 1e6,
+    "stage3_gather_16bit_weights_on_model_save": false,
+    "sub_group_size": 1e12
+  }
+}

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

@@ -0,0 +1,185 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+#########################################
+# autotuner implementation constants
+#########################################
+
+import os
+
+DEFAULT_TEMPLATE_PATH_ZERO_0 = os.path.join(os.path.dirname(os.path.realpath(__file__)), "config_templates",
+                                            "template_zero0.json")
+DEFAULT_TEMPLATE_PATH_ZERO_1 = os.path.join(os.path.dirname(os.path.realpath(__file__)), "config_templates",
+                                            "template_zero1.json")
+DEFAULT_TEMPLATE_PATH_ZERO_2 = os.path.join(os.path.dirname(os.path.realpath(__file__)), "config_templates",
+                                            "template_zero2.json")
+DEFAULT_TEMPLATE_PATH_ZERO_3 = os.path.join(os.path.dirname(os.path.realpath(__file__)), "config_templates",
+                                            "template_zero3.json")
+
+METRIC_PERCENT_DIFF_CONST = 0.05
+DS_CONFIG = "ds_config"
+BUFSIZE = 1  # line buffer size for writing files
+
+#########################################
+# autotuner configuration constants
+#########################################
+# Autotuner. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+AUTOTUNING_FORMAT = """
+autotuner should be enabled as:
+"session_params": {
+  "autotuning": {
+    "enabled": true,
+    "start_step": 5,
+    "end_step": 15
+    }
+}
+"""
+
+AUTOTUNING = "autotuning"
+
+AUTOTUNING_ENABLED = "enabled"
+AUTOTUNING_ENABLED_DEFAULT = False
+
+AUTOTUNING_FAST = "fast"
+AUTOTUNING_FAST_DEFAULT = True
+
+AUTOTUNING_RESULTS_DIR = "results_dir"
+AUTOTUNING_RESULTS_DIR_DEFAULT = "autotuning_results"
+
+AUTOTUNING_EXPS_DIR = "exps_dir"
+AUTOTUNING_EXPS_DIR_DEFAULT = "autotuning_exps"
+
+AUTOTUNING_OVERWRITE = "overwrite"
+AUTOTUNING_OVERWRITE_DEFAULT = True
+
+AUTOTUNING_START_PROFILE_STEP = "start_profile_step"
+AUTOTUNING_START_PROFILE_STEP_DEFAULT = 3
+
+AUTOTUNING_END_PROFILE_STEP = "end_profile_step"
+AUTOTUNING_END_PROFILE_STEP_DEFAULT = 5
+AUTOTUNING_METRIC_PATH = "metric_path"
+AUTOTUNING_METRIC_PATH_DEFAULT = None
+
+AUTOTUNING_TUNER_TYPE = "tuner_type"
+AUTOTUNING_TUNER_GRIDSEARCH = "gridsearch"
+AUTOTUNING_TUNER_RANDOM = "random"
+AUTOTUNING_TUNER_MODELBASED = "model_based"
+AUTOTUNING_TUNER_TYPE_DEFAULT = AUTOTUNING_TUNER_GRIDSEARCH
+AUTOTUNING_TUNER_EARLY_STOPPING = "tuner_early_stopping"
+AUTOTUNING_TUNER_EARLY_STOPPING_DEFAULT = 5
+AUTOTUNING_TUNER_NUM_TRIALS = "tuner_num_trials"
+AUTOTUNING_TUNER_NUM_TRIALS_DEFAULT = 50
+
+AUTOTUNING_ARG_MAPPINGS = "arg_mappings"
+AUTOTUNING_ARG_MAPPINGS_DEFAULT = None
+
+AUTOTUNING_MAX_TRAIN_BATCH_SIZE = "max_train_batch_size"
+AUTOTUNING_MAX_TRAIN_BATCH_SIZE_DEFAULT = None
+AUTOTUNING_MIN_TRAIN_BATCH_SIZE = "min_train_batch_size"
+AUTOTUNING_MIN_TRAIN_BATCH_SIZE_DEFAULT = 1
+AUTOTUNING_MAX_TRAIN_MICRO_BATCH_SIZE_PER_GPU = "max_train_micro_batch_size_per_gpu"
+AUTOTUNING_MAX_TRAIN_MICRO_BATCH_SIZE_PER_GPU_DEFAULT = 1024
+AUTOTUNING_MIN_TRAIN_MICRO_BATCH_SIZE_PER_GPU = "min_train_micro_batch_size_per_gpu"
+AUTOTUNING_MIN_TRAIN_MICRO_BATCH_SIZE_PER_GPU_DEFAULT = 1
+AUTOTUNING_NUM_TUNING_MICRO_BATCH_SIZES = "num_tuning_micro_batch_sizes"
+AUTOTUNING_NUM_TUNING_MICRO_BATCH_SIZES_DEFAULT = 3
+
+AUTOTUNING_MP_SIZE = "mp_size"
+AUTOTUNING_MP_SIZE_DEFAULT = 1
+
+AUTOTUNING_METRIC = "metric"
+AUTOTUNING_METRIC_LATENCY = "latency"
+AUTOTUNING_METRIC_THROUGHPUT = "throughput"
+AUTOTUNING_METRIC_FLOPS = "flops"
+AUTOTUNING_METRIC_FORWARD = "forward"
+AUTOTUNING_METRIC_BACKWRAD = "flops"
+AUTOTUNING_METRIC_STEPS = "step"
+AUTOTUNING_METRIC_DEFAULT = AUTOTUNING_METRIC_THROUGHPUT
+
+#########################################
+# MODEL INFO
+#########################################
+AUTOTUNING_MODEL_INFO_PATH = "model_info_path"
+AUTOTUNING_MODEL_INFO_PATH_DEFAULT = None
+
+MODEL_INFO_FORMAT = '''
+"model_info": {
+  "num_params": 1000000000,
+  "hidden_size": 10,
+  "num_layers": 12,
+}
+'''
+MODEL_INFO = "model_info"
+MODEL_INFO_PROFILE = "profile"
+MODEL_INFO_PROFILE_DEFAULT = False
+MODEL_INFO_NUM_PARAMS = "num_params"
+MODEL_INFO_NUM_PARAMS_DEFAULT = None
+MODEL_INFO_HIDDEN_SIZE = "hidden_size"
+MODEL_INFO_HIDDEN_SIZE_DEFAULT = None
+MODEL_INFO_NUM_LAYERS = "num_layers"
+MODEL_INFO_NUM_LAYERS_DEFAULT = None
+
+MODEL_INFO_KEY_DEFAULT_DICT = {
+    MODEL_INFO_PROFILE: MODEL_INFO_PROFILE_DEFAULT,
+    MODEL_INFO_NUM_PARAMS: MODEL_INFO_NUM_PARAMS_DEFAULT,
+    MODEL_INFO_HIDDEN_SIZE: MODEL_INFO_HIDDEN_SIZE_DEFAULT,
+    MODEL_INFO_NUM_LAYERS: MODEL_INFO_NUM_LAYERS_DEFAULT
+}
+
+#########################################
+# autotuner search space constants
+#########################################
+
+DEFAULT_HF_CONFIG = {
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "gradient_accumulation_steps": "auto",
+}
+
+DEFAULT_MIN_MEM_CONFIG = {
+    "train_micro_batch_size_per_gpu": 1,
+    "zero_optimization": {
+        "stage": 3
+    },
+    "memory_break_down": False
+}
+
+DEFAULT_TUNING_SPACE_ZERO_0 = {"zero_optimization": {"stage": 0}}
+
+DEFAULT_TUNING_SPACE_ZERO_1 = {
+    "zero_optimization": {
+        "stage": 1,
+        "reduce_bucket_size": [5e7, 5e8, 1e9],
+        "allgather_bucket_size": [5e7, 5e8, 1e9],
+    }
+}
+
+DEFAULT_TUNING_SPACE_ZERO_2 = {
+    "zero_optimization": {
+        "stage": 2,
+        "overlap_comm": [True, False],
+        "reduce_scatter": [False, True],
+        "reduce_bucket_size": [5e7, 5e8, 1e9],
+        "allgather_bucket_size": [5e7, 5e8, 1e9],
+        "contiguous_gradients": [False, True]
+    },
+}
+
+DEFAULT_TUNING_SPACE_ZERO_3 = {
+    "zero_optimization": {
+        "stage": 3,
+        "overlap_comm": [True, False],
+        "reduce_scatter": [False, True],
+        "reduce_bucket_size": [5e7, 5e8, 1e9],
+        "allgather_partitions": [True, False],
+        "allgather_bucket_size": [5e7, 5e8, 1e9],
+        "contiguous_gradients": [False, True]
+    },
+}
+
+GLOBAL_TUNING_SPACE = 'global'
+# TUNING_MICRO_BATCH_SIZE_PREFIX="tune_micro_batch_size_z"
+TUNING_MICRO_BATCH_SIZE_PREFIX = "z"

venv/lib/python3.10/site-packages/deepspeed/autotuning/scheduler.py

@@ -0,0 +1,433 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import copy
+
+from numpy import BUFSIZE
+import json
+import subprocess
+import sys
+import threading
+import time
+import base64
+
+import os
+import hjson
+from tqdm import tqdm
+
+from ..utils import logger
+from .constants import AUTOTUNING, AUTOTUNING_METRIC_PATH
+from .utils import get_val_by_key, search_error, was_interruptted
+"""
+thread-0: loop over experiment queue dispatching experiments if they become available
+thread-N: start each experiment in its own thread
+"""
+
+from deepspeed import comm as dist
+
+TIMEOUT = 5
+
+
+class ResourceManager:
+
+    def __init__(self, args, hosts, num_gpus_per_node, results_dir, exps_dir, arg_mappings):
+        self.results_dir = results_dir
+        self.exps_dir = exps_dir
+
+        self.nodes = []
+        self.num_gpus_per_node = num_gpus_per_node
+        for host in hosts:
+            self.nodes.append(Node(host, num_gpus_per_node))
+
+        self.experiment_queue = []
+        self.running_experiments = {}
+        self.finished_experiments = {}
+        self.experiment_count = 0
+        self.exp_paths = set()
+        self.args = args
+
+        self.arg_mappings = {}
+        if arg_mappings is not None:
+            for k, v in arg_mappings.items():
+                k = k.strip()
+                v = v.strip()
+                if k not in self.arg_mappings:
+                    self.arg_mappings[k] = v
+
+    def schedule_experiments(self, exp_paths):
+        for exp_path in exp_paths:
+            if exp_path in self.exp_paths:
+                continue
+            else:
+                self.exp_paths.add(exp_path)
+                with open(exp_path, "r") as fd:
+                    exp = hjson.load(fd)
+                    exp["exp_id"] = self.experiment_count
+                    self.experiment_count += 1
+
+                    result_dir = exp["result_dir"] = os.path.join(self.results_dir, exp['name'])
+                    if AUTOTUNING in exp["ds_config"]:
+                        metric_file = os.path.join(result_dir, "metrics.json")
+                        exp["ds_config"][AUTOTUNING][AUTOTUNING_METRIC_PATH] = metric_file
+                    stderr_file = os.path.join(result_dir, "stderr.log")
+                    model_info_file = os.path.join(result_dir, "model_info.json")
+                    metric_file = os.path.join(result_dir, "metrics.json")
+
+                    # skip existing experiments (except for the ones that were interrupted)
+                    if os.path.exists(result_dir) and os.path.exists(stderr_file):
+                        if not was_interruptted(stderr_file):
+                            err = search_error(stderr_file)
+                            exp_id = exp["exp_id"]
+                            self.finished_experiments[exp_id] = (exp, err)
+                            if err or os.path.exists(metric_file) or os.path.exists(model_info_file):
+                                logger.info(f"Skipping exp {exp['name']} whose result already exists")
+                                continue
+
+                    self.experiment_queue.append(exp)
+
+    def run_job(self, exp: dict, reservations):
+        exp_id = exp["exp_id"]
+        exp["master_port"] = self.args.master_port + exp_id
+        exp["result_dir"] = os.path.join(self.results_dir, exp['name'])
+        user_script = self.args.user_script
+        user_args = self.args.user_args
+
+        # overwrite the user arg in the arg_mappings
+        for key, val in self.arg_mappings.items():
+            nval = get_val_by_key(exp, key)
+            if nval and str(nval) != "auto":
+                if val in user_args:
+                    idx = user_args.index(val)
+                    user_args[idx + 1] = str(nval)
+                else:
+                    user_args.append(val)
+                    user_args.append(str(nval))
+
+        t = threading.Thread(target=run_experiment, args=(exp, reservations, user_script, user_args))
+        t.start()
+        self.running_experiments[exp_id] = (t, exp, reservations, time.time())
+
+    def experiment_check(self, pbar):
+        finished_exps = []
+        for exp_id, exp_data in self.running_experiments.items():
+            thread, exp_json, reservations, start_time = exp_data
+            logger.debug(f"Checking exp_id = {exp_id}, alive = {thread.is_alive()}")
+            thread.join(timeout=TIMEOUT)
+            if not thread.is_alive():
+                exp_dir = exp_json["result_dir"]
+                stderr_file = os.path.join(exp_dir, "stderr.log")
+                err = search_error(stderr_file)
+                finished_exps.append((exp_id, reservations))
+                self.finished_experiments[exp_id] = (exp_json, err)
+                duration = time.time() - start_time
+                logger.debug(f"Finished exp_id = {exp_id}, duration={duration:.2f} sec")
+                pbar.update(len(finished_exps))
+        for exp_id, reservations in finished_exps:
+            for reservation in reservations:
+                reservation.restore_slots()
+            self.running_experiments.pop(exp_id)
+        time.sleep(TIMEOUT)
+
+    def resource_request(self, exp):
+        num_gpus, num_nodes = exp['num_gpus'], exp['num_nodes']
+        slot_request = num_gpus
+        reservations = []
+        for node in self.nodes:
+            if num_nodes == 0:
+                break
+            slots = node.reserve_slots(slot_request=slot_request)
+            if slots:
+                reservations.append(Reservation(node=node, slots=slots))
+                num_nodes -= 1
+
+        if num_nodes == 0:
+            # request satisfied
+            return reservations
+        else:
+            # request not satisfied
+            for reservation in reservations:
+                reservation.restore_slots()
+
+    def status(self):
+        status = ""
+        for node in self.nodes:
+            status += f"{node.host} ({len(node.idle_slots)} idle gpus), "
+        return status[:-1]
+
+    def run(self):
+        pbar = tqdm(total=len(self.experiment_queue))
+
+        while len(self.experiment_queue) > 0:
+            exp = self.experiment_queue.pop(0)
+            logger.debug(f'Popped exp_id = {exp["exp_id"]} from the queue')
+            logger.debug(f'Resource status: {self.status()}')
+            reservations = self.resource_request(exp)
+
+            if not reservations:
+                logger.debug(f'Unable to schedule exp_id = {exp["exp_id"]}')
+                self.experiment_queue.insert(0, exp)
+                logger.debug(f'Put exp_id = {exp["exp_id"]} back into the queue')
+                self.experiment_check(pbar)
+            else:
+                desc = ""
+                for reservation in reservations:
+                    reservation.slots.sort()
+                    slots = ",".join(map(str, reservation.slots))
+                    desc += f"{reservation.node.host}:{slots}@"
+                desc = desc[:-1]
+                logger.debug(f'Running exp_id = {exp["exp_id"]} on {desc}')
+                self.run_job(exp, reservations)
+
+        # All pending experiments are scheduled, waiting for them to complete
+        while len(self.running_experiments) > 0:
+            self.experiment_check(pbar)
+
+    def save_exp_results_to_database(self, message, ranks=None, path=None):
+        """Print message when one of following condition meets
+
+        + not dist.is_initialized()
+        + dist.get_rank() in ranks if ranks is not None or ranks = [-1]
+
+    Args:
+            message (str)
+            ranks (list)
+            path (str)
+
+        """
+        should_log = not dist.is_initialized()
+        ranks = ranks or []
+        my_rank = dist.get_rank() if dist.is_initialized() else -1
+        if ranks and not should_log:
+            should_log = ranks[0] == -1
+            should_log = should_log or (my_rank in set(ranks))
+        logger.debug(f"*** Should log: {should_log}")
+        if should_log:
+            message['rank'] = my_rank
+            with open(path, 'a') as outfile:
+                json.dump(message, outfile)
+                outfile.write('\n')
+
+    def parse_results(self, metric):
+        """ Parses the metric file of the finished experiments to select the optimal DeepSpeed configuration.
+
+        Args:
+            finished_experiments (dcit): a dictionary of experiment id and experiment description.
+
+        Returns:
+            The path to the result folder of the experiment with the optimal configuration.
+        """
+        max_throughput = sys.float_info.min
+        best_exp_id = -1
+        for exp_id, (exp, err) in self.finished_experiments.items():
+            if err:
+                logger.info(
+                    f"The experiment exp_id = {exp_id}, exp_name = {exp['name']}, did not run successfully with error = {err}, thus a metrics.txt does not exist for it. Check the stderr.log in {exp['result_dir']}"
+                )
+                continue
+
+            metric_file = exp["ds_config"][AUTOTUNING][AUTOTUNING_METRIC_PATH]
+
+            if os.path.exists(metric_file):
+                with open(metric_file, 'r') as f:
+                    results = hjson.load(f)
+                    curr_throughput = results[metric]
+                    if curr_throughput > max_throughput:
+                        max_throughput = curr_throughput
+                        best_exp_id = exp_id
+                    exp['results'] = results
+
+        if best_exp_id != -1:
+            best_exp, _ = self.finished_experiments[best_exp_id]
+            return best_exp, max_throughput
+
+        return exp, None
+
+    def clear(self):
+        """Clear experiment queues, does not reset self.experiment_count
+        """
+        self.experiment_queue = []
+        # clean up the running experiments
+        for exp_id, exp_data in self.running_experiments.items():
+            thread, exp_json, reservations, start_time = exp_data
+            clean_up(exp_json, reservations)
+        self.running_experiments = {}
+        self.finished_experiments = {}
+        self.exp_paths = set()
+
+
+class Node:
+
+    def __init__(self, host, max_slots):
+        self.host = host
+        self.max_slots = max_slots
+        self.idle_slots = list(range(max_slots))
+
+    def reserve_slots(self, slot_request: int) -> list:
+        if len(self.idle_slots) >= slot_request:
+            return [self.idle_slots.pop(0) for _ in range(slot_request)]
+
+    def restore_slots(self, slots: list):
+        self.idle_slots += slots
+
+
+class Reservation:
+
+    def __init__(self, node, slots):
+        self.node = node
+        self.slots = slots
+
+    def restore_slots(self):
+        self.node.restore_slots(self.slots)
+
+    def desc(self):
+        slots = ",".join(map(str, self.slots))
+        return f"{self.node.host}:{slots}@"
+
+
+def get_job_id():
+    # Infrastructure-specific job-id
+    infra_job_id = None
+    if "DLWS_JOB_ID" in os.environ:
+        infra_job_id = os.environ["DLWS_JOB_ID"]
+    elif "DLTS_JOB_ID" in os.environ:
+        infra_job_id = os.environ["DLTS_JOB_ID"]
+    else:
+        infra_job_id = "unknown-job-id"
+
+    return infra_job_id
+
+
+def get_user():
+    user = None
+    if "USER" in os.environ:
+        user = os.environ["USER"]
+    else:
+        user = "unknown-user"
+    return user
+
+
+def run_experiment(exp: dict, reservations, user_script, user_args):
+    include_str = ""
+    for reservation in reservations:
+        reservation.slots.sort()
+        slots = ",".join(map(str, reservation.slots))
+        include_str += f"{reservation.node.host}:{slots}@"
+    include_str = include_str[:-1]
+    master_port = exp["master_port"]
+    hostfile = exp["hostfile"]
+    exp["launcher_args"] = [
+        "--hostfile",
+        f"{hostfile}",
+        "--include",
+        f"{include_str}",
+        "--master_port",
+        str(master_port),
+    ]
+    logger.debug(f'launcher args={exp["launcher_args"]}')
+
+    exp["user"] = get_user()
+    exp["job_id"] = get_job_id()
+    exp_dir = exp["result_dir"]
+    os.makedirs(exp_dir, exist_ok=True)
+    ds_config_path = os.path.join(exp_dir, "ds_config.json")
+    exp["ds_config_path"] = ds_config_path
+
+    ds_config = copy.deepcopy(exp["ds_config"])
+    ds_config_json = json.dumps(ds_config).encode('utf-8')
+
+    exp["ds_config_base64"] = base64.urlsafe_b64encode(ds_config_json).decode('utf-8')
+
+    with open(exp["ds_config_path"], "w", buffering=BUFSIZE) as fd:
+        json.dump(ds_config, fd)
+        fd.flush()
+        os.fsync(fd)
+        path = exp["ds_config_path"]
+        logger.info(f"Scheduler wrote ds_config to {path}, {os.path.abspath(path)}")
+
+    with open(os.path.join(exp_dir, "exp.json"), "w", buffering=BUFSIZE) as fd:
+        json.dump(exp, fd)
+        fd.flush()
+        os.fsync(fd)
+        path = os.path.join(exp_dir, "exp.json")
+        logger.info(f"Scheduler wrote exp to {path}, {os.path.abspath(path)}")
+
+    # remove "--deepspeed_config ds_config.json" from user_args
+    if user_args:
+        if "--deepspeed_config" in user_args:
+            idx = user_args.index("--deepspeed_config")
+        # "--deepspeed_config" is omitted in HF
+        elif "--deepspeed" in user_args:
+            idx = user_args.index("--deepspeed")
+        assert idx < len(user_args), "there is no ds_config file specified after --deepspeed_config or --deepspeed"
+        # user_args[idx + 1] = exp["ds_config_path"]
+        # pass base64 serialized ds_config to launcher
+        user_args[idx + 1] = exp["ds_config_base64"]
+
+    exp["user_script"] = user_script
+    exp["user_args"] = user_args
+
+    cmd = ["deepspeed"] + exp["launcher_args"] + [user_script] + user_args
+
+    assert len(exp["launcher_args"]) > 0, "must provide launcher args"
+
+    with open(os.path.join(exp_dir, "cmd.txt"), "w", buffering=BUFSIZE) as fd:
+        fd.write(" ".join(cmd))
+        fd.write("\n")
+        fd.flush()
+        os.fsync(fd)
+
+    logger.info(
+        f"Launching exp_id = {exp['exp_id']}, exp_name = {exp['name']}, with resource = {include_str}, and ds_config = {os.path.abspath(ds_config_path)}"
+    )
+
+    with open(os.path.join(exp_dir, "stdout.log"), "wb") as out, open(os.path.join(exp_dir, "stderr.log"),
+                                                                      "wb") as err:
+        result = subprocess.Popen(cmd, stdout=out, stderr=err)
+        result.wait()
+        out.flush()
+        err.flush()
+        os.fsync(out)
+        os.fsync(err)
+
+    clean_up(exp, reservations)
+
+    logger.info(f"Done running exp_id = {exp['exp_id']}, exp_name = {exp['name']}, with resource = {include_str}")
+
+
+PDSH_MAX_FAN_OUT = 1024
+
+
+def clean_up(exp: dict, reservations):
+    env = os.environ.copy()
+    env['PDSH_RCMD_TYPE'] = 'ssh'
+
+    nodes_str = ""
+    for reservation in reservations:
+        nodes_str += f"{reservation.node.host},"
+    nodes_str = nodes_str[:-1]
+    logger.debug(f"Cleaning up exp_id = {exp['exp_id']} on the following workers: {nodes_str}")
+
+    # PDSH flags for max node fan out and specific hosts to launch on
+    # See https://linux.die.net/man/1/pdsh for flag details
+    pdsh_cmd = ['pdsh', '-f', str(PDSH_MAX_FAN_OUT), '-w', nodes_str]
+
+    kill_cmd = [
+        'pkill',
+        '-f',
+        exp['name'],
+    ]
+    cmd = pdsh_cmd + kill_cmd
+    logger.debug("cmd = {}".format(' '.join(cmd)))
+
+    result = subprocess.Popen(cmd, env=env)
+    result.wait()
+
+    # In case of failure must propagate the error-condition back to the caller (usually shell). The
+    # actual error and traceback should have been printed in the subprocess, so in order to avoid
+    # unnecessary noise we just quietly exit here with the same code as the subprocess
+    if result.returncode > 0:
+        sys.exit(result.returncode)
+
+    logger.info(f"Done cleaning up exp_id = {exp['exp_id']} on the following workers: {nodes_str}")

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

@@ -0,0 +1,8 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .index_based_tuner import RandomTuner, GridSearchTuner
+# from .ga_tuner import GATuner
+from .model_based_tuner import ModelBasedTuner

venv/lib/python3.10/site-packages/deepspeed/autotuning/tuner/base_tuner.py

@@ -0,0 +1,72 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import sys
+
+from deepspeed.autotuning.constants import *
+from deepspeed.autotuning.utils import write_experiments
+from deepspeed.utils import logger
+
+
+class BaseTuner:
+
+    def __init__(self, exps, resource_manager, metric):
+        self.all_exps = exps
+        self.rm = resource_manager
+        self.best_iter = 0
+        self.best_exp = None
+        self.best_metric_val = None
+        self.metric = metric if metric else AUTOTUNING_METRIC_DEFAULT
+        logger.info(f"total number of exps =  {len(self.all_exps)}")
+
+    def has_next(self):
+        """Whether there exists more configurations for evaluation"""
+        if len(self.all_exps) > 0:
+            return True
+        else:
+            return False
+
+    def next_batch(self, sample_size):
+        """Select the next batch of configurations for evaluation"""
+        raise NotImplementedError
+
+    def update(self):
+        """"Update the tuner with what configurations have been evaluated and their performance results"""
+
+    def tune(self, sample_size=1, n_trials=1000, early_stopping=None):
+        i = 0
+        try:
+            while i < n_trials and self.has_next():
+                # Select the next batch of configuration for evaluation
+                sampled_exps = self.next_batch(sample_size)
+                # Generate experiments for measurement of performance
+                exp_paths = write_experiments(sampled_exps, self.rm.exps_dir)
+                self.rm.schedule_experiments(exp_paths)
+                self.rm.run()
+                exp, metric_val = self.rm.parse_results(self.metric)
+                if self.best_exp is None or self.best_metric_val is None or (metric_val
+                                                                             and metric_val > self.best_metric_val):
+                    # logger.info(f"tuner finds better = {exp}")
+                    self.best_exp = exp
+                    self.best_metric_val = metric_val
+                    self.best_iter = i
+
+                i += len(sampled_exps)
+
+                # Update the tuner with evaluated performance results
+                self.update()
+
+                self.rm.clear()
+
+                # Early stop if no more promising configurations are likely to be found
+                if early_stopping and i >= self.best_iter + early_stopping:
+                    logger.info(
+                        f"Tuner early stopped at iteration {i}. Best iteration is {self.best_iter}. Early stopping threshold is {early_stopping}"
+                    )
+                    break
+            return i
+        except:
+            logger.info("Tuner Error:", sys.exc_info()[0])
+            return i

venv/lib/python3.10/site-packages/deepspeed/autotuning/tuner/cost_model.py

@@ -0,0 +1,66 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .utils import *
+
+try:
+    import xgboost as xgb
+except ImportError:
+    xgb = None
+
+
+class XGBoostCostModel():
+
+    def __init__(self, loss_type, num_threads=None, log_interval=25, upper_model=None):
+
+        assert xgb is not None, "missing requirements, please install deepspeed w. 'autotuning_ml' extra."
+
+        self.loss_type = loss_type
+
+        if loss_type == "reg":
+            self.xgb_params = {
+                "max_depth": 3,
+                "gamma": 0.0001,
+                "min_child_weight": 1,
+                "subsample": 1.0,
+                "eta": 0.3,
+                "lambda": 1.0,
+                "alpha": 0,
+                "objective": "reg:linear",
+            }
+        elif loss_type == "rank":
+            self.xgb_params = {
+                "max_depth": 3,
+                "gamma": 0.0001,
+                "min_child_weight": 1,
+                "subsample": 1.0,
+                "eta": 0.3,
+                "lambda": 1.0,
+                "alpha": 0,
+                "objective": "rank:pairwise",
+            }
+        else:
+            raise RuntimeError("Invalid loss type: " + loss_type)
+
+        self.xgb_params["verbosity"] = 0
+        if num_threads:
+            self.xgb_params["nthread"] = num_threads
+
+    def fit(self, xs, ys):
+        x_train = np.array(xs, dtype=np.float32)
+        y_train = np.array(ys, dtype=np.float32)
+        y_max = np.max(y_train)
+        y_train = y_train / max(y_max, 1e-9)
+
+        index = np.random.permutation(len(x_train))
+        dtrain = xgb.DMatrix(x_train[index], y_train[index])
+
+        self.bst = xgb.train(self.xgb_params, dtrain)
+
+    def predict(self, xs):
+
+        features = xgb.DMatrix(xs)
+
+        return self.bst.predict(features)

venv/lib/python3.10/site-packages/deepspeed/autotuning/tuner/index_based_tuner.py

@@ -0,0 +1,40 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import random
+
+from .base_tuner import BaseTuner
+
+
+class RandomTuner(BaseTuner):
+    """Explore the search space in random order"""
+
+    def __init__(self, exps: list, resource_manager, metric):
+        super().__init__(exps, resource_manager, metric)
+
+    def next_batch(self, sample_size=1):
+        if sample_size > len(self.all_exps):
+            sample_size = len(self.all_exps)
+
+        sampled_batch = random.sample(self.all_exps, sample_size)
+        self.all_exps = [x for x in self.all_exps if x not in sampled_batch]
+
+        return sampled_batch
+
+
+class GridSearchTuner(BaseTuner):
+    """Explore the search space in sequential order"""
+
+    def __init__(self, exps: list, resource_manager, metric):
+        super().__init__(exps, resource_manager, metric)
+
+    def next_batch(self, sample_size=1):
+        if sample_size > len(self.all_exps):
+            sample_size = len(self.all_exps)
+
+        sampled_batch = self.all_exps[0:sample_size]
+        self.all_exps = [x for x in self.all_exps if x not in sampled_batch]
+
+        return sampled_batch

venv/lib/python3.10/site-packages/deepspeed/autotuning/tuner/model_based_tuner.py

@@ -0,0 +1,157 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import hjson
+
+from ..constants import AUTOTUNING, AUTOTUNING_METRIC_PATH
+from .base_tuner import BaseTuner
+from .cost_model import XGBoostCostModel
+from .utils import *
+from ..utils import *
+import numbers
+from ..constants import AUTOTUNING_METRIC_LATENCY
+
+INIT_NUM = 2
+
+
+class ModelBasedTuner(BaseTuner):
+    """Exploring the search space with a cost model"""
+
+    def __init__(self, exps: list, resource_manager, metric, tuning_space):
+        super().__init__(exps, resource_manager, metric)
+        self.tuning_space = tuning_space
+        self.best_iter = 0
+
+        self.all_configs = [e['ds_config'] for e in exps]
+        self.num_all_configs = len(self.all_configs)
+
+        self.dims = dict_to_dims(self.tuning_space)
+
+        logger.info(f"Create config dim: {self.dims}, all configs: {self.num_all_configs}")
+
+        self.visited = set([])
+
+        self.trials = []
+        self.trial_pt = 0
+
+        init_num = min(INIT_NUM, self.num_all_configs)
+
+        for _ in range(init_num):
+            exp_feature = np.random.randint(self.num_all_configs)
+            exp_feature = 0
+            while exp_feature in self.visited:
+                exp_feature = np.random.randint(self.num_all_configs)
+            self.trials.append(exp_feature)
+            self.visited.add(exp_feature)
+
+        self.cost_model = XGBoostCostModel("rank")
+
+        self.evaluated_configs = []
+        self.evaluated_perf = []
+
+        self.train_ct = 0
+
+        self.random_exploration_ratio = 0.2  # do random exploration
+
+    def find_estimated_top_configs(self):
+        """Use the cost model to predict the estimated performance of configurations and find the top ones for the next round of evaluation"""
+
+        configs = []
+
+        for c in self.all_configs:
+            flattened_ds_config = flatten(c)
+            feature_val = []
+            for k, v in flattened_ds_config.items():
+                if isinstance(v, numbers.Number):
+                    feature_val.append(v)
+            configs.append(feature_val)
+        # print(configs)
+        # TODO the current implementation requires that all configs have the same shape.
+        configs = np.array(configs, dtype=np.float32)
+        estimates = self.cost_model.predict(configs)
+
+        n = len(estimates)
+        top_idx = np.argsort(estimates)
+        top_idx_ret = top_idx if self.metric == AUTOTUNING_METRIC_LATENCY else top_idx[::-1][:n]
+
+        # top_configs = [self.all_configs[i] for i in top_idx]
+
+        return top_idx_ret
+
+    def next_batch(self, sample_size):
+        sampled_batch = []
+
+        counter = 0
+        while counter < sample_size:
+
+            if len(self.visited) >= self.num_all_configs:
+                break
+
+            while self.trial_pt < len(self.trials):
+                logger.debug(f"trials: {self.trials}")
+                # Select top promising trials
+                index = self.trials[self.trial_pt]
+                if index not in self.visited:
+                    break
+                self.trial_pt += 1
+
+            # To avoid over-exploitation, randomly select one that has not been explored.
+            rand = np.random.rand()
+            if rand < self.random_exploration_ratio:
+                # Do normal selection
+                feature = np.random.choice(self.trials)
+                while index in self.visited:
+                    index = np.random.randint(self.num_all_configs)
+
+            # Need to track both the sampled configs and indices
+
+            sampled_batch.append(self.all_exps[index])
+            self.visited.add(index)
+            counter += 1
+
+        return sampled_batch
+
+    def has_next(self):
+        return len(self.visited) < self.num_all_configs
+
+    def update(self):
+        for exp_id, (exp, err) in self.rm.finished_experiments.items():
+            feature_val = []
+            if err:
+                logger.info(
+                    f"Skipping exp_id = {exp_id}, exp_name = {exp['name']}, the experiment did not run successfully with error = {err}, thus a metrics.txt does not exist for it. Please check the stderr.log in {exp['result_dir']}"
+                )
+                ds_config = exp["ds_config"]
+                flattened_ds_config = flatten(ds_config)
+                for k, v in flattened_ds_config.items():
+                    if isinstance(v, numbers.Number):
+                        feature_val.append(v)
+                self.evaluated_configs.append(feature_val)
+                self.evaluated_perf.append(0.0)
+                continue
+
+            p = exp["ds_config"][AUTOTUNING][AUTOTUNING_METRIC_PATH]
+            with open(p, 'r') as f:
+                results = hjson.load(f)
+                curr_iter = results[self.metric]
+                logger.debug(f"parsing the results for {exp_id}， Result is {curr_iter}")
+
+                ds_config = exp["ds_config"]
+                flattened_ds_config = flatten(ds_config)
+                for k, v in flattened_ds_config.items():
+                    if isinstance(v, numbers.Number):
+                        feature_val.append(v)
+                self.evaluated_configs.append(feature_val)
+                self.evaluated_perf.append(curr_iter)
+
+        logger.debug(f"**Evaluated configs: {len(self.evaluated_configs)}, evaluated perf: {self.evaluated_perf}")
+
+        self.cost_model.fit(self.evaluated_configs, self.evaluated_perf)
+
+        estimated_top_configs = self.find_estimated_top_configs()
+
+        self.trials = estimated_top_configs
+        self.trial_pt = 0
+        self.train_ct += 1

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

@@ -0,0 +1,86 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import numpy as np
+import itertools
+from ..utils import *
+import collections.abc
+
+
+def index_to_feature(p, dims):
+    """convert index form (single integer) to feature form (vector)"""
+    feature = []
+    for dim in dims:
+        feature.append(p % dim)
+        p //= dim
+    return feature
+
+
+def feature_to_index(feature, dims):
+    """convert feature form (vector) to index form (single integer)"""
+    p = 0
+    for j, k in enumerate(feature):
+        print("j:", "k:", k, "dims", dims[:j])
+        p += int(np.prod(dims[:j])) * k
+    return p
+
+
+def dict_to_dims(tuning_space):
+
+    dims = []
+
+    for key, val in tuning_space.items():
+        if isinstance(val, dict):
+            dims.extend(dict_to_dims(val))
+        elif isinstance(val, list):
+            dims.append(len(val))
+        else:
+            dims.append(1)
+
+    return dims
+
+
+def gen_combinations(d: dict):
+    keys, values = d.keys(), d.values()
+    for v in values:
+        if not isinstance(v, list):
+            v = [v]
+    values_choices = (gen_combinations(v) if isinstance(v, dict) else get_list(v) for v in values)
+    for comb in itertools.product(*values_choices):
+        yield dict(zip(keys, comb))
+
+
+def flatten(d, parent_key='', sep='_'):
+    items = []
+    for k, v in d.items():
+        new_key = parent_key + sep + k if parent_key else k
+        if isinstance(v, collections.abc.MutableMapping):
+            items.extend(flatten(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+
+def dict_to_feature(feature_dict, keys, max_value=None):
+    """Extract values from dict"""
+    feature = []
+    for key, val in feature_dict.items():  # First level
+        if key not in keys:
+            continue
+        if val is None or val == "auto" or key == "autotuning" or val == "":
+            continue
+        if isinstance(val, dict):
+            feature.append(dict_to_feature(val, max_value))
+        else:
+            feature.append(float(val))
+
+    # normalization, should not matter in tree models
+    if max_value is not None:
+        norm_feature = []
+        for f, mv in zip(feature, max_value):
+            norm_feature.append(f / mv)
+        feature = norm_feature
+
+    return feature

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

@@ -0,0 +1,459 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import re
+import collections.abc
+import os
+import json
+from deepspeed.runtime.constants import GRADIENT_ACCUMULATION_STEPS, TRAIN_MICRO_BATCH_SIZE_PER_GPU
+import itertools
+import copy
+
+from ..utils import logger
+
+
+def search_error(filename):
+    if not os.path.exists(filename):
+        return "stderr.log does not exist"
+    with open(filename) as f:
+        for line in f:
+            for s in ["Error", "error", "ERROR"]:
+                idx = line.find(s)
+                if idx != -1:
+                    return line[idx + len(s):].lstrip(": ")
+    return None
+
+
+def was_interruptted(filename):
+    if not os.path.exists(filename):
+        return "stderr.log does not exist"
+    with open(filename) as f:
+        for line in f:
+            s = "KeyboardInterrupt"
+            idx = line.find(s)
+            if idx != -1:
+                return True
+    return False
+
+
+def find_replace_str(value, replace_dict):
+    if not isinstance(value, str):
+        return str(value)
+
+    matches = re.findall(r"\$[\w]+", value)
+    for var in matches:
+        var_key = var.replace("$", "").lower()
+        if var_key == "nvme_path":
+            continue
+        assert var_key in replace_dict, f"unknown var key: {var_key}, in {replace_dict}"
+        if isinstance(replace_dict[var_key], str):
+            value = value.replace(var, replace_dict[var_key])
+        else:
+            assert len(matches) == 1, "unable to replace multiple non-string matches"
+            value = replace_dict[var_key]
+    return value
+
+
+def find_replace(target, replace_dict):
+    if isinstance(target, dict):
+        for key, value in target.items():
+            if isinstance(value, str):
+                target[key] = find_replace_str(value, replace_dict)
+            if isinstance(value, list):
+                for i in range(len(value)):
+                    value[i] = find_replace_str(value[i], replace_dict)
+            if isinstance(value, dict):
+                find_replace(value, replace_dict)
+    elif isinstance(target, list):
+        for i in range(len(target)):
+            target[i] = str(find_replace_str(target[i], replace_dict))
+
+
+def get_list(val):
+    if not isinstance(val, list):
+        return [val]
+    else:
+        return val
+
+
+def combine_dict(d, u):
+    for k, v in u.items():
+        if isinstance(v, collections.abc.Mapping):
+            d[k] = combine_dict(d.get(k, {}), v)
+        else:
+            if k not in d:
+                d[k] = v
+            else:
+                if not isinstance(d[k], list):
+                    d[k] = [d[k]]
+                d[k].extend(i for i in get_list(v) if i not in d[k])
+    return d
+
+
+def del_if_exists(t, d):
+    """Deletes a key from a dictionary if it exists.
+
+    Args:
+        t (string): target key to delete
+        d (dict): dictionary to delete from
+    """
+    if t in d:
+        del d[t]
+        return
+    for k, v in d.items():
+        if isinstance(v, collections.abc.Mapping):
+            del_if_exists(t, v)
+
+
+def replace_dict(d, u, ignored_keys=[]):
+    """Replaces values in dict d with values in dict u.
+
+    Args:
+        d (dict): the target dict to overwrite
+        u (dict): the dict containing the values to overwrite the target dict
+
+    Returns:
+        dict d with values overwritten by the corresponding ones in dict u.
+    """
+    if u is not None:
+        for k, v in u.items():
+            if k not in ignored_keys:
+                if v is None:
+                    del_if_exists(k, d)
+                    continue
+                if isinstance(v, collections.abc.Mapping):
+                    d[k] = replace_dict(d.get(k, {}), v, ignored_keys)
+                else:
+                    d[k] = v
+    return d
+
+
+def get_val_by_key(d: dict, k):
+    if k in d:
+        return d[k]
+    for v in d.values():
+        if isinstance(v, dict):
+            return get_val_by_key(v, k)
+    return None
+
+
+def set_val_by_key(d: dict, k, vv):
+    if k in d:
+        d[k] = vv
+    for v in d.values():
+        if isinstance(v, dict):
+            set_val_by_key(v, k, vv)
+
+
+def fetch_hostfile(hostfile_path):
+    if not os.path.isfile(hostfile_path):
+        logger.warning("Unable to find hostfile, will proceed with training "
+                       "with local resources only.")
+        return None
+
+    # e.g., worker-0 slots=16
+    with open(hostfile_path, 'r') as fd:
+        resource_pool = collections.OrderedDict()
+        for line in fd.readlines():
+            line = line.strip()
+            if line == '':
+                # skip empty lines
+                continue
+            try:
+                hostname, slots = line.split()
+                _, slot_count = slots.split("=")
+                slot_count = int(slot_count)
+            except ValueError as err:
+                logger.error("Hostfile is not formatted correctly, unable to "
+                             "proceed with training.")
+                raise err
+            if hostname in resource_pool:
+                logger.error("Hostfile contains duplicate hosts, unable to "
+                             "proceed with training.")
+                raise ValueError("host {} is already defined".format(hostname))
+            resource_pool[hostname] = slot_count
+
+    return resource_pool
+
+
+def validate_ds_config(config: dict):
+
+    def is_False(config: dict, key):
+        if config is None:
+            return False
+        return bool(config.get(key))
+
+    config_zero = config.get("zero_optimization", {})
+    if not config_zero:
+        return True
+    stage = config_zero.get("stage")
+    offload = False
+    if stage == 1:
+        return True
+    elif stage == 2:
+        if is_False(config_zero, "cpu_offload") and is_False(config_zero, "cpu_offload_params"):
+            return False
+    elif stage == 3:
+        offload_devices = ["cpu", "nvme"]
+        if config_zero.get("offload_optimizer", {}).get("device") in offload_devices:
+            offload = True
+        if config_zero.get("offload_param", {}).get("device") in offload_devices:
+            offload = True
+    else:
+        return True
+
+    # HF requires that "ZeRO Offload can only work with DeepSpeed optimizers"
+    if offload and not config.get("optimizer"):
+        return False
+
+    return True
+
+
+def remove_dupe_dicts(l):
+    """ Removes duplicate dictionaries from a list. Uses list comprehension and the json library to sort and stringify each dictionary and the set data type to ensure unique values. Works with nested data structures.
+
+    Args:
+        l (list): a list of (nested) data structures.
+
+    Returns:
+        A list of unique values.
+    """
+    list_of_strings = [json.dumps(d, sort_keys=True) for d in l]
+    list_of_strings = set(list_of_strings)
+    return [json.loads(s) for s in list_of_strings]
+
+
+def prune_config(config, ignored_keys=[]):
+    """ Prunes the input configurations
+
+    Args:
+        configs (dict): A configuration dictionary.
+        ignored_keys (list, optional): the keys of the sections to delete. Defaults to [].
+
+    Returns:
+        A configuration dictionary.
+    """
+    if ignored_keys:
+        for k in ignored_keys:
+
+            def find_del_key(d: dict, k: str):
+                if k in d:
+                    del d[k]
+                else:
+                    for dd in d.values():
+                        if isinstance(dd, dict):
+                            find_del_key(dd, k)
+
+            find_del_key(config, k)
+
+
+def prune_configs(configs, ignored_keys=[]):
+    """ Prunes the input list of configurations
+
+    Args:
+        configs (list): A list of configuration dictionaries.
+        ignored_keys (list, optional): the keys of the sections to delete. Defaults to [].
+
+    Returns:
+        A list of valid and unique configuration dictionaries.
+    """
+    pruned_list = []
+    for config in configs:
+        prune_config(config, ignored_keys)
+        pruned_list.append(config)
+
+    return remove_dupe_dicts(pruned_list)
+
+
+def get_tuning_keys(tuning_space: dict):
+    """Outputs the list of tunable parameters in the tuning space dict.
+
+    Args:
+        tuning_space (dict): a configuration dictionary containing tunable parameters as lists of values.
+
+    Returns:
+        A list of strings
+    """
+    tuning_keys = []
+    for key, val in tuning_space.items():
+        if isinstance(val, dict):
+            tuning_keys.extend(get_tuning_keys(val))
+        if isinstance(val, list) and len(val) > 1:
+            tuning_keys.append(key)
+    return tuning_keys
+
+
+def get_all_configs(tuning_space: dict, ignore_keys=None):
+    """ Splits the tuning space dictionary to result in all combinations of values.
+
+    Args:
+        tuning_space (dict): the tuning space where tunable parameters are lists of values.
+    """
+
+    def gen_combinations(d: dict):
+        keys, values = d.keys(), d.values()
+        for v in values:
+            if not isinstance(v, list):
+                v = [v]
+        values_choices = (gen_combinations(v) if isinstance(v, dict) else get_list(v) for v in values)
+        for comb in itertools.product(*values_choices):
+            yield dict(zip(keys, comb))
+
+    all_configs = []
+    ignored_key_vals = {}
+    for ik in ignore_keys:
+        ignored_key_vals[ik] = tuning_space.get(ik, {})
+        del_if_exists(ik, tuning_space)
+    for c in gen_combinations(tuning_space):
+        replace_dict(c, ignored_key_vals)
+        all_configs.append(c)
+    return all_configs
+
+
+def canonical_name(config: dict, tuning_keys=None, prefix="", omit_val=False):
+    """ Generates a name from the acronyms of the tuning keys in the config dict. TRAIN_MICRO_BATCH_SIZE_PER_GPU is always included in the tuning keys.
+    Args:
+        config (dict): the config dict used to generate the name
+        tuning_keys (list, optional):  the tuning keys used to generate the name. Defaults to None.
+        prefix (str, optional): a string added to the beginning of the name. Defaults to None.
+    """
+    if TRAIN_MICRO_BATCH_SIZE_PER_GPU not in tuning_keys:
+        tuning_keys.append(TRAIN_MICRO_BATCH_SIZE_PER_GPU)
+    if GRADIENT_ACCUMULATION_STEPS not in tuning_keys:
+        tuning_keys.append(GRADIENT_ACCUMULATION_STEPS)
+    tuning_keys.sort()
+
+    def get_offload_name(offload_config):
+        cname = ""
+        if offload_config is None:
+            return "None_"
+        for key, val in offload_config.items():
+            key = "".join(map(lambda c: c[0], key.split('_')))
+            if (isinstance(val, int) or isinstance(val, float)) and val > 9000:
+                cname += key + '{:.1e}'.format(val) + "_"
+            else:
+                if isinstance(val, bool):
+                    val = "T" if val else "F"
+                cname += f"{key}{val}_"
+        return cname
+
+    def get_name_by_keys(config: dict, tuning_keys=None, omit_val=False):
+        cname = ""
+        if not tuning_keys or config is None:
+            return cname
+        for key, val in config.items():
+            # skip the arg_mappings section when naming the exp file
+            if key == "arg_mappings":
+                continue
+            if key == "offload_param":
+                cname += "op_"
+                if not omit_val:
+                    cname += get_offload_name(val)
+                continue
+            if key == "offload_optimizer":
+                cname += "oo_"
+                if not omit_val:
+                    cname += get_offload_name(val)
+                continue
+            # recursively call the func to get name for the child dicts
+            if isinstance(val, dict):
+                n = get_name_by_keys(val, tuning_keys, omit_val=omit_val)
+                if n != "":
+                    cname += n + "_"
+            if tuning_keys and key not in tuning_keys:
+                continue
+
+            key_str = "".join(map(lambda c: c[0], key.split('_')))
+
+            if not omit_val:
+                if (isinstance(val, int) or isinstance(val, float)) and val > 9000:
+                    cname += key_str + '{:.1e}'.format(val) + "_"
+                else:
+                    if isinstance(val, bool):
+                        val = "T" if val else "F"
+                    cname += f"{key_str}{val}_"
+            else:
+                cname += key_str + "_"
+
+        return cname[:-1]
+
+    name = get_name_by_keys(config, tuning_keys, omit_val=omit_val)
+
+    return prefix + (name if name != "" else "exp")
+
+
+def get_first_config(config: dict):
+    if not config:
+        return None
+    cfg = copy.deepcopy(config)
+
+    for key, val in cfg.items():
+        if isinstance(val, dict):
+            if key == "optimizer":  # use user defined optimizer which might have lists of values as params
+                cfg[key] = val
+            else:
+                cfg[key] = get_first_config(val)
+        if isinstance(val, list) and len(val) > 0:
+            cfg[key] = val[0]
+    return cfg
+
+
+def write_experiments(exps: list, exps_dir: str):
+    exp_paths = []
+    for exp in exps:
+        exp_name = exp['name']
+        # write the expr config to a json file
+        exp_path = os.path.join(exps_dir, f'{exp_name}.json')
+        with open(exp_path, 'w') as fd:
+
+            json.dump(exp, fd)
+            exp_paths.append(exp_path)
+    return exp_paths
+
+
+def memory_to_string(n, postfix="", units=None, precision=2):
+    if units is None:
+        if n // 10**12 > 0:
+            return str(round(n / 1024**4, precision)) + " T" + postfix
+        if n // 10**9 > 0:
+            return str(round(n / 1024**3, precision)) + " G" + postfix
+        elif n // 10**6 > 0:
+            return str(round(n / 1024**2, precision)) + " M" + postfix
+        elif n // 10**3 > 0:
+            return str(round(n / 1014, precision)) + " K" + postfix
+        else:
+            return str(n) + " "
+    else:
+        if units == "T":
+            return str(round(n / 1024**4, precision)) + " " + units
+        if units == "G" + postfix:
+            return str(round(n / 1024**3, precision)) + " " + units
+        elif units == "M" + postfix:
+            return str(round(n / 1024**2, precision)) + " " + units
+        elif units == "K" + postfix:
+            return str(round(n / 1024, precision)) + " " + units
+        else:
+            return str(n) + " "
+
+
+def number_to_string(n, postfix="", units=None, precision=2):
+    if units is None:
+        if n // 10**9 > 0:
+            return str(round(n / 1000**3, precision)) + " B" + postfix
+        if n // 10**6 > 0:
+            return str(round(n / 1000**2, precision)) + " M" + postfix
+        elif n // 10**3 > 0:
+            return str(round(n / 1000**1, precision)) + " K" + postfix
+        else:
+            return str(n) + " "
+    else:
+        if units == "B" + postfix:
+            return str(round(n / 1000**3, precision)) + " " + units
+        elif units == "M" + postfix:
+            return str(round(n / 1000**2, precision)) + " " + units
+        elif units == "K" + postfix:
+            return str(round(n / 1000**1, precision)) + " " + units
+        else:
+            return str(n) + " "

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

@@ -0,0 +1,15 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from . import adam
+from . import adagrad
+from . import lamb
+from . import lion
+from . import sparse_attention
+from . import transformer
+
+from .transformer import DeepSpeedTransformerLayer, DeepSpeedTransformerConfig
+
+from ..git_version_info import compatible_ops as __compatible_ops__

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

@@ -0,0 +1,6 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from ..op_builder import AsyncIOBuilder