Add files using upload-large-folder tool

.gitattributes

@@ -1537,3 +1537,4 @@ infer_4_47_1/lib/python3.10/site-packages/msgpack/_cmsgpack.cpython-310-x86_64-l
 infer_4_47_1/lib/python3.10/site-packages/torch/bin/protoc filter=lfs diff=lfs merge=lfs -text
 evalkit_tf449/lib/python3.10/site-packages/nvidia/cufft/lib/libcufft.so.11 filter=lfs diff=lfs merge=lfs -text
 infer_4_47_1/lib/python3.10/site-packages/torch/_decomp/__pycache__/decompositions.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/axes3d.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/comm/comm.py

@@ -0,0 +1,771 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""
+    DeepSpeed Communication Package: deepspeed.comm
+    deepspeed.comm
+        -- import and use deepspeed.ops.comm
+        -- use torch.distributed directly if both this package and torch.distributed use the same NCCL version
+        -- use custom collectives
+            -- can either use torch.dist or ds.ops.comm?
+        Note: the old 1-bit compressed allreduce variants that resided in deepspeed.runtime.comm will be moved here as well.
+    deepspeed.comm API
+        -- must be kept fully compatible (same signatures) as torch.dist API to ensure backward/cross-framework compatibility.
+        -- e.g. if a client code used
+            from deepspeed import comm as dist
+            instead of
+            import torch.distributed as dist
+            The code should work without breaking any of the public torch.distributed functionality
+    Future:
+        -- deepspeed groups API should be brought into ds.comm
+"""
+
+import torch
+import os
+
+from ..constants import TORCH_DISTRIBUTED_DEFAULT_PORT, default_pg_timeout
+from .constants import *
+from .reduce_op import *
+from deepspeed.accelerator import get_accelerator
+from deepspeed.comm.ccl import CCLBackend
+
+from deepspeed.utils.comms_logging import CommsLogger
+from deepspeed.utils import timer, get_caller_func
+from deepspeed.comm.torch import TorchBackend
+
+from deepspeed import utils
+from datetime import timedelta
+
+# Current deepspeed.comm backend (cdb) global object for simple access by client code
+cdb = None
+
+# Create global timer for ops
+timers = timer.SynchronizedWallClockTimer()
+timer_summary = {}
+
+comms_logger = CommsLogger()
+
+# Maintain objects of all initialized ds backends and assign them using the API functions in this file
+nccl_backend = None
+mpi_backend = None
+ccl_backend = None
+hccl_backend = None
+
+# This should be set here so all rank/size information from the launcher can be propagated
+from deepspeed.comm.utils import *
+
+
+class ProcessGroup():
+
+    def __init__(self, comm_id, ranks=[]):
+        self.ranks = ranks
+        self.comm_id = comm_id
+        self.size = len(ranks)
+
+
+def _configure_using_config_file(config):
+    if config.comms_logger_enabled:
+        comms_logger.configure(config)
+
+
+def configure(
+    deepspeed_config=None,
+    enabled=None,
+    prof_all=None,
+    prof_ops=None,
+    verbose=None,
+    debug=None,
+):
+
+    if deepspeed_config is not None:
+        _configure_using_config_file(deepspeed_config.comms_config)
+
+    if enabled is not None:
+        comms_logger.enabled = enabled
+
+    if prof_all is not None:
+        comms_logger.prof_all = prof_all
+
+    if prof_ops is not None:
+        comms_logger.prof_ops = prof_ops
+
+    if verbose is not None:
+        comms_logger.verbose = verbose
+
+    if debug is not None:
+        comms_logger.debug = debug
+
+
+# Logging wrapper for timing ops
+def timed_op(func):
+
+    def log_wrapper(*args, **kwargs):
+        # Add enabled flag so that overhead to each comm op is two if conditions at most
+        if comms_logger.enabled:
+            if ('prof' in kwargs
+                    and kwargs['prof']) or comms_logger.prof_all or ('log_name' in kwargs
+                                                                     and kwargs['log_name'] in comms_logger.prof_ops):
+                # Need func args for their defaults
+                func_args = get_default_args(func)
+                func_args.update(kwargs)
+                msg_size = get_msg_size_from_args(func, *args, **kwargs)
+                log_name = get_debug_log_name(func_args, comms_logger.debug)
+                timers(log_name).start()
+        # Return the op, then stop the op's timer
+        try:
+            return func(*args, **kwargs)
+        finally:
+            if comms_logger.enabled:
+                # Need to make op blocking for accurate logging
+                get_accelerator().synchronize()
+                # If we're using MPI, we can't simply sync the stream
+                if cdb.using_mpi:
+                    cdb.barrier()
+                if ('prof' in kwargs and kwargs['prof']) or comms_logger.prof_all or (
+                        'log_name' in kwargs and kwargs['log_name'] in comms_logger.prof_ops):
+                    log_name = get_debug_log_name(func_args, comms_logger.debug)
+                    raw_name = func.__name__
+                    timers(log_name).stop()
+                    # need temp var since 'elapsed' resets events
+                    time_elapsed = timers(log_name).elapsed(reset=False)
+                    comms_logger.append(raw_name, log_name, time_elapsed, msg_size)
+
+    return log_wrapper
+
+
+# For compatibility with torch distributed's init_process_group, we shall retain the signature from PyTorch code.
+# DeepSpeed NCCL/MPI backend may not need all these params as we will have our own implementation.
+# Please read full torch.distributed API docs from https://pytorch.org/docs/stable/distributed.html
+
+
+# UNUSED: Future helper function to initialize DS backends
+def init_deepspeed_backend(ds_backend, timeout, init_method):
+    global cdb
+    global nccl_backend
+    global mpi_backend
+    global ccl_backend
+    global hccl_backend
+
+    rank = int(os.getenv('RANK', '-1'))
+    size = int(os.getenv('WORLD_SIZE', '-1'))
+
+    if ds_backend == NCCL_BACKEND:
+        utils.logger.debug("NCCL backend in DeepSpeed not yet implemented")
+    elif ds_backend == MPI_BACKEND:
+        utils.logger.debug("MPI backend in DeepSpeed not yet implemented")
+    elif ds_backend == GLOO_BACKEND:
+        utils.logger.debug("Gloo backend in DeepSpeed not yet implemented")
+    elif ds_backend == CCL_BACKEND:
+        ccl_backend = CCLBackend(rank=rank, world_size=size, timeout=timeout, init_method=init_method)
+        utils.logger.info(f"Initialize {ds_backend} backend")
+    elif ds_backend == HCCL_BACKEND:
+        utils.logger.warn("HCCL backend in DeepSpeed not yet implemented")
+    else:
+        utils.logger.debug(f"DeepSpeed does not support {ds_backend} backend")
+
+
+def is_initialized():
+    #assert cdb is not None, 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    if cdb is None:
+        return False
+    else:
+        return cdb.is_initialized()
+
+
+def destroy_process_group(group=None):
+    global cdb
+    return cdb.destroy_process_group(group=group)
+
+
+def new_group(ranks):
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    return cdb.new_group(ranks)
+
+
+def is_available() -> bool:
+
+    # Returns ``True`` if the deepspeed comm package is available.
+
+    # TODO: load other ops. Clients including deepspeed itself should use deepspeed.comm to import
+    # any communication related primitives from this package.
+    # use hasattr(deepspeed.csrc.ops, "_comm") or something
+    return True
+
+
+def set_backend():
+    global cdb
+    global nccl_backend
+    global mpi_backend
+    global ccl_backend
+    global hccl_backend
+
+    backend_name = get_accelerator().communication_backend_name()
+
+    if backend_name == NCCL_BACKEND:
+        if nccl_backend is not None and nccl_backend.is_initialized():
+            cdb = nccl_backend
+    elif backend_name == MPI_BACKEND:
+        if mpi_backend is not None and mpi_backend.is_initialized():
+            cdb = mpi_backend
+    elif backend_name == CCL_BACKEND:
+        if ccl_backend is not None and ccl_backend.is_initialized():
+            cdb = ccl_backend
+    elif backend_name == HCCL_BACKEND:
+        if hccl_backend is not None and hccl_backend.is_initialized():
+            cdb = hccl_backend
+
+
+@timed_op
+def broadcast(tensor, src, group=None, async_op=False, prof=False, log_name='broadcast', debug=get_caller_func()):
+    global cdb
+    return cdb.broadcast(tensor=tensor, src=src, group=group, async_op=async_op)
+
+
+@timed_op
+def all_gather(tensor_list,
+               tensor,
+               group=None,
+               async_op=False,
+               prof=False,
+               log_name='all_gather',
+               debug=get_caller_func()):
+    global cdb
+    return cdb.all_gather(tensor_list=tensor_list, tensor=tensor, group=group, async_op=async_op)
+
+
+def has_reduce_scatter_tensor():
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    return cdb.has_reduce_scatter_tensor()
+
+
+def reduce_scatter_fn(output_tensor,
+                      tensor,
+                      op=ReduceOp.SUM,
+                      group=None,
+                      async_op=False,
+                      prof=False,
+                      debug=get_caller_func()):
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    if cdb.has_reduce_scatter_tensor():
+        return reduce_scatter_tensor(output_tensor,
+                                     tensor,
+                                     op=op,
+                                     group=group,
+                                     async_op=async_op,
+                                     prof=prof,
+                                     debug=debug)
+    else:
+        if get_rank() == 0:
+            utils.logger.warning_once("unable to find torch.distributed.reduce_scatter_tensor. will fall back to "
+                                      "torch.distributed.reduce_scatter which will result in suboptimal performance. "
+                                      "please consider upgrading your pytorch installation.")
+        input_tensor_lst = list(torch.chunk(tensor, cdb.get_world_size(group)))
+        return reduce_scatter(output_tensor,
+                              input_tensor_lst,
+                              op=op,
+                              group=group,
+                              async_op=async_op,
+                              prof=prof,
+                              debug=debug)
+
+
+@timed_op
+def reduce_scatter_tensor(output_tensor,
+                          tensor,
+                          op=ReduceOp.SUM,
+                          group=None,
+                          async_op=False,
+                          prof=False,
+                          log_name='reduce_scatter_tensor',
+                          debug=get_caller_func()):
+    global cdb
+    return cdb.reduce_scatter_tensor(output_tensor=output_tensor,
+                                     input_tensor=tensor,
+                                     op=op,
+                                     group=group,
+                                     async_op=async_op)
+
+
+@timed_op
+def all_gather_into_tensor(output_tensor,
+                           tensor,
+                           group=None,
+                           async_op=False,
+                           prof=False,
+                           log_name='all_gather_into_tensor',
+                           debug=get_caller_func()):
+    global cdb
+    return cdb.all_gather_into_tensor(output_tensor=output_tensor, input_tensor=tensor, group=group, async_op=async_op)
+
+
+def has_all_gather_into_tensor():
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    return cdb.has_all_gather_into_tensor()
+
+
+def allgather_fn(output_tensor, input_tensor, group=None, async_op=False, debug=get_caller_func()):
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    if cdb.has_all_gather_into_tensor():
+        return all_gather_into_tensor(output_tensor, input_tensor, group=group, async_op=async_op, debug=debug)
+    else:
+        if get_rank() == 0:
+            utils.logger.warning_once("unable to find torch.distributed.all_gather_into_tensor. will fall back to "
+                                      "torch.distributed.all_gather which will result in suboptimal performance. "
+                                      "please consider upgrading your pytorch installation.")
+        output_tensors = list(torch.chunk(output_tensor, cdb.get_world_size(group)))
+        return all_gather(output_tensors, input_tensor, group=group, async_op=async_op, debug=debug)
+
+
+@timed_op
+def all_to_all_single(output,
+                      tensor,
+                      output_split_sizes=None,
+                      input_split_sizes=None,
+                      group=None,
+                      async_op=False,
+                      prof=False,
+                      log_name='all_to_all_single',
+                      debug=get_caller_func()):
+    global cdb
+    return cdb.all_to_all_single(output=output,
+                                 input=tensor,
+                                 output_split_sizes=output_split_sizes,
+                                 input_split_sizes=input_split_sizes,
+                                 group=group,
+                                 async_op=async_op)
+
+
+@timed_op
+def all_to_all(output_tensor_list, input_tensor_list, group=None, async_op=False):
+    global cdb
+    return cdb.all_to_all(output_tensor_list, input_tensor_list, group=group, async_op=async_op)
+
+
+@timed_op
+def send(tensor, dst, group=None, tag=0, prof=False, log_name='send', debug=get_caller_func()):
+    global cdb
+    return cdb.send(tensor=tensor, dst=dst, group=group, tag=tag)
+
+
+@timed_op
+def recv(tensor, src=None, group=None, tag=0, prof=False, log_name='recv', debug=get_caller_func()):
+    global cdb
+    return cdb.recv(tensor=tensor, src=src, group=group, tag=tag)
+
+
+@timed_op
+def isend(tensor, dst, group=None, tag=0, prof=False, log_name='isend', debug=get_caller_func()):
+    global cdb
+    return cdb.send(tensor=tensor, dst=dst, group=group, tag=tag)
+
+
+@timed_op
+def irecv(tensor, src=None, group=None, tag=0, prof=False, log_name='irecv', debug=get_caller_func()):
+    global cdb
+    return cdb.recv(tensor=tensor, src=src, group=group, tag=tag)
+
+
+@timed_op
+def gather(tensor,
+           gather_list=None,
+           dst=0,
+           group=None,
+           async_op=False,
+           prof=False,
+           log_name='gather',
+           debug=get_caller_func()):
+    global cdb
+    return cdb.gather(tensor=tensor, gather_list=gather_list, dst=dst, group=group, async_op=async_op)
+
+
+@timed_op
+def scatter(tensor,
+            scatter_list=None,
+            src=0,
+            group=None,
+            async_op=False,
+            prof=False,
+            log_name='scatter',
+            debug=get_caller_func()):
+    global cdb
+    return cdb.scatter(tensor=tensor, scatter_list=scatter_list, src=src, group=group, async_op=async_op)
+
+
+@timed_op
+def barrier(group=None, async_op=False, device_ids=None, prof=False, log_name='barrier', debug=get_caller_func()):
+    global cdb
+    return cdb.barrier(group=group, async_op=async_op)
+
+
+@timed_op
+def monitored_barrier(group=None,
+                      timeout=None,
+                      wait_all_ranks=False,
+                      prof=False,
+                      log_name='monitored_barrier',
+                      debug=get_caller_func()):
+    global cdb
+    return cdb.monitored_barrier(group=group, timeout=timeout, wait_all_ranks=wait_all_ranks)
+
+
+def log_summary(show_straggler=False):
+    global cdb
+    barrier(log_name='log_summary_barrier')
+    if cdb.get_rank() == 0:
+        comms_logger.log_all(print_log=True, show_straggler=show_straggler)
+    else:
+        comms_logger.log_all(print_log=False, show_straggler=show_straggler)
+    barrier(log_name='log_summary_barrier')
+
+
+@timed_op
+def reduce(tensor,
+           dst,
+           op=ReduceOp.SUM,
+           group=None,
+           async_op=False,
+           prof=False,
+           log_name='reduce',
+           debug=get_caller_func()):
+    global cdb
+    return cdb.reduce(tensor=tensor, dst=dst, op=op, group=group, async_op=async_op)
+
+
+@timed_op
+def reduce_scatter(output,
+                   input_list,
+                   op=ReduceOp.SUM,
+                   group=None,
+                   async_op=False,
+                   prof=False,
+                   log_name='reduce_scatter',
+                   debug=get_caller_func()):
+    global cdb
+    return cdb.reduce_scatter(output=output, input_list=input_list, op=op, group=group, async_op=async_op)
+
+
+def has_all_reduce_coalesced():
+    """"""
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    assert cdb.has_all_reduce_coalesced is not None, 'has_all_reduce_coalesced is not yet defined'
+    return cdb.has_all_reduce_coalesced
+
+
+def has_coalescing_manager():
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    assert cdb.has_coalescing_manager is not None, 'has_coalescing_manager is not yet defined'
+    return cdb.has_coalescing_manager
+
+
+def all_gather_coalesced(output_tensors, input_tensors, group=None, async_op=False):
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    return cdb.all_gather_coalesced(output_tensors, input_tensors, group=group, async_op=async_op)
+
+
+@timed_op
+def all_reduce(tensor,
+               op=ReduceOp.SUM,
+               group=None,
+               async_op=False,
+               prof=False,
+               log_name='all_reduce',
+               debug=get_caller_func()):
+    #if profile_comm:
+    # context of the timers?
+    # timers.start()
+    # TensorBoard logging for comm calls.?
+    global cdb
+    #print(f'op = {op}, cdb= {cdb.name}')
+    return cdb.all_reduce(tensor, op, group, async_op)
+
+
+@timed_op
+def inference_all_reduce(tensor,
+                         op=ReduceOp.SUM,
+                         group=None,
+                         async_op=False,
+                         prof=False,
+                         log_name='all_reduce',
+                         debug=get_caller_func()):
+    global cdb
+    return cdb.inference_all_reduce(tensor, op, group, async_op)
+
+
+@timed_op
+def all_reduce_coalesced(tensors,
+                         op=ReduceOp.SUM,
+                         group=None,
+                         async_op=False,
+                         prof=False,
+                         log_name='all_reduce',
+                         debug=get_caller_func()):
+    global cdb
+    return cdb.all_reduce_coalesced(tensors, op, group, async_op)
+
+
+def get_world_group():
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    return cdb.get_world_group()
+
+
+def get_world_size(group=None) -> int:
+    """
+    Returns the number of processes in the current process group
+    Args:
+        group (ProcessGroup, optional): The process group to work on. If None,
+            the default process group will be used.
+    Returns:
+        The world size of the process group
+        -1, if not part of the group
+    """
+    global cdb
+
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    return cdb.get_world_size(group)
+
+
+def get_rank(group=None):
+    """
+    Returns the rank of the current process in the provided ``group`` or the
+    default group if none was provided.
+    Rank is a unique identifier assigned to each process within a distributed
+    process group. They are always consecutive integers ranging from 0 to
+    ``world_size``.
+    Args:
+        group (ProcessGroup, optional): The process group to work on. If None,
+            the default process group will be used.
+    Returns:
+        The rank of the process group
+        -1, if not part of the group
+    """
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    return cdb.get_rank(group)
+
+
+def get_local_rank():
+    """
+        Helper function to get local rank after a backend has been set and initialized
+        Args:
+            None
+        Returns:
+            local rank (= GPU device ID)
+    """
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    return get_local_rank_from_launcher()
+
+
+def get_global_rank(group=None, group_rank=0):
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    return cdb.get_global_rank(group, group_rank)
+
+
+def get_all_ranks_from_group(group=None):
+    global cdb
+    assert cdb is not None and cdb.is_initialized(
+    ), 'DeepSpeed backend not set, please initialize it using init_process_group()'
+    rank = 0
+    group_ranks = []
+    try:
+        while True:
+            group_ranks.append(cdb.get_global_rank(group, rank))
+            rank += 1
+    except RuntimeError:
+        pass
+    return group_ranks
+
+
+# Main DeepSpeed Comms. public API.
+def init_distributed(dist_backend=None,
+                     auto_mpi_discovery=True,
+                     distributed_port=TORCH_DISTRIBUTED_DEFAULT_PORT,
+                     verbose=True,
+                     timeout=default_pg_timeout,
+                     init_method=None,
+                     dist_init_required=None,
+                     config=None,
+                     rank=-1,
+                     world_size=-1):
+    ''' Initialize dist backend, potentially performing MPI discovery if needed
+
+    Arguments:
+        dist_backend: Optional (str). torch distributed backend, e.g., nccl, mpi, gloo
+        auto_mpi_discovery Optional (bool). if distributed environment variables are not set, attempt to discover them from MPI
+        distributed_port: Optional (int). torch distributed backend port
+        verbose: Optional (bool). verbose logging
+        timeout: Optional (timedelta). Timeout for operations executed against the process group. Default value equals 30 minutes.
+        init_method: Optional (string). Torch distributed, URL specifying how to initialize the process group. Default is “env://” if no init_method or store is specified.
+        config: Optional (dict). DeepSpeed configuration for setting up comms options (e.g. Comms profiling)
+        rank: Optional (int). The current manually specified rank. Some init_method like “tcp://” need the rank and world_size as well (see: https://pytorch.org/docs/stable/distributed.html#tcp-initialization)
+        world_size: Optional (int). Desired world_size for the TCP or Shared file-system initialization.
+    '''
+    global cdb
+
+    configure(deepspeed_config=config)
+
+    if dist_init_required is None:
+        dist_init_required = cdb is None or not cdb.is_initialized()
+
+    if cdb is None:
+        init_deepspeed_backend(get_accelerator().communication_backend_name(), timeout, init_method)
+        set_backend()
+        utils.logger.info(f'cdb={cdb}')
+    if cdb is None and torch.distributed.is_initialized():
+        # The user initialized torch.dist themselves, create cdb and short-circuit
+        cdb = TorchBackend(dist_backend, timeout, init_method)
+        return
+
+    if dist_init_required is False:
+        assert (
+            cdb is not None and cdb.is_initialized() is True
+        ), "Distributed backend is not initialized. Please set dist_init_required to True or initialize before calling deepspeed.initialize()"
+    else:
+        # Initialize torch distributed if needed
+        required_env = ["RANK", "WORLD_SIZE", "MASTER_ADDR", "MASTER_PORT", "LOCAL_RANK"]
+        if auto_mpi_discovery and not all(map(lambda v: v in os.environ, required_env)):
+            if verbose:
+                utils.logger.info("Not using the DeepSpeed or dist launchers, attempting to detect MPI environment...")
+            if in_aml() and not in_dlts():
+                patch_aml_env_for_torch_nccl_backend(verbose=verbose)
+            elif in_aws_sm():
+                patch_aws_sm_env_for_torch_nccl_backend(verbose=verbose)
+            else:
+                mpi_discovery(distributed_port=distributed_port, verbose=verbose)
+
+        if cdb is not None and cdb.is_initialized():
+            if int(os.getenv('RANK', '0')) == 0:
+                utils.logger.info('Distributed backend already initialized')
+        else:
+            assert isinstance(timeout, timedelta)
+            if dist_backend is None:
+                dist_backend = get_accelerator().communication_backend_name()
+            if int(os.getenv('RANK', '0')) == 0:
+                utils.logger.info('Initializing TorchBackend in DeepSpeed with backend {}'.format(dist_backend))
+            # Create a torch backend object, initialize torch distributed, and assign to cdb
+            cdb = TorchBackend(dist_backend, timeout, init_method, rank, world_size)
+
+
+def mpi_discovery(distributed_port=TORCH_DISTRIBUTED_DEFAULT_PORT, verbose=True):
+    '''
+    Discovery MPI environment via mpi4py and map to relevant dist state
+    '''
+    from mpi4py import MPI
+    import subprocess
+    comm = MPI.COMM_WORLD
+    rank = comm.Get_rank()
+    world_size = comm.Get_size()
+
+    master_addr = None
+    if rank == 0:
+        hostname_cmd = ["hostname -I"]
+        result = subprocess.check_output(hostname_cmd, shell=True)
+        master_addr = result.decode('utf-8').split()[0]
+    master_addr = comm.bcast(master_addr, root=0)
+
+    # Determine local rank by assuming hostnames are unique
+    proc_name = MPI.Get_processor_name()
+    all_procs = comm.allgather(proc_name)
+    local_rank = sum([i == proc_name for i in all_procs[:rank]])
+
+    os.environ['RANK'] = str(rank)
+    os.environ['WORLD_SIZE'] = str(world_size)
+    os.environ['LOCAL_RANK'] = str(local_rank)
+    os.environ['MASTER_ADDR'] = master_addr
+    os.environ['MASTER_PORT'] = str(distributed_port)
+
+    if verbose:
+        utils.logger.info(
+            "Discovered MPI settings of world_rank={}, local_rank={}, world_size={}, master_addr={}, master_port={}".
+            format(os.environ['RANK'], os.environ['LOCAL_RANK'], os.environ['WORLD_SIZE'], os.environ['MASTER_ADDR'],
+                   os.environ['MASTER_PORT']))
+
+    if cdb is not None and cdb.is_initialized():
+        assert cdb.get_rank() == rank, "MPI rank {} does not match torch rank {}".format(rank, cdb.get_rank())
+        assert cdb.get_world_size() == world_size, "MPI world size {} does not match torch world size {}".format(
+            world_size, cdb.get_world_size())
+
+
+def in_aml():
+    # Are we running inside an Azure Machine Learning (AML) environment?
+    return 'AZUREML_EXPERIMENT_ID' in os.environ
+
+
+def in_aws_sm():
+    # Are we running inside an AWS SageMaker environment?
+    return 'SM_TRAINING_ENV' in os.environ
+
+
+def in_dlts():
+    # Are we running on a DLTS cluster?
+    return 'DLTS_JOB_ID' in os.environ
+
+
+def patch_aml_env_for_torch_nccl_backend(master_port=6105, verbose=True):
+    """Helper routine to get and set environment variables.
+    This is adapted from Azure ML's documentation available from:
+    https://azure.github.io/azureml-web/docs/cheatsheet/distributed-training/#environment-variables-from-openmpi
+    """
+    os.environ["RANK"] = os.environ["OMPI_COMM_WORLD_RANK"]
+    os.environ["WORLD_SIZE"] = os.environ["OMPI_COMM_WORLD_SIZE"]
+    single_node = int(os.environ["OMPI_COMM_WORLD_LOCAL_SIZE"]) == int(os.environ["WORLD_SIZE"])
+
+    if not single_node:
+        master_node_params = os.environ["AZ_BATCH_MASTER_NODE"].split(":")
+        os.environ["MASTER_ADDR"] = master_node_params[0]
+        # Do not overwrite master port with that defined in AZ_BATCH_MASTER_NODE
+        if "MASTER_PORT" not in os.environ:
+            os.environ["MASTER_PORT"] = str(master_port)
+    else:
+        os.environ["MASTER_ADDR"] = os.environ["AZ_BATCHAI_MPI_MASTER_NODE"]
+        os.environ["MASTER_PORT"] = DEFAULT_AML_MASTER_PORT
+
+    if verbose:
+        utils.logger.info("NCCL_SOCKET_IFNAME original value = {}".format(os.environ["NCCL_SOCKET_IFNAME"]))
+
+    os.environ["NCCL_SOCKET_IFNAME"] = DEFAULT_AML_NCCL_SOCKET_IFNAME
+    os.environ['LOCAL_RANK'] = os.environ["OMPI_COMM_WORLD_LOCAL_RANK"]
+
+    if verbose:
+        utils.logger.info(
+            "Discovered AzureML settings of world_rank={}, local_rank={}, world_size={}, master_addr={}, master_port={}"
+            .format(os.environ['RANK'], os.environ['LOCAL_RANK'], os.environ['WORLD_SIZE'], os.environ['MASTER_ADDR'],
+                    os.environ['MASTER_PORT']))
+
+
+def patch_aws_sm_env_for_torch_nccl_backend(verbose=True):
+    """Helper routine to get and set environment variables when running inside an AWS SageMaker environment.
+    """
+    os.environ["RANK"] = os.environ["OMPI_COMM_WORLD_RANK"]
+    os.environ['LOCAL_RANK'] = os.environ["OMPI_COMM_WORLD_LOCAL_RANK"]
+    os.environ["WORLD_SIZE"] = os.environ["OMPI_COMM_WORLD_SIZE"]
+
+    if verbose:
+        utils.logger.info(
+            "Discovered AWS SageMaker settings of world_rank={}, local_rank={}, world_size={}, master_addr={}, master_port={}"
+            .format(os.environ['RANK'], os.environ['LOCAL_RANK'], os.environ['WORLD_SIZE'], os.environ['MASTER_ADDR'],
+                    os.environ['MASTER_PORT']))

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/comm/constants.py

@@ -0,0 +1,51 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+NCCL_BACKEND = 'nccl'
+CCL_BACKEND = 'ccl'
+MPI_BACKEND = 'mpi'
+GLOO_BACKEND = 'gloo'
+SCCL_BACKEND = 'sccl'
+HCCL_BACKEND = 'hccl'
+
+DEFAULT_AML_MASTER_PORT = "54965"
+DEFAULT_AML_NCCL_SOCKET_IFNAME = "^docker0,lo"
+
+#########################################
+# Comms Logger
+#########################################
+# Comms Logger. By default, this feature is not enabled.
+# Users can configure in ds_config.json as below example:
+COMMS_LOGGER_FORMAT = '''
+The Comms Logger can be specified as:
+"comms_logger": {
+  "enabled": true,
+  "verbose": false,
+  "prof_all": true,
+  "debug": false,
+  "prof_ops": ["all_reduce", "custom_all_reduce_name"]
+}
+'''
+COMMS_LOGGER = "comms_logger"
+
+# Comms logger enable signal
+COMMS_LOGGER_ENABLED = "enabled"
+COMMS_LOGGER_ENABLED_DEFAULT = False
+
+# Comms logger verbose signal
+COMMS_LOGGER_VERBOSE = "verbose"
+COMMS_LOGGER_VERBOSE_DEFAULT = False
+
+# comms logger profile all ops signal
+COMMS_LOGGER_PROF_ALL = "prof_all"
+COMMS_LOGGER_PROF_ALL_DEFAULT = True
+
+# comms logger show all ops signal
+COMMS_LOGGER_DEBUG = "debug"
+COMMS_LOGGER_DEBUG_DEFAULT = False
+
+# comms logger profile specific ops in list
+COMMS_LOGGER_PROF_OPS = "prof_ops"
+COMMS_LOGGER_PROF_OPS_DEFAULT = []

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/comm/torch.py

@@ -0,0 +1,374 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from deepspeed import utils
+
+from .utils import *
+from .backend import *
+from .comm import *
+import os
+
+DS_COMM_ALL_GATHER_OFF = False
+DS_COMM_REDUCE_SCATTER_OFF = False
+DS_COMM_BROADCAST_OFF = False
+DS_COMM_ALL_REDUCE_OFF = False
+DS_COMM_REDUCE_OFF = False
+
+
+def is_torch_ver_eq_2_0():
+    TORCH_MAJOR, TORCH_MINOR = map(int, torch.__version__.split('.')[:2])
+    if TORCH_MAJOR == 2 and TORCH_MINOR == 0:
+        return True
+    return False
+
+
+def is_torch_ver_ge_2_1():
+    TORCH_MAJOR, TORCH_MINOR = map(int, torch.__version__.split('.')[:2])
+    if TORCH_MAJOR >= 2 and TORCH_MINOR >= 1:
+        return True
+    return False
+
+
+def torch_ver_ge_1_13():
+    TORCH_MAJOR, TORCH_MINOR = map(int, torch.__version__.split('.')[:2])
+    if TORCH_MAJOR >= 1 and TORCH_MINOR >= 13:
+        return True
+    return False
+
+
+def has_coalescing_manager():
+    has_c10d = hasattr(torch.distributed, 'distributed_c10d')
+    return has_c10d and hasattr(torch.distributed.distributed_c10d, '_coalescing_manager')
+
+
+def has_all_reduce_coalesced():
+    return hasattr(torch.distributed, "all_reduce_coalesced") and torch_ver_ge_1_13()
+
+
+def get_coalescing_manager(group, device, reqs, async_op):
+    if is_torch_ver_eq_2_0():
+        return torch.distributed.distributed_c10d._coalescing_manager(group, device=device, reqs=reqs)
+    elif is_torch_ver_ge_2_1():
+        return torch.distributed.distributed_c10d._coalescing_manager(group, device=device, async_ops=async_op)
+    else:
+        return torch.distributed.distributed_c10d._coalescing_manager(group, reqs)
+
+
+##Utilities to turn comm off
+##TODO: move to base comm (wrapper)
+def all_gather_comm_off(flag=False):
+    global DS_COMM_ALL_GATHER_OFF
+    DS_COMM_ALL_GATHER_OFF = flag
+
+
+def reduce_scatter_comm_off(flag=False):
+    global DS_COMM_REDUCE_SCATTER_OFF
+    DS_COMM_REDUCE_SCATTER_OFF = flag
+
+
+def broadcast_comm_off(flag=False):
+    global DS_COMM_BROADCAST_OFF
+    DS_COMM_BROADCAST_OFF = flag
+
+
+def all_reduce_comm_off(flag=False):
+    global DS_COMM_ALL_REDUCE_OFF
+    DS_COMM_ALL_REDUCE_OFF = flag
+
+
+def reduce_comm_off(flag=False):
+    global DS_COMM_REDUCE_OFF
+    DS_COMM_REDUCE_OFF = flag
+
+
+#assumption: all_gather and reduce scatter
+## are what we care about
+def backward_comm_off(flag=False):
+    all_gather_comm_off(flag)
+    reduce_scatter_comm_off(flag)
+
+
+class Noop:
+
+    def wait(self):
+        return None
+
+
+class TorchBackend(Backend):
+    """
+        A light-weight wrapper class for torch.distributed API.
+        Only a subset of functions are wrapped. Once the init_process_group
+        is initialized, standard torch.distributed.* can be used directly
+        so no need to wrap all the functions. We can keep adding wrappers as
+        needed.
+    """
+
+    def __init__(self, backend, timeout, init_method, rank=-1, world_size=-1, name='torch'):
+        super(TorchBackend, self).__init__()
+        self.has_all_reduce_coalesced = has_all_reduce_coalesced()
+        self.has_coalescing_manager = has_coalescing_manager()
+        self.all_gather_function = self.get_all_gather_function()
+        self.reduce_scatter_function = self.get_reduce_scatter_function()
+        self.initialized = True
+        self.name = name
+        # Future functionality to support ds.initialize() on a single GPU
+        # The idea is to fake that dist backend is initialized even when
+        # it is not so we can run on a single GPU without doing any init_process_group
+        self.single_gpu_mode = True
+        self.init_process_group(backend, timeout, init_method, rank, world_size)
+
+    @classmethod
+    def get_all_gather_function(self):
+        if hasattr(torch.distributed, "all_gather_into_tensor"):
+            return torch.distributed.all_gather_into_tensor
+        elif hasattr(torch.distributed, "_all_gather_base"):
+            return torch.distributed._all_gather_base
+        return None
+
+    @classmethod
+    def get_reduce_scatter_function(self):
+        if hasattr(torch.distributed, "reduce_scatter_tensor"):
+            return torch.distributed.reduce_scatter_tensor
+        elif hasattr(torch.distributed, "_reduce_scatter_base"):
+            return torch.distributed._reduce_scatter_base
+        return None
+
+    def has_all_gather_into_tensor(self):
+        return self.all_gather_function is not None
+
+    def has_reduce_scatter_tensor(self):
+        return self.reduce_scatter_function is not None
+
+    def init_process_group(self, backend, timeout, init_method, rank, world_size):
+        if not torch.distributed.is_initialized():
+            torch.distributed.init_process_group(backend,
+                                                 timeout=timeout,
+                                                 init_method=init_method,
+                                                 rank=rank,
+                                                 world_size=world_size)
+        self.using_mpi = torch.distributed.get_backend() == 'mpi'
+
+    def all_reduce(self, tensor, op=torch.distributed.ReduceOp.SUM, group=None, async_op=False):
+        op = self._reduce_op(op)
+        return torch.distributed.all_reduce(tensor=tensor, op=op, group=group, async_op=async_op)
+
+    def inference_all_reduce(self, tensor, op=torch.distributed.ReduceOp.SUM, group=None, async_op=False):
+        op = self._reduce_op(op)
+        return torch.distributed.all_reduce(tensor=tensor, op=op, group=group, async_op=async_op)
+
+    def all_reduce_coalesced(self, tensors, op=torch.distributed.ReduceOp.SUM, group=None, async_op=False):
+        """ proxy func to torch.distributed.all_reduce_coalesced,
+        which is included in PyTorch 1.13 and above
+        """
+        if not self.has_all_reduce_coalesced:
+            raise RuntimeError(f"Current torch version does not have all_reduce_coalesced "
+                               f"api (torch.__version__: {torch.__version__})")
+        op = self._reduce_op(op)
+        return torch.distributed.all_reduce_coalesced(tensors=tensors, op=op, group=group, async_op=async_op)
+
+    def reduce(self, tensor, dst, op=ReduceOp.SUM, group=None, async_op=False):
+        if DS_COMM_REDUCE_OFF:
+            if int(os.getenv('RANK', '0')) == 0:
+                utils.logger.warning("REDUCE is OFF")
+            return Noop()
+        return torch.distributed.reduce(tensor=tensor, dst=dst, op=self._reduce_op(op), group=group, async_op=async_op)
+
+    def reduce_scatter(self, output, input_list, op=ReduceOp.SUM, group=None, async_op=False):
+        if DS_COMM_REDUCE_SCATTER_OFF:
+            if int(os.getenv('RANK', '0')) == 0:
+                utils.logger.warning("REDUCE SCATTER  is OFF")
+            return Noop()
+        else:
+            return torch.distributed.reduce_scatter(output=output,
+                                                    input_list=input_list,
+                                                    op=self._reduce_op(op),
+                                                    group=group,
+                                                    async_op=async_op)
+
+    def broadcast(self, tensor, src, group=None, async_op=False):
+        if DS_COMM_BROADCAST_OFF:
+            if int(os.getenv('RANK', '0')) == 0:
+                utils.logger.warning("BROADCAST  is OFF")
+            return Noop()
+        else:
+            return torch.distributed.broadcast(tensor=tensor, src=src, group=group, async_op=async_op)
+
+    def all_gather(self, tensor_list, tensor, group=None, async_op=False):
+        if DS_COMM_ALL_GATHER_OFF:
+            if int(os.getenv('RANK', '0')) == 0:
+                utils.logger.warning("All Gather is OFF")
+            return Noop()
+        else:
+            return torch.distributed.all_gather(tensor_list=tensor_list, tensor=tensor, group=group, async_op=async_op)
+
+    def all_gather_into_tensor(self, output_tensor, input_tensor, group=None, async_op=False):
+        if self.has_all_gather_into_tensor():
+            return self.all_gather_function(output_tensor=output_tensor,
+                                            input_tensor=input_tensor,
+                                            group=group,
+                                            async_op=async_op)
+
+    def all_gather_base(self, output_tensor, input_tensor, group=None, async_op=False):
+        if DS_COMM_ALL_GATHER_OFF:
+            if int(os.getenv('RANK', '0')) == 0:
+                utils.logger.warning("All Gather is OFF")
+            return Noop()
+        else:
+            if self.has_allgather_base:
+                return torch.distributed.distributed_c10d._all_gather_base(output_tensor=output_tensor,
+                                                                           input_tensor=input_tensor,
+                                                                           group=group,
+                                                                           async_op=async_op)
+            else:
+                utils.logger.warning("unable to find torch.distributed._all_gather_base. will fall back to "
+                                     "torch.distributed.reduce_scatter which will result in suboptimal performance. "
+                                     "please consider upgrading your pytorch installation.")
+                pass
+
+    def all_gather_coalesced(self, output_tensors, input_tensors, group=None, async_op=False):
+        """"""
+        assert len(output_tensors) == len(input_tensors), ""
+        if hasattr(torch.distributed.distributed_c10d, '_all_gather_base_coalesced'):
+            # customized PyTorch
+            return torch.distributed.distributed_c10d._all_gather_base_coalesced(output_tensors,
+                                                                                 input_tensors,
+                                                                                 group=group,
+                                                                                 async_op=async_op)
+        elif has_coalescing_manager():
+            reqs = []
+            with get_coalescing_manager(group, input_tensors[0].device, reqs, async_op):
+                for output, input in zip(output_tensors, input_tensors):
+                    handle = torch.distributed.distributed_c10d.all_gather_into_tensor(output,
+                                                                                       input,
+                                                                                       group=group,
+                                                                                       async_op=True)
+                    reqs.append(handle)
+            if async_op:
+                return reqs[-1]
+            else:
+                reqs[-1].wait()
+
+    def reduce_scatter_tensor(self, output_tensor, input_tensor, op=ReduceOp.SUM, group=None, async_op=False):
+        if self.has_reduce_scatter_tensor():
+            return self.reduce_scatter_function(output_tensor,
+                                                input_tensor,
+                                                op=self._reduce_op(op),
+                                                group=group,
+                                                async_op=async_op)
+        else:
+            utils.logger.warning("unable to find torch.distributed.reduce_scatter_tensor. will fall back to "
+                                 "torch.distributed.reduce_scatter which will result in suboptimal performance. "
+                                 "please consider upgrading your pytorch installation.")
+            pass
+
+    def all_to_all_single(self,
+                          output,
+                          input,
+                          output_split_sizes=None,
+                          input_split_sizes=None,
+                          group=None,
+                          async_op=False):
+        return torch.distributed.all_to_all_single(output=output,
+                                                   input=input,
+                                                   output_split_sizes=output_split_sizes,
+                                                   input_split_sizes=input_split_sizes,
+                                                   group=group,
+                                                   async_op=async_op)
+
+    def all_to_all(self, output_tensor_list, input_tensor_list, group=None, async_op=False):
+        return torch.distributed.all_to_all(output_tensor_list, input_tensor_list, group=group, async_op=async_op)
+
+    def send(self, tensor, dst, group=None, tag=0):
+        return torch.distributed.send(tensor=tensor, dst=dst, group=group, tag=tag)
+
+    def recv(self, tensor, src=None, group=None, tag=0):
+        return torch.distributed.recv(tensor=tensor, src=src, group=group, tag=tag)
+
+    def isend(self, tensor, dst, group=None, tag=0):
+        return torch.distributed.isend(tensor=tensor, dst=dst, group=group, tag=tag)
+
+    def irecv(self, tensor, src=None, group=None, tag=0):
+        return torch.distributed.irecv(tensor=tensor, src=src, group=group, tag=tag)
+
+    def gather(self, tensor, gather_list=None, dst=0, group=None, async_op=False):
+        return torch.distributed.gather(tensor=tensor,
+                                        gather_list=gather_list,
+                                        dst=dst,
+                                        group=group,
+                                        async_op=async_op)
+
+    def scatter(self, tensor, scatter_list=None, src=0, group=None, async_op=False):
+        return torch.distributed.scatter(tensor=tensor,
+                                         scatter_list=scatter_list,
+                                         src=src,
+                                         group=group,
+                                         async_op=async_op)
+
+    def barrier(self, group=torch.distributed.GroupMember.WORLD, async_op=False, device_ids=None):
+        if group is None:
+            group = torch.distributed.GroupMember.WORLD
+        return torch.distributed.barrier(group=group, async_op=async_op, device_ids=device_ids)
+
+    def monitored_barrier(self, group=torch.distributed.GroupMember.WORLD, timeout=None, wait_all_ranks=False):
+        if group is None:
+            group = torch.distributed.GroupMember.WORLD
+        return torch.distributed.monitored_barrier(group=group, timeout=timeout, wait_all_ranks=wait_all_ranks)
+
+    def get_rank(self, group=None):
+        return torch.distributed.get_rank(group=group)
+
+    def get_world_size(self, group=None):
+        return torch.distributed.get_world_size(group=group)
+
+    def is_initialized(self):
+        return torch.distributed.is_initialized()
+
+    def get_backend(self, group=None):
+        return torch.distributed.get_backend(group=group)
+
+    def new_group(self, ranks):
+        return torch.distributed.new_group(ranks)
+
+    def get_global_rank(self, group, group_rank):
+        if hasattr(torch.distributed.distributed_c10d, "get_global_rank"):
+            from torch.distributed.distributed_c10d import get_global_rank as _get_global_rank
+        else:
+            from torch.distributed.distributed_c10d import _get_global_rank
+        return _get_global_rank(group, group_rank)
+
+    def get_world_group(self):
+        return torch.distributed.group.WORLD
+
+    def destroy_process_group(self, group=None):
+        return torch.distributed.destroy_process_group(group=group)
+
+    def _reduce_op(self, op):
+        '''
+            Helper function. If the op provided is not a torch.dist.ReduceOp, convert it and return
+        '''
+        if not isinstance(op, torch.distributed.ReduceOp):
+            if op == ReduceOp.SUM:
+                op = torch.distributed.ReduceOp.SUM
+            elif op == ReduceOp.PRODUCT:
+                op = torch.distributed.ReduceOp.PRODUCT
+            elif op == ReduceOp.AVG:
+                op = torch.distributed.ReduceOp.AVG
+            elif op == ReduceOp.MIN:
+                op = torch.distributed.ReduceOp.MIN
+            elif op == ReduceOp.MAX:
+                op = torch.distributed.ReduceOp.MAX
+            elif op == ReduceOp.BAND:
+                op = torch.distributed.ReduceOp.BAND
+            elif op == ReduceOp.BOR:
+                op = torch.distributed.ReduceOp.BOR
+            elif op == ReduceOp.BXOR:
+                op = torch.distributed.ReduceOp.BXOR
+        return op
+
+
+# This will become a light-weight wrapper around torch.distributed functions
+# TODO: create some example to show how this wrapper can help profile communication
+# TODO: make sure there is no performance regression with this approach
+# TODO: explore monkey-patching if this does not work

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/comm/utils.py

@@ -0,0 +1,133 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import os
+import inspect
+from deepspeed.utils import get_caller_func
+
+
+def get_local_rank_from_launcher():
+
+    # DeepSpeed launcher will set it so get from there
+    rank = os.environ.get('LOCAL_RANK')
+
+    if rank is None:
+        rank = os.environ.get('OMPI_COMM_WORLD_LOCAL_RANK')
+
+    # Make it a single process job and set rank to 0
+    if rank is None:
+        rank = 0
+
+    return int(rank)
+
+
+def get_world_rank_from_launcher():
+
+    # DeepSpeed launcher will set it so get from there
+    rank = os.environ.get('RANK')
+
+    if rank is None:
+        rank = os.environ.get('OMPI_COMM_WORLD_RANK')
+
+    # Make it a single process job and set rank to 0
+    if rank is None:
+        rank = 0
+
+    return int(rank)
+
+
+def get_world_size_from_launcher():
+    # DeepSpeed launcher will set it so get from there
+    size = os.environ.get('WORLD_SIZE')
+    rank = os.environ.get('RANK')
+
+    if size is None:
+        size = os.environ.get('OMPI_COMM_WORLD_SIZE')
+
+    # Make it a single process job and set size to 1
+    if size is None:
+        size = 1
+
+    if rank == 0:
+        print(f"set world size to {size}")
+
+    return int(size)
+
+
+def get_default_args(func):
+    signature = inspect.signature(func)
+    return {k: v.default for k, v in signature.parameters.items() if v.default is not inspect.Parameter.empty}
+
+
+# We need this hacky function since torch doesn't consistently name or place the input tensor args
+def get_tensor_position(func):
+    sig_params = inspect.signature(func).parameters
+    arg = None
+    # most colls
+    if 'tensor' in sig_params:
+        arg = 'tensor'
+    # all_reduce_coalesced coll
+    elif 'tensors' in sig_params:
+        arg = 'tensors'
+    # reduce scatter coll
+    elif 'input_list' in sig_params:
+        arg = 'input_list'
+    # all_to_all and torch multiGPU colls
+    elif 'input_tensor_list' in sig_params:
+        arg = 'input_tensor_list'
+    if arg is None:
+        return -1
+    else:
+        return list(sig_params).index(arg)
+
+
+def get_tensor_kwarg(func, kwargs):
+    func_args = get_default_args(func)
+    func_args.update(kwargs)
+    arg = None
+
+    if 'tensor' in func_args:
+        arg = func_args['tensor']
+    elif 'tensors' in func_args:
+        arg = func_args['tensors']
+    elif 'input_list' in func_args:
+        arg = func_args['input_list']
+    elif 'input_tensor_list' in func_args:
+        arg = func_args['input_tensor_list']
+    return arg
+
+
+def get_msg_size_from_args(func, *args, **kwargs):
+    # 3 cases:
+    #   - tensor arg is in args
+    #   - tensor arg is in kwargs
+    #   - tensor arg is not present (e.g. barrier)
+    tensor_arg_position = -1
+    tensor_arg = None
+    # check if tensor arg is in args
+    if len(args) > 0:
+        tensor_arg_position = get_tensor_position(func)
+        if tensor_arg_position > -1:
+            tensor_arg = args[get_tensor_position(func)]
+    # check if tensor arg is in kwargs
+    if tensor_arg is None and len(kwargs) > 0:
+        tensor_arg = get_tensor_kwarg(func, kwargs)
+    # if tensor arg is not present, no data is being transmitted
+    if tensor_arg is None:
+        return 0
+    else:
+        # Sum of tensor sizes for list colls such as torch's all_to_all
+        # NOTE: msg_size for list colls will not be the actual size transmitted by a given MPI/NCCL call within the coll op. Instead, it's the total amount of data transmitted.
+        if type(tensor_arg) is list:
+            return sum(x.element_size() * x.nelement() for x in tensor_arg)
+        else:
+            return tensor_arg.element_size() * tensor_arg.nelement()
+
+
+def get_debug_log_name(func_args, debug):
+    if debug:
+        return func_args['log_name'] + ' | [Caller Func: ' + get_caller_func() + ']'
+    else:
+        return func_args['log_name']

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/compression/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .compress import init_compression, redundancy_clean
+from .scheduler import compression_scheduler
+from .helper import convert_conv1d_to_linear

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/compression/basic_layer.py

@@ -0,0 +1,840 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+import math
+from torch import nn
+from torch.nn import init
+import deepspeed.comm as dist
+from .utils import TopKBinarizer, SymQuantizer, AsymQuantizer, TernaryQuantizer, BinaryQuantizer
+from deepspeed.utils import logger
+
+g_mpu = None
+
+
+class QuantAct(nn.Module):
+    """
+    Class to quantize given activations. Note that when using this function, the input activation quantization range will be fixed for all
+    tokens/images for inference. This generally will affect some accuracy but achieve better latency performance.
+    Parameters:
+    ----------
+    act_range_momentum : float, default 0.95
+        Momentum for updating the activation quantization range.
+    quant_mode : str, default 'symmetric'
+    """
+
+    def __init__(self, act_range_momentum=0.95, quant_mode='symmetric'):
+        super(QuantAct, self).__init__()
+
+        self.act_range_momentum = act_range_momentum
+        self.quant_mode = quant_mode
+        if quant_mode == 'symmetric':
+            self.act_function = SymQuantizer.apply
+        else:
+            self.act_function = AsymQuantizer.apply
+
+        self.register_buffer('x_min_max', torch.zeros(2))
+
+    def forward(self, x, num_bits, *args):
+        """
+        x: the activation that we need to quantize
+        num_bits: the number of bits we need to quantize the activation to
+        *args: some extra arguments that are useless but needed for align with the interface of other quantization functions
+        """
+
+        if self.training:
+            x_min = x.data.min()
+            x_max = x.data.max()
+
+            # Initialization
+            if self.x_min_max[0] == self.x_min_max[1]:
+                self.x_min_max[0] = x_min
+                self.x_min_max[1] = x_max
+
+            # if do not need momentum, please set self.act_range_momentum = 0
+            self.x_min_max[0] = self.x_min_max[0] * self.act_range_momentum + x_min * (1 - self.act_range_momentum)
+            self.x_min_max[1] = self.x_min_max[1] * self.act_range_momentum + x_max * (1 - self.act_range_momentum)
+
+        x_q = self.act_function(x, num_bits, self.x_min_max[0], self.x_min_max[1])
+
+        return x_q
+
+
+class Embedding_Compress(nn.Embedding):
+
+    def __init__(self, *kargs):
+        super(Embedding_Compress, self).__init__(*kargs)
+        self.weight.start_bits = None
+        self.weight.target_bits = None
+        self.weight.q_period = None
+        self.weight_quantization_enabled_in_forward = False
+        self.weight_quantization_enabled = False
+
+    def extra_repr(self):
+        return 'num_embeddings={}, embedding_dim={}, weight_quantization={}'.format(
+            self.num_embeddings, self.embedding_dim, self.weight.target_bits)
+
+    def enable_weight_quantization(self, start_bits, target_bits, quantization_period,
+                                   weight_quantization_enabled_in_forward, quantization_type, num_groups):
+        self.weight.start_bits = start_bits
+        self.weight.target_bits = target_bits
+        self.weight.q_period = quantization_period
+        self.weight_quantization_enabled_in_forward = weight_quantization_enabled_in_forward
+        if self.weight_quantization_enabled_in_forward:
+            logger.warning(
+                "************ A lot of MoQ features are not supported in quantize_weight_in_forward mode, please consider to use DS-FP16 optimizer************"
+            )
+            if self.weight.target_bits >= 3:
+                if quantization_type == 'symmetric':
+                    self.weight_quantizer = SymQuantizer.apply
+                else:
+                    self.weight_quantizer = AsymQuantizer.apply
+            elif self.weight.target_bits == 2:
+                assert quantization_type == 'symmetric', 'Only symmetric quantization is supported for ternary weight quantization'
+                self.weight_quantizer = TernaryQuantizer.apply
+            elif self.weight.target_bits == 1:
+                assert quantization_type == 'symmetric', 'Only symmetric quantization is supported for binary weight quantization'
+                self.weight_quantizer = BinaryQuantizer.apply
+            # for embedding, we always use token-wise quantization
+            self.weight_quantize_num_groups = self.weight.size(0)
+
+    def fix_weight_quantization(self):
+        self.weight.data = self.weight_quantizer(self.weight, self.weight.target_bits, None, None,
+                                                 self.weight_quantize_num_groups).data
+        self.weight_quantization_enabled_in_forward = False
+        return None
+
+    def forward(self, input):
+        if self.weight_quantization_enabled_in_forward and self.weight_quantization_enabled:
+            weight = self.weight_quantizer(self.weight, self.weight.target_bits, None, None,
+                                           self.weight_quantize_num_groups)
+        else:
+            weight = self.weight
+
+        out = nn.functional.embedding(input, weight, self.padding_idx, self.max_norm, self.norm_type,
+                                      self.scale_grad_by_freq, self.sparse)
+        return out
+
+
+class LinearLayer_Compress(nn.Linear):
+    """
+    Linear layer with compression.
+    """
+
+    def __init__(self, *kargs, bias=True):
+        super(LinearLayer_Compress, self).__init__(*kargs, bias=bias)
+        self.sparse_pruning_method = None
+        self.row_pruning_method = None
+        self.head_pruning_method = None
+        self.activation_quantization_method = None
+        self.weight.start_bits = None
+        self.weight.target_bits = None
+        self.weight.q_period = None
+        self.weight_quantization_enabled_in_forward = False
+        self.weight_quantization_enabled = False
+        self.sparse_pruning_enabled = False
+        self.row_pruning_enabled = False
+        self.head_pruning_enabled = False
+        self.activation_quantization_enabled = False
+
+    def extra_repr(self):
+        return 'in_features={}, out_features={}, bias={}, sparse pruning={}, row pruning={}, head pruning={}, activation quantization={}, weight_quantization={}'.format(
+            self.in_features, self.out_features, self.bias is not None, self.sparse_pruning_method is not None, \
+            self.row_pruning_method is not None, self.head_pruning_method is not None, self.activation_quantization_method is not None, self.weight.target_bits)
+
+    def enable_sparse_pruning(self, ratio, method):
+        # Here, we support two cases: L1 norm based pruning and topk based pruning
+        self.sparse_pruning_ratio = ratio
+        self.sparse_pruning_method = method
+        if method == 'l1':
+            weight_norm = torch.abs(self.weight.data)
+            mask = TopKBinarizer.apply(weight_norm, self.sparse_pruning_ratio, False)
+            mask = mask.view(self.weight.size())
+            mask = mask.to(self.weight.device)
+        elif method == 'topk':
+            self.sparse_mask_scores = nn.Parameter(torch.Tensor(self.weight.size()))
+            self.sparse_mask_scores.data = self.sparse_mask_scores.data.to(self.weight.device)
+            init.kaiming_uniform_(self.sparse_mask_scores, a=math.sqrt(5))
+            mask = None
+        else:
+            raise NotImplementedError
+
+        self.register_buffer('sparse_pruning_mask', mask)
+
+    def enable_row_pruning(self, ratio, method):
+        # Here, we support two cases: L1 norm based pruning and topk based pruning
+        self.row_pruning_ratio = ratio
+        self.row_pruning_method = method
+
+        if method == 'l1':
+            # compute the l1 norm of each column
+            weight_norm = torch.linalg.norm(self.weight.data, ord=1, dim=1)
+            mask = TopKBinarizer.apply(weight_norm, self.row_pruning_ratio, False)
+            mask = mask.view(-1, 1)
+            mask = mask.to(self.weight.device)
+        elif method == 'topk':
+            self.row_mask_scores = nn.Parameter(torch.Tensor(self.weight.size(0), 1))
+            self.row_mask_scores.data = self.row_mask_scores.data.to(self.weight.device)
+            init.kaiming_uniform_(self.row_mask_scores, a=math.sqrt(5))
+            mask = None
+        else:
+            raise NotImplementedError
+
+        self.register_buffer('row_pruning_mask', mask)
+
+    def enable_head_pruning(self, ratio, method, num_heads):
+        # Here, we support only topk based pruning
+        self.num_heads = num_heads
+        self.head_pruning_ratio = ratio
+        self.head_pruning_method = method
+
+        if method not in ['topk']:
+            raise NotImplementedError
+        else:
+            self.head_pruning_ratio = ratio
+            self.head_pruning_scores = nn.Parameter(torch.Tensor(1,
+                                                                 self.num_heads))  # we apply the pruning to O matrix
+            self.head_pruning_scores.data = self.head_pruning_scores.data.to(self.weight.device)
+            init.kaiming_uniform_(self.head_pruning_scores, a=math.sqrt(5))
+
+    def fix_sparse_pruning_helper(self):
+        mask = self.get_mask(pruning_type='sparse')
+        self.weight.data = self.weight.data * mask
+        del self.sparse_pruning_mask
+        if self.sparse_pruning_method == 'topk':
+            del self.sparse_mask_scores
+        self.sparse_pruning_method = None
+        self.sparse_pruning_enabled = False
+        return None
+
+    def fix_row_col_pruning_helper(self, mask=None, dim_reduction=False):
+        # This function is used for row/col pruning
+        # particularly, if we have two back-to-back layers, F1 and F2; when
+        # we remove rows from F1, we also need to remove columns from F2
+        # However, if we only have one layer, F1, then we only need to mask pruned
+        # rows as 0 in F1
+        if mask is None:
+            mask = self.get_mask(pruning_type='row').bool()
+            if dim_reduction:
+                start_bits = self.weight.start_bits
+                target_bits = self.weight.target_bits
+                q_period = self.weight.q_period
+                self.weight = nn.Parameter(self.weight.data[mask.view(-1), :])
+                self.weight.start_bits = start_bits
+                self.weight.target_bits = target_bits
+                self.weight.q_period = q_period
+                if self.bias is not None:
+                    self.bias = nn.Parameter(self.bias.data[mask.view(-1)])
+                self.out_features = self.weight.size(0)
+            else:
+                self.weight.data = self.weight.data * mask.view(-1, 1)
+                if self.bias is not None:
+                    self.bias.data = self.bias.data * mask.view(-1)
+
+            del self.row_pruning_mask
+            if self.row_pruning_method == 'topk':
+                del self.row_mask_scores
+            self.row_pruning_method = None
+        else:
+            # this is generally for column pruning
+            start_bits = self.weight.start_bits
+            target_bits = self.weight.target_bits
+            q_period = self.weight.q_period
+            self.weight = nn.Parameter(self.weight.data[:, mask.view(-1)])
+            self.weight.start_bits = start_bits
+            self.weight.target_bits = target_bits
+            self.weight.q_period = q_period
+            self.in_features = self.weight.size(1)
+            mask = None
+        self.row_pruning_enabled = False
+        return mask
+
+    def fix_head_pruning_helper(self, mask=None, num_heads=None, dim_reduction=False):
+        # similar as row/col pruning, head pruning also needs to prune QKV which is associated with O matrix
+        num_heads = num_heads if num_heads else self.num_heads
+        if mask is None:
+            if self.head_pruning_method == 'topk':
+                mask = self.get_mask(pruning_type='head').bool()
+                if dim_reduction:
+                    shape = self.weight.size(0)
+                    start_bits = self.weight.start_bits
+                    target_bits = self.weight.target_bits
+                    q_period = self.weight.q_period
+                    self.weight = nn.Parameter(self.weight.data.t().reshape(num_heads,
+                                                                            -1)[mask.view(-1), :].reshape(-1,
+                                                                                                          shape).t())
+                    self.weight.start_bits = start_bits
+                    self.weight.target_bits = target_bits
+                    self.weight.q_period = q_period
+                else:
+
+                    shape = self.weight.size()
+                    self.weight.data = (self.weight.data.t().reshape(self.num_heads, -1) * mask.view(-1, 1)).reshape(
+                        shape[1], shape[0]).t()
+
+                if self.head_pruning_method == 'topk':
+                    del self.head_pruning_scores
+                self.head_pruning_method = None
+            else:
+                raise NotImplementedError
+        else:
+            start_bits = self.weight.start_bits
+            target_bits = self.weight.target_bits
+            q_period = self.weight.q_period
+            shape = self.weight.size(1)
+            self.weight = nn.Parameter(self.weight.data.reshape(num_heads, -1)[mask.view(-1), :].reshape(-1, shape))
+            self.weight.start_bits = start_bits
+            self.weight.target_bits = target_bits
+            self.weight.q_period = q_period
+            if self.bias is not None:
+                self.bias = nn.Parameter(self.bias.data.reshape(num_heads, -1)[mask.view(-1), :].reshape(-1))
+        self.head_pruning_enabled = False
+        return mask
+
+    def get_mask(self, pruning_type='row'):
+        if pruning_type == 'sparse':
+            if self.sparse_pruning_method == 'l1':
+                return self.sparse_pruning_mask.to(self.weight.device)
+            elif self.sparse_pruning_method == 'topk':
+                return TopKBinarizer.apply(self.sparse_mask_scores, self.sparse_pruning_ratio, False)
+            else:
+                raise NotImplementedError
+        if pruning_type == 'row':
+            if self.row_pruning_method == 'l1':
+                return self.row_pruning_mask.to(self.weight.device)
+            elif self.row_pruning_method == 'topk':
+                return TopKBinarizer.apply(self.row_mask_scores, self.row_pruning_ratio, False)
+            else:
+                raise NotImplementedError
+        elif pruning_type == 'head':
+            if self.head_pruning_method == 'topk':
+                return TopKBinarizer.apply(self.head_pruning_scores, self.head_pruning_ratio, False)
+            else:
+                raise NotImplementedError
+        else:
+            raise NotImplementedError
+
+    def enable_weight_quantization(self, start_bits, target_bits, quantization_period,
+                                   weight_quantization_enabled_in_forward, quantization_type, num_groups):
+        self.weight.start_bits = start_bits
+        self.weight.target_bits = target_bits
+        self.weight.q_period = quantization_period
+        self.weight_quantization_enabled_in_forward = weight_quantization_enabled_in_forward
+        if self.weight_quantization_enabled_in_forward:
+            logger.warning(
+                "************ A lot of MoQ features are not supported in quantize_weight_in_forward mode, please consider to use DS-FP16 optimizer************"
+            )
+            if self.weight.target_bits >= 3:
+                if quantization_type == 'symmetric':
+                    self.weight_quantizer = SymQuantizer.apply
+                else:
+                    self.weight_quantizer = AsymQuantizer.apply
+            elif self.weight.target_bits == 2:
+                assert quantization_type == 'symmetric', 'Only symmetric quantization is supported for ternary weight quantization'
+                self.weight_quantizer = TernaryQuantizer.apply
+            elif self.weight.target_bits == 1:
+                assert quantization_type == 'symmetric', 'Only symmetric quantization is supported for binary weight quantization'
+                self.weight_quantizer = BinaryQuantizer.apply
+            self.weight_quantize_num_groups = num_groups
+
+    def fix_weight_quantization(self):
+        self.weight.data = self.weight_quantizer(self.weight, self.weight.target_bits, None, None,
+                                                 self.weight_quantize_num_groups).data
+        self.weight_quantization_enabled_in_forward = False
+        return None
+
+    def enable_activation_quantization(self, bits, quantization_type, range_calibration):
+        assert bits in [4, 8], 'Only 4/8 bits activation quantization are supported for now'
+        self.activation_quantization_bits = bits
+        self.activation_quantization_method = f"{quantization_type}_{range_calibration}"
+        if range_calibration == 'static':
+            self.activation_quantizer = QuantAct(quant_mode=quantization_type)
+        else:
+            if quantization_type == 'symmetric':
+                self.activation_quantizer = SymQuantizer.apply
+            else:
+                self.activation_quantizer = AsymQuantizer.apply
+
+    def head_pruning_reshape(self, w, mask):
+        shape = w.shape
+        return (w.t().reshape(self.num_heads, -1) * mask.view(-1, 1)).reshape(shape[1], shape[0]).t()
+
+    def forward(self, input, skip_bias_add=False):
+
+        if self.weight_quantization_enabled_in_forward and self.weight_quantization_enabled:
+            weight = self.weight_quantizer(self.weight, self.weight.target_bits, None, None,
+                                           self.weight_quantize_num_groups)
+            bias = self.bias
+        else:
+            weight = self.weight
+            bias = self.bias
+
+        if self.sparse_pruning_enabled and self.sparse_pruning_method:
+            mask = self.get_mask(pruning_type='sparse')
+            weight = weight * mask.view(self.weight.size())
+
+        if self.row_pruning_enabled and self.row_pruning_method:
+            mask = self.get_mask(pruning_type='row')
+            weight = weight * mask.view(-1, 1)
+            if bias is not None:
+                bias = bias * mask.view(-1)
+
+        if self.head_pruning_enabled and self.head_pruning_method:
+            mask = self.get_mask(pruning_type='head')
+            weight = self.head_pruning_reshape(weight, mask)
+
+        if self.activation_quantization_enabled:
+            if 'dynamic' in self.activation_quantization_method:
+                num_groups = input.numel() // input.size(-1)
+            else:
+                num_groups = 1
+            input = self.activation_quantizer(input, self.activation_quantization_bits, None, None, num_groups)
+
+        if skip_bias_add:
+            # used for mpu linear layers
+            output = nn.functional.linear(input, weight, None)
+            return output, bias
+        else:
+            output = nn.functional.linear(input, weight, bias)
+            return output
+
+
+class Conv2dLayer_Compress(nn.Conv2d):
+    """
+    Conv2D layer with compression.
+    """
+
+    def __init__(self, *kargs):
+        super(Conv2dLayer_Compress, self).__init__(*kargs)
+        self.sparse_pruning_method = None
+        self.channel_pruning_method = None
+        self.activation_quantization_method = None
+        self.weight.start_bits = None
+        self.weight.target_bits = None
+        self.weight.q_period = None
+        self.weight_quantization_enabled_in_forward = False
+        self.sparse_pruning_enabled = False
+        self.channel_pruning_enabled = False
+        self.activation_quantization_enabled = False
+
+    def __repr__(self):
+        s = ('{in_channels}, {out_channels}, kernel_size={kernel_size}'
+             ', stride={stride}')
+        if self.padding != (0, ) * len(self.padding):
+            s += ', padding={padding}'
+        if self.dilation != (1, ) * len(self.dilation):
+            s += ', dilation={dilation}'
+        if self.output_padding != (0, ) * len(self.output_padding):
+            s += ', output_padding={output_padding}'
+        if self.groups != 1:
+            s += ', groups={groups}'
+        if self.bias is None:
+            s += ', bias=False'
+        if self.padding_mode != 'zeros':
+            s += ', padding_mode={padding_mode}'
+        output = s.format(**self.__dict__)
+
+        return output + ' sparse pruning={}, channel pruning={}, activation quantization={}, weight_quantization={}'.format(
+            self.sparse_pruning_method is not None, self.channel_pruning_method is not None,
+            self.activation_quantization_method is not None, self.weight.target_bits)
+
+    def enable_sparse_pruning(self, ratio, method):
+        self.sparse_pruning_ratio = ratio
+        self.sparse_pruning_method = method
+        if method == 'l1':
+            weight_norm = torch.abs(self.weight.data)
+            mask = TopKBinarizer.apply(weight_norm, self.sparse_pruning_ratio, False)
+            mask = mask.view(self.weight.size())
+            mask = mask.to(self.weight.device)
+        elif method == 'topk':
+            self.sparse_mask_scores = nn.Parameter(torch.Tensor(self.weight.size()))
+            self.sparse_mask_scores.data = self.sparse_mask_scores.data.to(self.weight.device)
+            init.kaiming_uniform_(self.sparse_mask_scores, a=math.sqrt(5))
+            mask = None
+        else:
+            raise NotImplementedError
+
+        self.register_buffer('sparse_pruning_mask', mask)
+
+    def enable_channel_pruning(self, ratio, method):
+        # Here, we support two cases: L1 norm based pruning and topk based pruning
+        self.channel_pruning_ratio = ratio
+        self.channel_pruning_method = method
+
+        if method == 'l1':
+            # compute the l1 norm of each conv2d kernel (the last three dimension)
+            weight_norm = torch.linalg.norm(self.weight.data, ord=1, dim=[1, 2, 3])
+            mask = TopKBinarizer.apply(weight_norm, self.channel_pruning_ratio, False)
+            mask = mask.view(-1, 1, 1, 1)
+            mask = mask.to(self.weight.device)
+        elif method == 'topk':
+            self.channel_mask_scores = nn.Parameter(torch.Tensor(self.weight.size(0), 1, 1, 1))
+            self.channel_mask_scores.data = self.channel_mask_scores.data.to(self.weight.device)
+            init.kaiming_uniform_(self.channel_mask_scores, a=math.sqrt(5))
+            mask = None
+        else:
+            raise NotImplementedError
+
+        self.register_buffer('channel_pruning_mask', mask)
+
+    def fix_sparse_pruning_helper(self):
+        mask = self.get_mask(pruning_type='sparse')
+        self.weight.data = self.weight.data * mask
+        del self.sparse_pruning_mask
+        if self.sparse_pruning_method == 'topk':
+            del self.sparse_mask_scores
+        self.sparse_pruning_method = None
+        self.sparse_pruning_enabled = False
+        return None
+
+    def fix_channel_pruning_helper(self, mask=None, dim_reduction=False):
+        if mask is None:
+            if self.channel_pruning_method in ['l1', 'topk']:
+                mask = self.get_mask(pruning_type='channel').bool()
+                if dim_reduction:
+                    start_bits = self.weight.start_bits
+                    target_bits = self.weight.target_bits
+                    q_period = self.weight.q_period
+                    self.weight = nn.Parameter(self.weight.data[mask.view(-1), ...])
+                    self.weight.start_bits = start_bits
+                    self.weight.target_bits = target_bits
+                    self.weight.q_period = q_period
+                    if self.bias is not None:
+                        self.bias = nn.Parameter(self.bias.data[mask.view(-1)])
+                else:
+                    self.weight.data = self.weight.data * mask.view(-1, 1, 1, 1)
+                    if self.bias is not None:
+                        self.bias.data = self.bias.data * mask.view(-1)
+                del self.channel_pruning_mask
+                if self.channel_pruning_method == 'topk':
+                    del self.channel_mask_scores
+                self.channel_pruning_method = None
+            else:
+                raise NotImplementedError
+        else:
+            start_bits = self.weight.start_bits
+            target_bits = self.weight.target_bits
+            q_period = self.weight.q_period
+            self.weight = nn.Parameter(self.weight.data[:, mask.view(-1), ...])
+            self.weight.start_bits = start_bits
+            self.weight.target_bits = target_bits
+            self.weight.q_period = q_period
+            mask = None
+        self.channel_pruning_enabled = False
+        return mask
+
+    def get_mask(self, pruning_type='sparse'):
+        if pruning_type == 'sparse':
+            if self.sparse_pruning_method == 'l1':
+                return self.sparse_pruning_mask.to(self.weight.device)
+            elif self.sparse_pruning_method == 'topk':
+                return TopKBinarizer.apply(self.sparse_mask_scores, self.sparse_pruning_ratio, False)
+            else:
+                raise NotImplementedError
+        elif pruning_type == 'channel':
+            if self.channel_pruning_method == 'l1':
+                return self.channel_pruning_mask.to(self.weight.device)
+            elif self.channel_pruning_method == 'topk':
+                return TopKBinarizer.apply(self.channel_mask_scores, self.channel_pruning_ratio, False)
+            else:
+                raise NotImplementedError
+        else:
+            raise NotImplementedError
+
+    def fix_weight_quantization(self):
+        self.weight.data = self.weight_quantizer(self.weight, self.weight.target_bits, None, None,
+                                                 self.weight_quantize_num_groups).data
+        self.weight_quantization_enabled_in_forward = False
+        return None
+
+    def enable_weight_quantization(self, start_bits, target_bits, quantization_period,
+                                   weight_quantization_enabled_in_forward, quantization_type, num_groups):
+        self.weight.start_bits = start_bits
+        self.weight.target_bits = target_bits
+        self.weight.q_period = quantization_period
+        self.weight_quantization_enabled_in_forward = weight_quantization_enabled_in_forward
+        if self.weight_quantization_enabled_in_forward:
+            assert self.weight.target_bits >= 4, 'Only >=4 bits weight quantization are supported during forward pass for now'
+            logger.warning(
+                "************ A lot of MoQ features are not supported in quantize_weight_in_forward mode, please consider to use DS-FP16 optimizer************"
+            )
+            if quantization_type == 'symmetric':
+                self.weight_quantizer = SymQuantizer.apply
+            else:
+                self.weight_quantizer = AsymQuantizer.apply
+            self.weight_quantize_num_groups = num_groups
+
+    def enable_activation_quantization(self, bits, quantization_type, range_calibration):
+        assert bits in [4, 8], 'Only 4/8 bits activation quantization are supported for now'
+        self.activation_quantization_bits = bits
+        self.activation_quantization_method = f"{quantization_type}_{range_calibration}"
+        if range_calibration == 'static':
+            self.activation_quantizer = QuantAct(quant_mode=quantization_type)
+        else:
+            if quantization_type == 'symmetric':
+                self.activation_quantizer = SymQuantizer.apply
+            else:
+                self.activation_quantizer = AsymQuantizer.apply
+
+    def forward(self, input):
+
+        if self.weight_quantization_enabled_in_forward and self.weight_quantization_enabled:
+            weight = self.weight_quantizer(self.weight, self.weight.target_bits, None, None,
+                                           self.weight_quantize_num_groups)
+            bias = self.bias
+        else:
+            weight = self.weight
+            bias = self.bias
+
+        if self.sparse_pruning_enabled and self.sparse_pruning_method:
+            mask = self.get_mask(pruning_type='sparse')
+            weight = weight * mask.view(self.weight.size())
+
+        if self.channel_pruning_enabled:
+            mask = self.get_mask(pruning_type='channel')
+            weight = weight * mask.view(-1, 1, 1, 1)
+            if bias is not None:
+                bias = bias * mask.view(-1)
+
+        if self.activation_quantization_enabled:
+            if 'dynamic' in self.activation_quantization_method:
+                num_groups = input.numel() // input[0].numel()
+            else:
+                num_groups = 1
+            input = self.activation_quantizer(input, self.activation_quantization_bits, None, None, num_groups)
+
+        return nn.functional.conv2d(input, weight, bias, self.stride, self.padding, self.dilation, self.groups)
+
+
+class BNLayer_Compress(nn.BatchNorm2d):
+
+    def fix_channel_pruning_helper(self, mask, dim_reduction=True):
+        self.weight = nn.Parameter(self.weight.data[mask.view(-1)])
+        self.bias = nn.Parameter(self.bias.data[mask.view(-1)])
+        self.running_mean = self.running_mean[mask.view(-1)]
+        self.running_var = self.running_var[mask.view(-1)]
+
+
+def _reduce(input_):
+    """All-reduce the input tensor across model parallel group."""
+    group = g_mpu.get_model_parallel_group()
+
+    # Bypass the function if we are using only 1 GPU.
+    if dist.get_world_size(group=group) == 1:
+        return input_
+
+    # All-reduce.
+    dist.all_reduce(input_, group=group)
+
+    return input_
+
+
+def split_tensor_along_last_dim(tensor, num_partitions, contiguous_split_chunks=False):
+    """Split a tensor along its last dimension.
+    Arguments:
+        tensor: input tensor.
+        num_partitions: number of partitions to split the tensor
+        contiguous_split_chunks: If True, make each chunk contiguous
+                                 in memory.
+    """
+    # Get the size and dimension.
+    last_dim = tensor.dim() - 1
+    assert tensor.size()[last_dim] % num_partitions == 0
+    last_dim_size = tensor.size()[last_dim] // num_partitions
+    # Split.
+    tensor_list = torch.split(tensor, last_dim_size, dim=last_dim)
+    # Note: torch.split does not create contiguous tensors by default.
+    if contiguous_split_chunks:
+        return tuple(chunk.contiguous() for chunk in tensor_list)
+
+    return tensor_list
+
+
+def _split(input_):
+    """Split the tensor along its last dimension and keep the
+    corresponding slice."""
+    group = g_mpu.get_model_parallel_group()
+
+    # Bypass the function if we are using only 1 GPU.
+    if dist.get_world_size(group=group) == 1:
+        return input_
+
+    # Split along last dimension.
+    world_size = dist.get_world_size(group=group)
+    input_list = split_tensor_along_last_dim(input_, world_size)
+
+    # Note: torch.split does not create contiguous tensors by default.
+    rank = dist.get_rank(group=group)
+    output = input_list[rank].contiguous()
+
+    return output
+
+
+def _gather(input_):
+    """Gather tensors and concatenate along the last dimension."""
+    group = g_mpu.get_model_parallel_group()
+
+    # Bypass the function if we are using only 1 GPU.
+    if dist.get_world_size(group=group) == 1:
+        return input_
+
+    # Size and dimension.
+    last_dim = input_.dim() - 1
+    rank = dist.get_rank(group=group)
+    world_size = dist.get_world_size(group=group)
+
+    tensor_list = [torch.empty_like(input_) for _ in range(world_size)]
+    tensor_list[rank] = input_
+    dist.all_gather(tensor_list, input_, group=group)
+
+    # Note: torch.cat already creates a contiguous tensor.
+    output = torch.cat(tensor_list, dim=last_dim).contiguous()
+
+    return output
+
+
+class _CopyToModelParallelRegion(torch.autograd.Function):
+    """Pass the input to the model parallel region."""
+
+    @staticmethod
+    def forward(ctx, input_):
+        return input_
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return _reduce(grad_output)
+
+
+class _ReduceFromModelParallelRegion(torch.autograd.Function):
+    """All-reduce the input from the model parallel region."""
+
+    @staticmethod
+    def forward(ctx, input_):
+        return _reduce(input_)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return grad_output
+
+
+class _ScatterToModelParallelRegion(torch.autograd.Function):
+    """Split the input and keep only the corresponding chuck to the rank."""
+
+    @staticmethod
+    def forward(ctx, input_):
+        return _split(input_)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return _gather(grad_output)
+
+
+class _GatherFromModelParallelRegion(torch.autograd.Function):
+    """Gather the input from model parallel region and concatenate."""
+
+    @staticmethod
+    def forward(ctx, input_):
+        return _gather(input_)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return _split(grad_output)
+
+
+# -----------------
+# Helper functions.
+# -----------------
+
+
+def copy_to_model_parallel_region(input_):
+    return _CopyToModelParallelRegion.apply(input_)
+
+
+def reduce_from_model_parallel_region(input_):
+    return _ReduceFromModelParallelRegion.apply(input_)
+
+
+def scatter_to_model_parallel_region(input_):
+    return _ScatterToModelParallelRegion.apply(input_)
+
+
+def gather_from_model_parallel_region(input_):
+    return _GatherFromModelParallelRegion.apply(input_)
+
+
+class ColumnParallelLinear_Compress(LinearLayer_Compress):
+
+    def __init__(self, mpu, input_size, output_size, bias=True, gather_output=True, skip_bias_add=False):
+        # Keep input parameters
+        global g_mpu
+        g_mpu = mpu
+        self.input_size = input_size
+        self.output_size = output_size
+        self.gather_output = gather_output
+        self.skip_bias_add = skip_bias_add
+
+        # Divide the weight matrix along the last dimension.
+        world_size = mpu.get_model_parallel_world_size()
+        assert output_size % world_size == 0
+        self.output_size_per_partition = output_size // world_size
+
+        super(ColumnParallelLinear_Compress, self).__init__(self.input_size, self.output_size_per_partition, bias=bias)
+
+    def forward(self, input_):
+        # Set up backprop all-reduce.
+        input_parallel = copy_to_model_parallel_region(input_)
+        # Matrix multiply.
+        if self.skip_bias_add:
+            output_parallel, bias = super().forward(input_parallel, True)
+        else:
+            output_parallel = super().forward(input_parallel)
+            bias = None
+        if self.gather_output:
+            # All-gather across the partitions.
+            output = gather_from_model_parallel_region(output_parallel)
+        else:
+            output = output_parallel
+        return output, bias
+
+
+class RowParallelLinear_Compress(LinearLayer_Compress):
+
+    def __init__(self, mpu, input_size, output_size, bias=True, input_is_parallel=False, skip_bias_add=False):
+        # Keep input parameters
+        global g_mpu
+        g_mpu = mpu
+        self.input_size = input_size
+        self.output_size = output_size
+        self.input_is_parallel = input_is_parallel
+        self.skip_bias_add = skip_bias_add
+
+        # Divide the weight matrix along the last dimension.
+        world_size = mpu.get_model_parallel_world_size()
+        assert input_size % world_size == 0
+        self.input_size_per_partition = input_size // world_size
+
+        super(RowParallelLinear_Compress, self).__init__(self.input_size_per_partition, self.output_size, bias=bias)
+
+    def forward(self, input_):
+        # Set up backprop all-reduce.
+        if self.input_is_parallel:
+            input_parallel = input_
+        else:
+            input_parallel = scatter_to_model_parallel_region(input_)
+        # Matrix multiply.
+        output_parallel, bias = super().forward(input_parallel, True)
+
+        # All-reduce across all the partitions.
+        output_ = reduce_from_model_parallel_region(output_parallel)
+        if not self.skip_bias_add:
+            if bias is not None:
+                output = output_ + bias
+            else:
+                output = output_
+            output_bias = None
+        else:
+            output = output_
+            output_bias = bias
+        return output, output_bias

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/compression/compress.py

@@ -0,0 +1,239 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import re
+from .helper import compression_preparation, fix_compression, recursive_getattr, is_module_compressible
+from .config import get_compression_config
+from ..runtime.config_utils import dict_raise_error_on_duplicate_keys
+from .constants import *
+import os
+import json
+
+try:
+    import neural_compressor as nc
+except ImportError as e:
+    nc = None
+
+
+def check_deepspeed_config(config):
+    if isinstance(config, dict):
+        return config
+    elif os.path.exists(config):
+        return json.load(open(config, "r"), object_pairs_hook=dict_raise_error_on_duplicate_keys)
+    else:
+        raise ValueError(
+            f"Expected a string path to an existing deepspeed config, or a dictionary. Received: {config}")
+
+
+def get_module_name(group_name, model, key_word, exist_module_name, mpu=None, verbose=True):
+    '''
+    get the associated module name from the model based on the key_word provided by users
+    '''
+    return_module_name = []
+    for name, module in model.named_modules():
+
+        module_check = is_module_compressible(module, mpu)
+
+        if re.search(key_word, name) is not None and module_check:
+            if name in exist_module_name and verbose:
+                # logger.warning
+                raise ValueError(
+                    f"{name} is already added to compression, please check your config file for {group_name}.")
+            if name not in exist_module_name:
+                exist_module_name.add(name)
+                return_module_name.append(name)
+    return return_module_name, exist_module_name
+
+
+def get_compress_methods(model, compress_methods, mpu=None):
+    # extract the compression module for each method in compress_methods
+    layer_added_compress_methods = []
+    for method, method_content in compress_methods.items():
+        if LAYER_REDUCTION in method:
+            continue
+        # for loop different methods, i.e., weight quantization, activation quantization etc
+        exist_module_name = set()
+        shared_parameters = method_content[SHARED_PARAMETERS]  # get all the shared parameters
+        for group_name, method_parameters in method_content[DIFFERENT_GROUPS].items():
+            # for loop different groups, i.e., weight quantization group 1, weight quantization group 2 etc
+            module_name_list = []
+            related_module_name_list = []
+            if method_parameters[DIFFERENT_GROUPS_RELATED_MODULE_SCOPE]:
+                # this is used for head/row/channel pruning, if users provide the related module scope, we can shrink the layer dim for them
+                # otherwise we just mask those as zeros
+                for key_word, related_key_words in zip(method_parameters[DIFFERENT_GROUPS_MODULE_SCOPE],
+                                                       method_parameters[DIFFERENT_GROUPS_RELATED_MODULE_SCOPE]):
+                    module_name, exist_module_name = get_module_name(group_name,
+                                                                     model,
+                                                                     key_word,
+                                                                     exist_module_name,
+                                                                     mpu=mpu)
+                    module_name_list.append(module_name)
+                    tmp_related_module_name_list = []
+                    for rkw in related_key_words:
+                        # related key word can be a list, for instance the QKV for O matrix in Attention
+                        module_name, _ = get_module_name(group_name, model, rkw, set(), mpu=mpu)
+                        tmp_related_module_name_list.append(module_name)
+                    related_module_name_list.append(tmp_related_module_name_list)
+            else:
+                for key_word in method_parameters[DIFFERENT_GROUPS_MODULE_SCOPE]:
+                    module_name, exist_module_name = get_module_name(group_name,
+                                                                     model,
+                                                                     key_word,
+                                                                     exist_module_name,
+                                                                     mpu=mpu)
+                    module_name_list.append(module_name)
+
+            if module_name_list:
+                # combine shared parameters with each group
+                combined_method_parameters = {
+                    **(method_parameters.copy().pop(DIFFERENT_GROUPS_PARAMETERS)),
+                    **shared_parameters
+                }
+                compression_item = [module_name_list, related_module_name_list, {method: combined_method_parameters}]
+                layer_added_compress_methods.append(compression_item)
+    return layer_added_compress_methods
+
+
+def init_compression(model, deepspeed_config, teacher_model=None, mpu=None):
+    """
+    Compress a model: replace linear/conv2d layer with deepspeed compression-aware modules
+    Args:
+        model (`torch.nn.Module`)
+            The model to compress.
+        deepspeed_config (`DeepSpeedConfig`)
+            The path of ds_config
+        mpu
+            The mpu module for Row/Column parallelism
+    """
+    compress_methods = get_compression_config(check_deepspeed_config(deepspeed_config))
+    if hasattr(model, 'module'):
+        c_model = model.module
+    else:
+        c_model = model
+
+    # For layer reduction
+    if compress_methods[LAYER_REDUCTION][LAYER_REDUCTION_ENABLED]:
+        assert teacher_model is not None, "Teacher model is required for layer reduction"
+        student_initialization(c_model, teacher_model, deepspeed_config)
+
+    layer_added_compress_methods = get_compress_methods(c_model, compress_methods, mpu=mpu)
+    compression_preparation(c_model, layer_added_compress_methods, mpu)
+
+    # For sparse pruning snip_momentum method
+    shared_parameters = compress_methods[SPARSE_PRUNING][SHARED_PARAMETERS]
+    if shared_parameters[SPARSE_PRUNING_ENABLED] and \
+        shared_parameters[SPARSE_PRUNING_METHOD] == SPARSE_PRUNING_METHOD_SNIP_MOMENTUM:
+
+        assert nc is not None, "please ensure the neural_compressor python package is installed by pip or conda if user wants to use snip_momentum sparse pruning"
+
+        from .helper import generate_pruners, register_on_step_begin
+        from nc import WeightPruningConfig
+
+        config = WeightPruningConfig(target_sparsity=1 - shared_parameters[SPARSE_PRUNING_DENSE_RATIO],
+                                     pattern=shared_parameters[SPARSE_PRUNING_BLOCK_PATTERN],
+                                     pruning_frequency=shared_parameters[SPARSE_PRUNING_SCHEDULE_OFFSET_STRIDE],
+                                     start_step=shared_parameters[SPARSE_PRUNING_SCHEDULE_OFFSET],
+                                     end_step=shared_parameters[SPARSE_PRUNING_SCHEDULE_OFFSET_END],
+                                     excluded_op_names=shared_parameters[SPARSE_PRUNING_EXCLUDED_MODULES])
+        pruners = generate_pruners(config, c_model)
+        c_model.pruners = pruners
+        register_on_step_begin(c_model)
+
+    return model
+
+
+def redundancy_clean(model, deepspeed_config, mpu=None):
+    """
+    Remove the redundancy of a model
+    Args:
+        model (`torch.nn.Module`)
+            The model to compress.
+        deepspeed_config (`DeepSpeedConfig`)
+            The path of ds_config
+        mpu
+            The mpu module for Row/Column parallelism
+    """
+    compress_methods = get_compression_config(check_deepspeed_config(deepspeed_config))
+    if hasattr(model, 'module'):
+        c_model = model.module
+    else:
+        c_model = model
+
+    layer_added_compress_methods_tmp = get_compress_methods(c_model, compress_methods, mpu=mpu)
+    # sort methods
+    order_list = [
+        WEIGHT_QUANTIZATION, SPARSE_PRUNING, ROW_PRUNING, HEAD_PRUNING, CHANNEL_PRUNING, ACTIVATION_QUANTIZATION
+    ]
+    layer_added_compress_methods = sorted(layer_added_compress_methods_tmp,
+                                          key=lambda x: order_list.index(list(x[2].keys())[0]))
+
+    for module_name_lists, related_module_name_lists, compression_technique in layer_added_compress_methods:
+        stored_mask = []
+        need_mask = True if related_module_name_lists else False
+        for i, mnl in enumerate(module_name_lists):
+            for module_name in mnl:
+                mask = fix_compression(c_model, module_name, compression_technique, dim_reduction=need_mask)
+                if need_mask:
+                    stored_mask.append(mask)
+            if need_mask:
+                for rmnl in related_module_name_lists[i]:
+                    for j, module_name in enumerate(rmnl):
+                        mask = fix_compression(c_model,
+                                               module_name,
+                                               compression_technique,
+                                               mask=stored_mask[j],
+                                               dim_reduction=True)
+    return model
+
+
+def student_initialization(student_model, teacher_model, deepspeed_config):
+    '''
+    Given a student model and a teacher model, select the
+    Args:
+        student_model (`torch.nn.Module`)
+            The model we will update weight
+        teacher_model (`torch.nn.Module`)
+            The model guide the student to learn
+        deepspeed_config (`DeepSpeedConfig`)
+            The path of ds_config
+    '''
+    config = get_compression_config(check_deepspeed_config(deepspeed_config))
+    compress_methods = config[LAYER_REDUCTION]
+
+    module_name_prefix = compress_methods[MODULE_NAME_PREFIX]
+    teacher_layer = compress_methods[TEACHER_LAYER]
+    student_layer = [i for i in range(len(teacher_layer))]
+    other_module_name = compress_methods[OTHER_MODULE_NAME]
+    '''
+        name_prefix (`str`)
+            The prefix name before the layer #.
+            Example 1: bert.encoder.layer, for BERT_base model's prefix name
+            Example 2: transformer.h, for GPT-2 hugging face prefix name
+        teacher_layer (`list of integers`)
+            The layer of teacher will be used for student's reinitialization
+            Example 1: [1,3,5,7,9], means we want to matches the 2nd/4th/6th/8th/10th layer of teacher to the first 5 layers of student
+        student_layer (`list` or None)
+            The layer of student need to be re-initialized
+            Example 1: None, means we want to reinitialize all the layers
+            Example 1: [0,1,2,3,4], means  we want to reinitialize the first 5 layers
+        other_module_name (`list of string`)
+            The modules will be used for student's reinitialization
+            Example 1: ['bert.pooler', 'bert.embeddings', 'classifier'], means we want to apply the weight in teacher's embedding/pooler/classier module to the student
+            Example 2: ['transformer.w', 'transformer.ln_f', 'lm_head'], means we want to apply the weight in teacher's embedding layers module to the student
+    Note that teacher_layer should matches student layer
+    '''
+    assert len(student_layer) == len(teacher_layer)
+    for s_name, t_name in zip(student_layer, teacher_layer):
+        s_module = recursive_getattr(student_model, module_name_prefix + '.' + str(s_name))
+        t_module = recursive_getattr(teacher_model, module_name_prefix + '.' + str(t_name))
+        for s_param, t_param in zip(s_module.parameters(), t_module.parameters()):
+            s_param.data.copy_(t_param.data)
+    for name in other_module_name:
+        s_module = recursive_getattr(student_model, name)
+        t_module = recursive_getattr(teacher_model, name)
+        print(name)
+        for s_param, t_param in zip(s_module.parameters(), t_module.parameters()):
+            s_param.data.copy_(t_param.data)

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/compression/config.py

@@ -0,0 +1,452 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .constants import *
+import copy
+from ..runtime.config_utils import get_scalar_param, get_list_param
+
+
+def get_compression_config(param_dict):
+    #
+    output = {}
+
+    if COMPRESSION_TRAINING not in param_dict.keys():
+        param_dict[COMPRESSION_TRAINING] = {}
+    sub_param_dict = param_dict[COMPRESSION_TRAINING]
+    output[WEIGHT_QUANTIZATION] = get_weight_quantization(sub_param_dict)
+    output[ACTIVATION_QUANTIZATION] = get_activation_quantization(sub_param_dict)
+    output[SPARSE_PRUNING] = get_sparse_pruning(sub_param_dict)
+    output[ROW_PRUNING] = get_row_pruning(sub_param_dict)
+    output[HEAD_PRUNING] = get_head_pruning(sub_param_dict)
+    output[CHANNEL_PRUNING] = get_channel_pruning(sub_param_dict)
+
+    output[LAYER_REDUCTION] = get_layer_reduction(sub_param_dict)
+
+    return output
+
+
+def get_layer_reduction(param_dict):
+    output = {}
+    output[LAYER_REDUCTION_ENABLED] = LAYER_REDUCTION_ENABLED_DEFAULT
+    if get_layer_reduction_enabled(param_dict):
+        output[LAYER_REDUCTION_ENABLED] = get_layer_reduction_enabled(param_dict)
+        for key, val in get_layer_reduction_params(param_dict).items():
+            output[key] = val
+    return output
+
+
+def get_layer_reduction_enabled(param_dict):
+    if LAYER_REDUCTION in param_dict.keys():
+        return get_scalar_param(param_dict[LAYER_REDUCTION], LAYER_REDUCTION_ENABLED, LAYER_REDUCTION_ENABLED_DEFAULT)
+    else:
+        return False
+
+
+def get_layer_reduction_params(param_dict):
+    if LAYER_REDUCTION in param_dict.keys():
+        layer_reduction_params = copy.copy(param_dict[LAYER_REDUCTION])
+        layer_reduction_params.pop(LAYER_REDUCTION_ENABLED)
+        return layer_reduction_params
+    else:
+        return False
+
+
+def get_quantize_enabled(param_dict):
+    if COMPRESSION_TRAINING not in param_dict.keys():
+        return False
+
+    sub_param_dict = param_dict[COMPRESSION_TRAINING]
+    output = get_weight_quantization_shared_parameters(sub_param_dict)
+    return output[WEIGHT_QUANTIZE_ENABLED]
+
+
+def get_weight_quantization(param_dict):
+    output = {}
+    if WEIGHT_QUANTIZATION not in param_dict.keys():
+        param_dict[WEIGHT_QUANTIZATION] = {SHARED_PARAMETERS: {}, DIFFERENT_GROUPS: {}}
+    sub_param_dict = param_dict[WEIGHT_QUANTIZATION]
+    # shared parameters
+    output[SHARED_PARAMETERS] = get_weight_quantization_shared_parameters(sub_param_dict)
+    # each sub-groups
+    if output[SHARED_PARAMETERS][WEIGHT_QUANTIZE_ENABLED]:
+        assert DIFFERENT_GROUPS in sub_param_dict.keys(
+        ), f"Weigh Quantization is enabled, {DIFFERENT_GROUPS} must be specified"
+    output[DIFFERENT_GROUPS] = get_weight_quantization_different_groups(sub_param_dict)
+    return output
+
+
+def get_weight_quantization_shared_parameters(param_dict):
+    output = {}
+    if SHARED_PARAMETERS in param_dict.keys():
+        sub_param_dict = param_dict[SHARED_PARAMETERS]
+        output[WEIGHT_QUANTIZE_ENABLED] = get_scalar_param(sub_param_dict, WEIGHT_QUANTIZE_ENABLED,
+                                                           WEIGHT_QUANTIZE_ENABLED_DEFAULT)
+        output[WEIGHT_QUANTIZE_KERNEL] = get_scalar_param(sub_param_dict, WEIGHT_QUANTIZE_KERNEL,
+                                                          WEIGHT_QUANTIZE_KERNEL_DEFAULT)
+        output[WEIGHT_QUANTIZE_SCHEDULE_OFFSET] = get_scalar_param(sub_param_dict, WEIGHT_QUANTIZE_SCHEDULE_OFFSET,
+                                                                   WEIGHT_QUANTIZE_SCHEDULE_OFFSET_DEFAULT)
+        output[WEIGHT_QUANTIZE_GROUPS] = get_scalar_param(sub_param_dict, WEIGHT_QUANTIZE_GROUPS,
+                                                          WEIGHT_QUANTIZE_GROUPS_DEFAULT)
+        output[WEIGHT_QUANTIZE_VERBOSE] = get_scalar_param(sub_param_dict, WEIGHT_QUANTIZE_VERBOSE,
+                                                           WEIGHT_QUANTIZE_VERBOSE_DEFAULT)
+        output[WEIGHT_QUANTIZE_TYPE] = get_scalar_param(sub_param_dict, WEIGHT_QUANTIZE_TYPE,
+                                                        WEIGHT_QUANTIZE_TYPE_DEFAULT)
+        output[WEIGHT_QUANTIZE_IN_FORWARD_ENABLED] = get_scalar_param(sub_param_dict,
+                                                                      WEIGHT_QUANTIZE_IN_FORWARD_ENABLED,
+                                                                      WEIGHT_QUANTIZE_IN_FORWARD_ENABLED_DEFAULT)
+        assert output[WEIGHT_QUANTIZE_TYPE] in [
+            WEIGHT_QUANTIZE_SYMMETRIC, WEIGHT_QUANTIZE_ASYMMETRIC
+        ], f"Invalid weight quantize type. Supported types: [{WEIGHT_QUANTIZE_SYMMETRIC}, {WEIGHT_QUANTIZE_ASYMMETRIC}]"
+        output[WEIGHT_QUANTIZE_ROUNDING] = get_scalar_param(sub_param_dict, WEIGHT_QUANTIZE_ROUNDING,
+                                                            WEIGHT_QUANTIZE_ROUNDING_DEFAULT)
+        assert output[WEIGHT_QUANTIZE_ROUNDING] in [
+            WEIGHT_QUANTIZE_NEAREST_ROUNDING, WEIGHT_QUANTIZE_STOCHASTIC_ROUNDING
+        ], f"Invalid weight quantize rounding. Supported types: [{WEIGHT_QUANTIZE_NEAREST_ROUNDING}, {WEIGHT_QUANTIZE_STOCHASTIC_ROUNDING}]"
+        if WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE in sub_param_dict.keys():
+            output[WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE] = get_scalar_param(
+                sub_param_dict[WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE], WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE_ENABLED,
+                WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE_ENABLED_DEFAULT)
+            output[WEIGHT_QUANTIZE_CHANGE_RATIO] = get_scalar_param(
+                sub_param_dict[WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE], WEIGHT_QUANTIZE_CHANGE_RATIO,
+                WEIGHT_QUANTIZE_CHANGE_RATIO_DEFAULT)
+        else:
+            output[WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE] = WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE_ENABLED_DEFAULT
+            output[WEIGHT_QUANTIZE_CHANGE_RATIO] = WEIGHT_QUANTIZE_CHANGE_RATIO_DEFAULT
+    else:
+        output[WEIGHT_QUANTIZE_ENABLED] = WEIGHT_QUANTIZE_ENABLED_DEFAULT
+        output[WEIGHT_QUANTIZE_KERNEL] = WEIGHT_QUANTIZE_KERNEL_DEFAULT
+        output[WEIGHT_QUANTIZE_SCHEDULE_OFFSET] = WEIGHT_QUANTIZE_SCHEDULE_OFFSET_DEFAULT
+        output[WEIGHT_QUANTIZE_GROUPS] = WEIGHT_QUANTIZE_GROUPS_DEFAULT
+        output[WEIGHT_QUANTIZE_VERBOSE] = WEIGHT_QUANTIZE_VERBOSE_DEFAULT
+        output[WEIGHT_QUANTIZE_TYPE] = WEIGHT_QUANTIZE_TYPE_DEFAULT
+        output[WEIGHT_QUANTIZE_ROUNDING] = WEIGHT_QUANTIZE_ROUNDING_DEFAULT
+        output[WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE] = WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE_ENABLED_DEFAULT
+        output[WEIGHT_QUANTIZE_CHANGE_RATIO] = WEIGHT_QUANTIZE_CHANGE_RATIO_DEFAULT
+    return output
+
+
+def get_weight_quantization_different_groups(param_dict):
+    output = {}
+    sub_param_dict = param_dict[DIFFERENT_GROUPS]
+
+    def get_params(name, group_dict):
+        assert WEIGHT_QUANTIZE_START_BITS in group_dict.keys(
+        ), f"{WEIGHT_QUANTIZE_START_BITS} must be specified for weight quantization group {name}"
+        assert WEIGHT_QUANTIZE_TARGET_BITS in group_dict.keys(
+        ), f"{WEIGHT_QUANTIZE_TARGET_BITS} must be specified for weight quantization group {name}"
+        group_dict[WEIGHT_QUANTIZATION_PERIOD] = get_scalar_param(group_dict, WEIGHT_QUANTIZATION_PERIOD,
+                                                                  WEIGHT_QUANTIZATION_PERIOD_DEFAULT)
+        return group_dict
+
+    for k, v in sub_param_dict.items():
+        output[k] = {}
+        output[k][DIFFERENT_GROUPS_PARAMETERS] = get_params(k, sub_param_dict[k][DIFFERENT_GROUPS_PARAMETERS])
+        output[k][DIFFERENT_GROUPS_MODULE_SCOPE] = get_scalar_param(sub_param_dict[k], DIFFERENT_GROUPS_MODULE_SCOPE,
+                                                                    DIFFERENT_GROUPS_MODULE_SCOPE_DEFAULT)
+        output[k][DIFFERENT_GROUPS_RELATED_MODULE_SCOPE] = get_scalar_param(
+            sub_param_dict[k], DIFFERENT_GROUPS_RELATED_MODULE_SCOPE, DIFFERENT_GROUPS_RELATED_MODULE_SCOPE_DEFAULT)
+
+    return output
+
+
+def get_activation_quantization(param_dict):
+    output = {}
+    if ACTIVATION_QUANTIZATION not in param_dict.keys():
+        param_dict[ACTIVATION_QUANTIZATION] = {SHARED_PARAMETERS: {}, DIFFERENT_GROUPS: {}}
+    sub_param_dict = param_dict[ACTIVATION_QUANTIZATION]
+    # shared parameters
+    output[SHARED_PARAMETERS] = get_activation_quantization_shared_parameters(sub_param_dict)
+    # each sub-groups
+    if output[SHARED_PARAMETERS][ACTIVATION_QUANTIZATION_ENABLED]:
+        assert DIFFERENT_GROUPS in sub_param_dict.keys(
+        ), f"Activation Quantization is enabled, {DIFFERENT_GROUPS} must be specified"
+    output[DIFFERENT_GROUPS] = get_activation_quantization_different_groups(sub_param_dict)
+    return output
+
+
+def get_activation_quantization_shared_parameters(param_dict):
+    output = {}
+    if SHARED_PARAMETERS in param_dict.keys():
+        sub_param_dict = param_dict[SHARED_PARAMETERS]
+        output[ACTIVATION_QUANTIZATION_ENABLED] = get_scalar_param(sub_param_dict, ACTIVATION_QUANTIZATION_ENABLED,
+                                                                   ACTIVATION_QUANTIZATION_ENABLED_DEFAULT)
+        output[ACTIVATION_QUANTIZE_TYPE] = get_scalar_param(sub_param_dict, ACTIVATION_QUANTIZE_TYPE,
+                                                            ACTIVATION_QUANTIZE_TYPE_DEFAULT)
+        assert output[ACTIVATION_QUANTIZE_TYPE] in [
+            ACTIVATION_QUANTIZE_SYMMETRIC, ACTIVATION_QUANTIZE_ASYMMETRIC
+        ], f"Invalid activation quantize type. Supported types: [{ACTIVATION_QUANTIZE_SYMMETRIC}, {ACTIVATION_QUANTIZE_ASYMMETRIC}]"
+        output[ACTIVATION_QUANTIZE_RANGE] = get_scalar_param(sub_param_dict, ACTIVATION_QUANTIZE_RANGE,
+                                                             ACTIVATION_QUANTIZE_RANGE_DEFAULT)
+        assert output[ACTIVATION_QUANTIZE_RANGE] in [
+            ACTIVATION_QUANTIZE_RANGE_DYNAMIC, ACTIVATION_QUANTIZE_RANGE_STATIC
+        ], f"Invalid activation quantize range calibration. Supported types: [{ACTIVATION_QUANTIZE_RANGE_DYNAMIC}, {ACTIVATION_QUANTIZE_RANGE_STATIC}]"
+        output[ACTIVATION_QUANTIZE_SCHEDULE_OFFSET] = get_scalar_param(sub_param_dict,
+                                                                       ACTIVATION_QUANTIZE_SCHEDULE_OFFSET,
+                                                                       ACTIVATION_QUANTIZE_SCHEDULE_OFFSET_DEFAULT)
+    else:
+        output[ACTIVATION_QUANTIZATION_ENABLED] = ACTIVATION_QUANTIZATION_ENABLED_DEFAULT
+        output[ACTIVATION_QUANTIZE_TYPE] = ACTIVATION_QUANTIZE_TYPE_DEFAULT
+        output[ACTIVATION_QUANTIZE_RANGE] = ACTIVATION_QUANTIZE_RANGE_DEFAULT
+        output[ACTIVATION_QUANTIZE_SCHEDULE_OFFSET] = ACTIVATION_QUANTIZE_SCHEDULE_OFFSET_DEFAULT
+    return output
+
+
+def get_activation_quantization_different_groups(param_dict):
+    output = {}
+    sub_param_dict = param_dict[DIFFERENT_GROUPS]
+
+    def get_params(name, group_dict):
+        assert ACTIVATION_QUANTIZE_BITS in group_dict.keys(
+        ), f"{ACTIVATION_QUANTIZE_BITS} must be specified for activation quantization group {name}"
+        return group_dict
+
+    for k, v in sub_param_dict.items():
+        output[k] = {}
+        output[k][DIFFERENT_GROUPS_PARAMETERS] = get_params(k, sub_param_dict[k][DIFFERENT_GROUPS_PARAMETERS])
+        output[k][DIFFERENT_GROUPS_MODULE_SCOPE] = get_scalar_param(sub_param_dict[k], DIFFERENT_GROUPS_MODULE_SCOPE,
+                                                                    DIFFERENT_GROUPS_MODULE_SCOPE_DEFAULT)
+        output[k][DIFFERENT_GROUPS_RELATED_MODULE_SCOPE] = get_scalar_param(
+            sub_param_dict[k], DIFFERENT_GROUPS_RELATED_MODULE_SCOPE, DIFFERENT_GROUPS_RELATED_MODULE_SCOPE_DEFAULT)
+
+    return output
+
+
+def get_sparse_pruning(param_dict):
+    output = {}
+    if SPARSE_PRUNING not in param_dict.keys():
+        param_dict[SPARSE_PRUNING] = {SHARED_PARAMETERS: {}, DIFFERENT_GROUPS: {}}
+    sub_param_dict = param_dict[SPARSE_PRUNING]
+    # shared parameters
+    output[SHARED_PARAMETERS] = get_sparse_pruning_shared_parameters(sub_param_dict)
+    # each sub-groups
+    if output[SHARED_PARAMETERS][SPARSE_PRUNING_ENABLED] and output[SHARED_PARAMETERS][
+            SPARSE_PRUNING_METHOD] != SPARSE_PRUNING_METHOD_SNIP_MOMENTUM:
+        assert DIFFERENT_GROUPS in sub_param_dict.keys(
+        ), f"Sparse Pruning is enabled and not snip_momentum method, {DIFFERENT_GROUPS} must be specified"
+    output[DIFFERENT_GROUPS] = get_sparse_pruning_different_groups(sub_param_dict)
+    return output
+
+
+def get_sparse_pruning_shared_parameters(param_dict):
+    output = {}
+
+    if SHARED_PARAMETERS in param_dict.keys():
+        sub_param_dict = param_dict[SHARED_PARAMETERS]
+        output[SPARSE_PRUNING_ENABLED] = get_scalar_param(sub_param_dict, SPARSE_PRUNING_ENABLED,
+                                                          SPARSE_PRUNING_ENABLED_DEFAULT)
+        output[SPARSE_PRUNING_METHOD] = get_scalar_param(sub_param_dict, SPARSE_PRUNING_METHOD,
+                                                         SPARSE_PRUNING_METHOD_DEFAULT)
+        assert output[SPARSE_PRUNING_METHOD] in [
+            SPARSE_PRUNING_METHOD_L1, SPARSE_PRUNING_METHOD_TOPK, SPARSE_PRUNING_METHOD_SNIP_MOMENTUM
+        ], f"Invalid sparse pruning method. Supported types: [{SPARSE_PRUNING_METHOD_L1}, {SPARSE_PRUNING_METHOD_TOPK}, {SPARSE_PRUNING_METHOD_SNIP_MOMENTUM}]"
+        output[SPARSE_PRUNING_SCHEDULE_OFFSET] = get_scalar_param(sub_param_dict, SPARSE_PRUNING_SCHEDULE_OFFSET,
+                                                                  SPARSE_PRUNING_SCHEDULE_OFFSET_DEFAULT)
+        if output[SPARSE_PRUNING_METHOD] == SPARSE_PRUNING_METHOD_SNIP_MOMENTUM:
+            output[SPARSE_PRUNING_BLOCK_PATTERN] = get_scalar_param(sub_param_dict, SPARSE_PRUNING_BLOCK_PATTERN,
+                                                                    SPARSE_PRUNING_BLOCK_PATTERN_DEFAULT)
+            output[SPARSE_PRUNING_DENSE_RATIO] = get_scalar_param(sub_param_dict, SPARSE_PRUNING_DENSE_RATIO,
+                                                                  SPARSE_PRUNING_DENSE_RATIO_DEFAULT)
+            assert output[SPARSE_PRUNING_DENSE_RATIO] > 0 and output[
+                SPARSE_PRUNING_DENSE_RATIO] < 1, f"Invalid dense_ratio value. Must be less than 1"
+            output[SPARSE_PRUNING_SCHEDULE_OFFSET_STRIDE] = get_scalar_param(
+                sub_param_dict, SPARSE_PRUNING_SCHEDULE_OFFSET_STRIDE, SPARSE_PRUNING_SCHEDULE_OFFSET_STRIDE_DEFAULT)
+            output[SPARSE_PRUNING_EXCLUDED_MODULES] = get_list_param(sub_param_dict, SPARSE_PRUNING_EXCLUDED_MODULES,
+                                                                     SPARSE_PRUNING_EXCLUDED_MODULES_DEFAULT)
+            output[SPARSE_PRUNING_SCHEDULE_OFFSET_END] = get_scalar_param(sub_param_dict,
+                                                                          SPARSE_PRUNING_SCHEDULE_OFFSET_END,
+                                                                          output[SPARSE_PRUNING_SCHEDULE_OFFSET])
+            assert output[SPARSE_PRUNING_SCHEDULE_OFFSET] <= output[
+                SPARSE_PRUNING_SCHEDULE_OFFSET_END], f"Invalid schedule_offset and schedule_offset_end values"
+    else:
+        output[SPARSE_PRUNING_ENABLED] = SPARSE_PRUNING_ENABLED_DEFAULT
+        output[SPARSE_PRUNING_METHOD] = SPARSE_PRUNING_METHOD_DEFAULT
+        output[SPARSE_PRUNING_SCHEDULE_OFFSET] = SPARSE_PRUNING_SCHEDULE_OFFSET_DEFAULT
+    return output
+
+
+def get_sparse_pruning_different_groups(param_dict):
+    output = {}
+    sub_param_dict = param_dict[DIFFERENT_GROUPS]
+
+    def get_params(name, group_dict):
+        assert SPARSE_PRUNING_DENSE_RATIO in group_dict.keys(
+        ), f"{SPARSE_PRUNING_DENSE_RATIO} must be specified for sparse pruning group {name}"
+        return group_dict
+
+    for k, v in sub_param_dict.items():
+        output[k] = {}
+        output[k][DIFFERENT_GROUPS_PARAMETERS] = get_params(k, sub_param_dict[k][DIFFERENT_GROUPS_PARAMETERS])
+        output[k][DIFFERENT_GROUPS_MODULE_SCOPE] = get_scalar_param(sub_param_dict[k], DIFFERENT_GROUPS_MODULE_SCOPE,
+                                                                    DIFFERENT_GROUPS_MODULE_SCOPE_DEFAULT)
+        output[k][DIFFERENT_GROUPS_RELATED_MODULE_SCOPE] = get_scalar_param(
+            sub_param_dict[k], DIFFERENT_GROUPS_RELATED_MODULE_SCOPE, DIFFERENT_GROUPS_RELATED_MODULE_SCOPE_DEFAULT)
+
+    return output
+
+
+def get_row_pruning(param_dict):
+    output = {}
+    if ROW_PRUNING not in param_dict.keys():
+        param_dict[ROW_PRUNING] = {SHARED_PARAMETERS: {}, DIFFERENT_GROUPS: {}}
+    sub_param_dict = param_dict[ROW_PRUNING]
+    # shared parameters
+    output[SHARED_PARAMETERS] = get_row_pruning_shared_parameters(sub_param_dict)
+    # each sub-groups
+    if output[SHARED_PARAMETERS][ROW_PRUNING_ENABLED]:
+        assert DIFFERENT_GROUPS in sub_param_dict.keys(
+        ), f"Row Pruning is enabled, {DIFFERENT_GROUPS} must be specified"
+    output[DIFFERENT_GROUPS] = get_row_pruning_different_groups(sub_param_dict)
+    return output
+
+
+def get_row_pruning_shared_parameters(param_dict):
+    output = {}
+    if SHARED_PARAMETERS in param_dict.keys():
+        sub_param_dict = param_dict[SHARED_PARAMETERS]
+        output[ROW_PRUNING_ENABLED] = get_scalar_param(sub_param_dict, ROW_PRUNING_ENABLED,
+                                                       ROW_PRUNING_ENABLED_DEFAULT)
+        output[ROW_PRUNING_METHOD] = get_scalar_param(sub_param_dict, ROW_PRUNING_METHOD, ROW_PRUNING_METHOD_DEFAULT)
+        assert output[ROW_PRUNING_METHOD] in [
+            ROW_PRUNING_METHOD_L1, ROW_PRUNING_METHOD_TOPK
+        ], f"Invalid row pruning method. Supported types: [{ROW_PRUNING_METHOD_L1}, {ROW_PRUNING_METHOD_TOPK}]"
+        output[ROW_PRUNING_SCHEDULE_OFFSET] = get_scalar_param(sub_param_dict, ROW_PRUNING_SCHEDULE_OFFSET,
+                                                               ROW_PRUNING_SCHEDULE_OFFSET_DEFAULT)
+    else:
+        output[ROW_PRUNING_ENABLED] = ROW_PRUNING_ENABLED_DEFAULT
+        output[ROW_PRUNING_METHOD] = ROW_PRUNING_METHOD_DEFAULT
+        output[ROW_PRUNING_SCHEDULE_OFFSET] = ROW_PRUNING_SCHEDULE_OFFSET_DEFAULT
+    return output
+
+
+def get_row_pruning_different_groups(param_dict):
+    output = {}
+    sub_param_dict = param_dict[DIFFERENT_GROUPS]
+
+    def get_params(name, group_dict):
+        assert ROW_PRUNING_DENSE_RATIO in group_dict.keys(
+        ), f"{ROW_PRUNING_DENSE_RATIO} must be specified for row pruning group {name}"
+        return group_dict
+
+    for k, v in sub_param_dict.items():
+        output[k] = {}
+        output[k][DIFFERENT_GROUPS_PARAMETERS] = get_params(k, sub_param_dict[k][DIFFERENT_GROUPS_PARAMETERS])
+        output[k][DIFFERENT_GROUPS_MODULE_SCOPE] = get_scalar_param(sub_param_dict[k], DIFFERENT_GROUPS_MODULE_SCOPE,
+                                                                    DIFFERENT_GROUPS_MODULE_SCOPE_DEFAULT)
+        output[k][DIFFERENT_GROUPS_RELATED_MODULE_SCOPE] = get_scalar_param(
+            sub_param_dict[k], DIFFERENT_GROUPS_RELATED_MODULE_SCOPE, DIFFERENT_GROUPS_RELATED_MODULE_SCOPE_DEFAULT)
+    return output
+
+
+def get_head_pruning(param_dict):
+    output = {}
+    if HEAD_PRUNING not in param_dict.keys():
+        param_dict[HEAD_PRUNING] = {SHARED_PARAMETERS: {}, DIFFERENT_GROUPS: {}}
+    sub_param_dict = param_dict[HEAD_PRUNING]
+    # shared parameters
+    output[SHARED_PARAMETERS] = get_head_pruning_shared_parameters(sub_param_dict)
+    # each sub-groups
+    if output[SHARED_PARAMETERS][HEAD_PRUNING_ENABLED]:
+        assert DIFFERENT_GROUPS in sub_param_dict.keys(
+        ), f"Head Pruning is enabled, {DIFFERENT_GROUPS} must be specified"
+    output[DIFFERENT_GROUPS] = get_head_pruning_different_groups(sub_param_dict)
+    return output
+
+
+def get_head_pruning_shared_parameters(param_dict):
+    output = {}
+    if SHARED_PARAMETERS in param_dict.keys():
+        sub_param_dict = param_dict[SHARED_PARAMETERS]
+        output[HEAD_PRUNING_ENABLED] = get_scalar_param(sub_param_dict, HEAD_PRUNING_ENABLED,
+                                                        HEAD_PRUNING_ENABLED_DEFAULT)
+        output[HEAD_PRUNING_METHOD] = get_scalar_param(sub_param_dict, HEAD_PRUNING_METHOD,
+                                                       HEAD_PRUNING_METHOD_DEFAULT)
+        assert output[HEAD_PRUNING_METHOD] in [
+            HEAD_PRUNING_METHOD_L1, HEAD_PRUNING_METHOD_TOPK
+        ], f"Invalid head pruning method. Supported types: [{HEAD_PRUNING_METHOD_L1}, {HEAD_PRUNING_METHOD_TOPK}]"
+        output[HEAD_PRUNING_SCHEDULE_OFFSET] = get_scalar_param(sub_param_dict, HEAD_PRUNING_SCHEDULE_OFFSET,
+                                                                HEAD_PRUNING_SCHEDULE_OFFSET_DEFAULT)
+        if output[HEAD_PRUNING_ENABLED]:
+            assert HEAD_PRUNING_NUM_HEADS in sub_param_dict.keys(
+            ), f"{HEAD_PRUNING_NUM_HEADS} must be specified for head pruning"
+            output[HEAD_PRUNING_NUM_HEADS] = sub_param_dict[HEAD_PRUNING_NUM_HEADS]
+    else:
+        output[HEAD_PRUNING_ENABLED] = HEAD_PRUNING_ENABLED_DEFAULT
+        output[HEAD_PRUNING_METHOD] = HEAD_PRUNING_METHOD_DEFAULT
+        output[HEAD_PRUNING_SCHEDULE_OFFSET] = HEAD_PRUNING_SCHEDULE_OFFSET_DEFAULT
+    return output
+
+
+def get_head_pruning_different_groups(param_dict):
+    output = {}
+    sub_param_dict = param_dict[DIFFERENT_GROUPS]
+
+    def get_params(name, group_dict):
+        assert HEAD_PRUNING_DENSE_RATIO in group_dict.keys(
+        ), f"dense_ratio must be specified for head pruning group {name}"
+        return group_dict
+
+    for k, v in sub_param_dict.items():
+        output[k] = {}
+        output[k][DIFFERENT_GROUPS_PARAMETERS] = get_params(k, sub_param_dict[k][DIFFERENT_GROUPS_PARAMETERS])
+        output[k][DIFFERENT_GROUPS_MODULE_SCOPE] = get_scalar_param(sub_param_dict[k], DIFFERENT_GROUPS_MODULE_SCOPE,
+                                                                    DIFFERENT_GROUPS_MODULE_SCOPE_DEFAULT)
+        output[k][DIFFERENT_GROUPS_RELATED_MODULE_SCOPE] = get_scalar_param(
+            sub_param_dict[k], DIFFERENT_GROUPS_RELATED_MODULE_SCOPE, DIFFERENT_GROUPS_RELATED_MODULE_SCOPE_DEFAULT)
+    return output
+
+
+def get_channel_pruning(param_dict):
+    output = {}
+    if CHANNEL_PRUNING not in param_dict.keys():
+        param_dict[CHANNEL_PRUNING] = {SHARED_PARAMETERS: {}, DIFFERENT_GROUPS: {}}
+    sub_param_dict = param_dict[CHANNEL_PRUNING]
+    # shared parameters
+    output[SHARED_PARAMETERS] = get_channel_pruning_shared_parameters(sub_param_dict)
+    # each sub-groups
+    if output[SHARED_PARAMETERS][CHANNEL_PRUNING_ENABLED]:
+        assert DIFFERENT_GROUPS in sub_param_dict.keys(
+        ), f"Sparse Pruning is enabled, {DIFFERENT_GROUPS} must be specified"
+    output[DIFFERENT_GROUPS] = get_channel_pruning_different_groups(sub_param_dict)
+    return output
+
+
+def get_channel_pruning_shared_parameters(param_dict):
+    output = {}
+    if SHARED_PARAMETERS in param_dict.keys():
+        sub_param_dict = param_dict[SHARED_PARAMETERS]
+        output[CHANNEL_PRUNING_ENABLED] = get_scalar_param(sub_param_dict, CHANNEL_PRUNING_ENABLED,
+                                                           CHANNEL_PRUNING_ENABLED_DEFAULT)
+        output[CHANNEL_PRUNING_METHOD] = get_scalar_param(sub_param_dict, CHANNEL_PRUNING_METHOD,
+                                                          CHANNEL_PRUNING_METHOD_DEFAULT)
+        assert output[CHANNEL_PRUNING_METHOD] in [
+            CHANNEL_PRUNING_METHOD_L1, CHANNEL_PRUNING_METHOD_TOPK
+        ], f"Invalid channel pruning method. Supported types: [{CHANNEL_PRUNING_METHOD_L1}, {CHANNEL_PRUNING_METHOD_TOPK}]"
+        output[CHANNEL_PRUNING_SCHEDULE_OFFSET] = get_scalar_param(sub_param_dict, CHANNEL_PRUNING_SCHEDULE_OFFSET,
+                                                                   CHANNEL_PRUNING_SCHEDULE_OFFSET_DEFAULT)
+    else:
+        output[CHANNEL_PRUNING_ENABLED] = CHANNEL_PRUNING_ENABLED_DEFAULT
+        output[CHANNEL_PRUNING_METHOD] = CHANNEL_PRUNING_METHOD_DEFAULT
+        output[CHANNEL_PRUNING_SCHEDULE_OFFSET] = CHANNEL_PRUNING_SCHEDULE_OFFSET_DEFAULT
+    return output
+
+
+def get_channel_pruning_different_groups(param_dict):
+    output = {}
+    sub_param_dict = param_dict[DIFFERENT_GROUPS]
+
+    def get_params(name, group_dict):
+        assert CHANNEL_PRUNING_DENSE_RATIO in group_dict.keys(
+        ), f"{CHANNEL_PRUNING_DENSE_RATIO} must be specified for channel pruning group {name}"
+        return group_dict
+
+    for k, v in sub_param_dict.items():
+        output[k] = {}
+        output[k][DIFFERENT_GROUPS_PARAMETERS] = get_params(k, sub_param_dict[k][DIFFERENT_GROUPS_PARAMETERS])
+        output[k][DIFFERENT_GROUPS_MODULE_SCOPE] = get_scalar_param(sub_param_dict[k], DIFFERENT_GROUPS_MODULE_SCOPE,
+                                                                    DIFFERENT_GROUPS_MODULE_SCOPE_DEFAULT)
+        output[k][DIFFERENT_GROUPS_RELATED_MODULE_SCOPE] = get_scalar_param(
+            sub_param_dict[k], DIFFERENT_GROUPS_RELATED_MODULE_SCOPE, DIFFERENT_GROUPS_RELATED_MODULE_SCOPE_DEFAULT)
+
+    return output

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/compression/constants.py

@@ -0,0 +1,188 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+#########################################
+# Compression Methods
+# It has several sub-components
+# #########################################
+COMPRESSION_TRAINING = "compression_training"
+SHARED_PARAMETERS = "shared_parameters"
+DIFFERENT_GROUPS = "different_groups"
+TECHNIQUE_ENABLED = "enabled"
+TECHNIQUE_SCHEDULE_OFFSET = "schedule_offset"
+TECHNIQUE_SCHEDULE_OFFSET_END = "schedule_offset_end"
+DIFFERENT_GROUPS_PARAMETERS = "params"
+DIFFERENT_GROUPS_MODULE_SCOPE = "modules"
+DIFFERENT_GROUPS_MODULE_SCOPE_DEFAULT = "*"
+DIFFERENT_GROUPS_RELATED_MODULE_SCOPE = "related_modules"
+DIFFERENT_GROUPS_RELATED_MODULE_SCOPE_DEFAULT = None
+# COMPRESSION_TRAINING_ENABLED = "enabled"
+# COMPRESSION_TRAINING_ENABLED_DEFAULT = False
+
+####
+# Layer Reduction
+####
+LAYER_REDUCTION = "layer_reduction"
+LAYER_REDUCTION_ENABLED = "enabled"
+LAYER_REDUCTION_ENABLED_DEFAULT = False
+KEEP_NUMBER_LAYER = "keep_number_layer"
+MODULE_NAME_PREFIX = "module_name_prefix"
+TEACHER_LAYER = "teacher_layer"
+OTHER_MODULE_NAME = "other_module_name"
+
+####
+# Weight Quantization
+####
+WEIGHT_QUANTIZATION = "weight_quantization"
+
+WEIGHT_QUANTIZATION_PERIOD = "quantization_period"
+WEIGHT_QUANTIZATION_PERIOD_DEFAULT = 1
+
+WEIGHT_QUANTIZE_IN_FORWARD_ENABLED = "quantize_weight_in_forward"
+WEIGHT_QUANTIZE_IN_FORWARD_ENABLED_DEFAULT = False
+
+WEIGHT_QUANTIZE_ENABLED = TECHNIQUE_ENABLED
+WEIGHT_QUANTIZE_ENABLED_DEFAULT = False
+
+WEIGHT_QUANTIZE_KERNEL = "quantizer_kernel"
+WEIGHT_QUANTIZE_KERNEL_DEFAULT = False
+
+WEIGHT_QUANTIZE_SCHEDULE_OFFSET = TECHNIQUE_SCHEDULE_OFFSET
+WEIGHT_QUANTIZE_SCHEDULE_OFFSET_DEFAULT = 0
+
+WEIGHT_QUANTIZE_GROUPS = "quantize_groups"
+WEIGHT_QUANTIZE_GROUPS_DEFAULT = 1
+
+WEIGHT_QUANTIZE_VERBOSE = "quantize_verbose"
+WEIGHT_QUANTIZE_VERBOSE_DEFAULT = False
+
+WEIGHT_QUANTIZE_TYPE = "quantization_type"
+WEIGHT_QUANTIZE_TYPE_DEFAULT = "symmetric"
+WEIGHT_QUANTIZE_SYMMETRIC = "symmetric"
+WEIGHT_QUANTIZE_ASYMMETRIC = "asymmetric"
+
+WEIGHT_QUANTIZE_ROUNDING = "rounding"
+WEIGHT_QUANTIZE_ROUNDING_DEFAULT = "nearest"
+WEIGHT_QUANTIZE_STOCHASTIC_ROUNDING = "stochastic"
+WEIGHT_QUANTIZE_NEAREST_ROUNDING = "nearest"
+# maybe deleted for a cleaner version
+WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE = "fp16_mixed_quantize"
+
+WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE_ENABLED = "enabled"
+WEIGHT_QUANTIZE_FP16_MIXED_QUANTIZE_ENABLED_DEFAULT = False
+
+WEIGHT_QUANTIZE_CHANGE_RATIO = "quantize_change_ratio"
+WEIGHT_QUANTIZE_CHANGE_RATIO_DEFAULT = 0.001
+
+WEIGHT_QUANTIZE_START_BITS = "start_bits"
+WEIGHT_QUANTIZE_TARGET_BITS = "target_bits"
+###
+# Activation Quantization
+###
+ACTIVATION_QUANTIZATION = "activation_quantization"
+
+ACTIVATION_QUANTIZATION_ENABLED = TECHNIQUE_ENABLED
+ACTIVATION_QUANTIZATION_ENABLED_DEFAULT = False
+
+ACTIVATION_QUANTIZE_SCHEDULE_OFFSET = TECHNIQUE_SCHEDULE_OFFSET
+ACTIVATION_QUANTIZE_SCHEDULE_OFFSET_DEFAULT = 1000
+
+ACTIVATION_QUANTIZE_TYPE = "quantization_type"
+ACTIVATION_QUANTIZE_TYPE_DEFAULT = "symmetric"
+ACTIVATION_QUANTIZE_SYMMETRIC = "symmetric"
+ACTIVATION_QUANTIZE_ASYMMETRIC = "asymmetric"
+
+ACTIVATION_QUANTIZE_RANGE = 'range_calibration'
+ACTIVATION_QUANTIZE_RANGE_DEFAULT = 'dynamic'
+ACTIVATION_QUANTIZE_RANGE_STATIC = 'static'
+ACTIVATION_QUANTIZE_RANGE_DYNAMIC = 'dynamic'
+
+ACTIVATION_QUANTIZE_BITS = "bits"
+###
+# Sparse Pruning
+###
+SPARSE_PRUNING = "sparse_pruning"
+
+SPARSE_PRUNING_ENABLED = TECHNIQUE_ENABLED
+SPARSE_PRUNING_ENABLED_DEFAULT = False
+
+SPARSE_PRUNING_METHOD = "method"
+SPARSE_PRUNING_METHOD_DEFAULT = "l1"
+SPARSE_PRUNING_METHOD_L1 = "l1"
+SPARSE_PRUNING_METHOD_TOPK = "topk"
+SPARSE_PRUNING_METHOD_SNIP_MOMENTUM = "snip_momentum"
+
+SPARSE_PRUNING_BLOCK_PATTERN = "block_pattern"
+SPARSE_PRUNING_BLOCK_PATTERN_DEFAULT = "4x1"
+
+SPARSE_PRUNING_SCHEDULE_OFFSET_STRIDE = "schedule_offset_stride"
+SPARSE_PRUNING_SCHEDULE_OFFSET_STRIDE_DEFAULT = 1
+
+SPARSE_PRUNING_SCHEDULE_OFFSET = TECHNIQUE_SCHEDULE_OFFSET
+SPARSE_PRUNING_SCHEDULE_OFFSET_DEFAULT = 1000
+
+SPARSE_PRUNING_SCHEDULE_OFFSET_END = TECHNIQUE_SCHEDULE_OFFSET_END
+SPARSE_PRUNING_SCHEDULE_OFFSET_END_DEFAULT = SPARSE_PRUNING_SCHEDULE_OFFSET_DEFAULT
+
+SPARSE_PRUNING_DENSE_RATIO = "dense_ratio"
+SPARSE_PRUNING_DENSE_RATIO_DEFAULT = 0.1
+
+SPARSE_PRUNING_EXCLUDED_MODULES = "excluded_modules"
+SPARSE_PRUNING_EXCLUDED_MODULES_DEFAULT = []
+###
+# Row Pruning
+###
+ROW_PRUNING = "row_pruning"
+
+ROW_PRUNING_ENABLED = TECHNIQUE_ENABLED
+ROW_PRUNING_ENABLED_DEFAULT = False
+
+ROW_PRUNING_METHOD = "method"
+ROW_PRUNING_METHOD_DEFAULT = "l1"
+ROW_PRUNING_METHOD_L1 = "l1"
+ROW_PRUNING_METHOD_TOPK = "topk"
+
+ROW_PRUNING_SCHEDULE_OFFSET = TECHNIQUE_SCHEDULE_OFFSET
+ROW_PRUNING_SCHEDULE_OFFSET_DEFAULT = 1000
+
+ROW_PRUNING_DENSE_RATIO = "dense_ratio"
+
+###
+# Head Pruning
+###
+HEAD_PRUNING = "head_pruning"
+
+HEAD_PRUNING_ENABLED = TECHNIQUE_ENABLED
+HEAD_PRUNING_ENABLED_DEFAULT = False
+
+HEAD_PRUNING_METHOD = "method"
+HEAD_PRUNING_METHOD_DEFAULT = "topk"
+HEAD_PRUNING_METHOD_L1 = "l1"
+HEAD_PRUNING_METHOD_TOPK = "topk"
+
+HEAD_PRUNING_SCHEDULE_OFFSET = TECHNIQUE_SCHEDULE_OFFSET
+HEAD_PRUNING_SCHEDULE_OFFSET_DEFAULT = 1000
+
+HEAD_PRUNING_NUM_HEADS = "num_heads"
+
+HEAD_PRUNING_DENSE_RATIO = "dense_ratio"
+
+###
+# Channel Pruning
+###
+CHANNEL_PRUNING = "channel_pruning"
+
+CHANNEL_PRUNING_ENABLED = TECHNIQUE_ENABLED
+CHANNEL_PRUNING_ENABLED_DEFAULT = False
+
+CHANNEL_PRUNING_METHOD = "method"
+CHANNEL_PRUNING_METHOD_DEFAULT = "l1"
+CHANNEL_PRUNING_METHOD_L1 = "l1"
+CHANNEL_PRUNING_METHOD_TOPK = "topk"
+
+CHANNEL_PRUNING_SCHEDULE_OFFSET = TECHNIQUE_SCHEDULE_OFFSET
+CHANNEL_PRUNING_SCHEDULE_OFFSET_DEFAULT = 1000
+
+CHANNEL_PRUNING_DENSE_RATIO = "dense_ratio"

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/compression/helper.py

@@ -0,0 +1,322 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+from .basic_layer import Embedding_Compress, LinearLayer_Compress, Conv2dLayer_Compress, BNLayer_Compress, ColumnParallelLinear_Compress, RowParallelLinear_Compress
+from .constants import *
+from deepspeed.utils import logger
+
+try:
+    from neural_compressor.compression import pruner as nc_pruner
+except ImportError as e:
+    nc_pruner = None
+
+
+def recursive_getattr(model, module_name):
+    """
+    Recursively get the attribute of a module.
+    Args:
+        model (`torch.nn.Module`)
+            The model to get the attribute from.
+        module_name (`str`)
+            The name of the module to get the attribute from.
+    """
+    split_list = module_name.split('.')
+    output = model
+    for name in split_list:
+        output = getattr(output, name)
+    return output
+
+
+def recursive_setattr(model, module_name, module):
+    """
+    Recursively set the attribute of a module.
+    Args:
+        model (`torch.nn.Module`)
+            The model to set the attribute in.
+        module_name (`str`)
+            The name of the module to set the attribute in.
+        module (`torch.nn.Module`)
+            The module to set the attribute to.
+    """
+    split_list = module_name.split('.')
+    output = model
+    for name in split_list[:-1]:
+        output = getattr(output, name)
+    output.__setattr__(split_list[-1], module)
+
+
+def module_replacement(model, module_name, compression_technique=None, mpu=None):
+    """
+    Replace a module with a new module.
+    Args:
+        model (`torch.nn.Module`)
+            The model to replace the module in.
+        module_name (`str`)
+            The name of the module to replace.
+        compression_technique (`str`)
+            The compression technique to use for the new module.
+    """
+
+    # Get the old module
+    old_module = recursive_getattr(model, module_name)
+
+    need_bias = False
+    if hasattr(old_module, 'bias') and old_module.bias is not None:
+        need_bias = True
+
+    # Initialize the new module
+    if isinstance(old_module, LinearLayer_Compress) or isinstance(old_module, torch.nn.Linear):
+        if isinstance(old_module, LinearLayer_Compress):
+            new_module = old_module
+        else:
+            new_module = LinearLayer_Compress(old_module.in_features, old_module.out_features,
+                                              bias=need_bias).to(device=old_module.weight.device,
+                                                                 dtype=old_module.weight.dtype)
+            new_module.weight.data = old_module.weight.data
+            if need_bias:
+                new_module.bias.data = old_module.bias.data
+    elif isinstance(old_module, Conv2dLayer_Compress) or isinstance(old_module, torch.nn.Conv2d):
+        if isinstance(old_module, Conv2dLayer_Compress):
+            new_module = old_module
+        else:
+            new_module = Conv2dLayer_Compress(old_module.in_channels, old_module.out_channels, old_module.kernel_size, old_module.stride, old_module.padding, \
+                                            old_module.dilation, old_module.groups, need_bias, \
+                                            old_module.padding_mode).to(device=old_module.weight.device, dtype=old_module.weight.dtype)
+            new_module.weight.data = old_module.weight.data
+            if need_bias:
+                new_module.bias.data = old_module.bias.data
+    elif isinstance(old_module, torch.nn.BatchNorm2d):
+        new_module = BNLayer_Compress(old_module.num_features, old_module.eps, old_module.momentum, old_module.affine,
+                                      old_module.track_running_stats).to(old_module.weight.device,
+                                                                         old_module.weight.dtype)
+        new_module.weight.data = old_module.weight.data
+        if need_bias:
+            new_module.bias.data = old_module.bias.data
+        new_module.running_mean.data = old_module.running_mean.data
+        new_module.running_var.data = old_module.running_var.data
+    elif isinstance(old_module, Embedding_Compress) or isinstance(old_module, torch.nn.Embedding):
+        if isinstance(old_module, Embedding_Compress):
+            new_module = old_module
+        else:
+            new_module = Embedding_Compress(old_module.num_embeddings, old_module.embedding_dim, old_module.padding_idx, old_module.max_norm, old_module.norm_type, \
+                                        old_module.scale_grad_by_freq, old_module.sparse).to(device=old_module.weight.device, dtype=old_module.weight.dtype)
+            new_module.weight.data = old_module.weight.data
+    elif mpu is not None and (isinstance(old_module, ColumnParallelLinear_Compress)
+                              or isinstance(old_module, mpu.ColumnParallelLinear)):
+        if isinstance(old_module, ColumnParallelLinear_Compress):
+            new_module = old_module
+        else:
+            new_module = ColumnParallelLinear_Compress(mpu,
+                                                       old_module.input_size,
+                                                       old_module.output_size,
+                                                       gather_output=old_module.gather_output,
+                                                       skip_bias_add=old_module.skip_bias_add,
+                                                       bias=need_bias).to(device=old_module.weight.device,
+                                                                          dtype=old_module.weight.dtype)
+            new_module.weight.data = old_module.weight.data
+            if need_bias:
+                new_module.bias.data = old_module.bias.data
+    elif mpu is not None and (isinstance(old_module, RowParallelLinear_Compress)
+                              or isinstance(old_module, mpu.RowParallelLinear)):
+        if isinstance(old_module, RowParallelLinear_Compress):
+            new_module = old_module
+        else:
+            new_module = RowParallelLinear_Compress(mpu,
+                                                    old_module.input_size,
+                                                    old_module.output_size,
+                                                    input_is_parallel=old_module.input_is_parallel,
+                                                    skip_bias_add=old_module.skip_bias_add,
+                                                    bias=need_bias).to(device=old_module.weight.device,
+                                                                       dtype=old_module.weight.dtype)
+            new_module.weight.data = old_module.weight.data
+            if need_bias:
+                new_module.bias.data = old_module.bias.data
+    else:
+        new_module = None
+
+    if compression_technique is not None:
+        for k, v in compression_technique.items():
+            if k == SPARSE_PRUNING:
+                if v[SPARSE_PRUNING_ENABLED]:
+                    new_module.enable_sparse_pruning(v[SPARSE_PRUNING_DENSE_RATIO], v[SPARSE_PRUNING_METHOD])
+            elif k == ROW_PRUNING:
+                if v[ROW_PRUNING_ENABLED]:
+                    new_module.enable_row_pruning(v[ROW_PRUNING_DENSE_RATIO], v[ROW_PRUNING_METHOD])
+            elif k == HEAD_PRUNING:
+                if v[HEAD_PRUNING_ENABLED]:
+                    new_module.enable_head_pruning(v[HEAD_PRUNING_DENSE_RATIO], v[HEAD_PRUNING_METHOD],
+                                                   v[HEAD_PRUNING_NUM_HEADS])
+            elif k == ACTIVATION_QUANTIZATION:
+                if v[ACTIVATION_QUANTIZATION_ENABLED]:
+                    new_module.enable_activation_quantization(v[ACTIVATION_QUANTIZE_BITS], v[ACTIVATION_QUANTIZE_TYPE],
+                                                              v[ACTIVATION_QUANTIZE_RANGE])
+            elif k == WEIGHT_QUANTIZATION:
+                if v[WEIGHT_QUANTIZE_ENABLED]:
+                    new_module.enable_weight_quantization(v[WEIGHT_QUANTIZE_START_BITS],
+                                                          v[WEIGHT_QUANTIZE_TARGET_BITS],
+                                                          v[WEIGHT_QUANTIZATION_PERIOD],
+                                                          v[WEIGHT_QUANTIZE_IN_FORWARD_ENABLED],
+                                                          v[WEIGHT_QUANTIZE_TYPE], v[WEIGHT_QUANTIZE_GROUPS])
+            elif k == CHANNEL_PRUNING:
+                if v[CHANNEL_PRUNING_ENABLED]:
+                    new_module.enable_channel_pruning(v[CHANNEL_PRUNING_DENSE_RATIO], v[CHANNEL_PRUNING_METHOD])
+            else:
+                raise NotImplementedError('Compression technique {} is not implemented'.format(k))
+
+    # Replace the old module with the new one
+    recursive_setattr(model, module_name, new_module)
+
+
+def is_module_compressible(module, mpu=None):
+    ret = isinstance(module, torch.nn.Linear) or \
+          isinstance(module, torch.nn.Conv2d) or \
+          isinstance(module, torch.nn.Embedding) or \
+          isinstance(module, torch.nn.BatchNorm2d)
+
+    if mpu is not None:
+        ret = ret or isinstance(module, mpu.RowParallelLinear) or isinstance(module, mpu.ColumnParallelLinear)
+
+    return ret
+
+
+def compression_preparation(model, compression_technique_list, mpu):
+    """
+    Prepare the compression techniques of a model.
+    Args:
+        model (`torch.nn.Module`)
+            The model to prepare the compression techniques of.
+        compression_technique_list (`list`)
+            The list of compression techniques to prepare the model to.
+            list[]
+    """
+    # Here we first replace all module with our linear wrapper
+    for module_name, module in model.named_modules():
+        if is_module_compressible(module, mpu):
+            module_replacement(model, module_name, mpu=mpu)
+    for module_name_lists, _, compression_technique in compression_technique_list:
+        for mnl in module_name_lists:
+            for module_name in mnl:
+                module_replacement(model, module_name, compression_technique)
+
+    return model
+
+
+def fix_compression(model, module_name, compression_technique, mask=None, dim_reduction=False):
+    """
+    Fix the compression technique of a module.
+    Args:
+        model (`torch.nn.Module`)
+            The model to fix the compression technique of.
+        module_name (`str`)
+            The name of the module to fix the compression technique of.
+        compression_technique (`str`)
+            The compression technique to fix the module to.
+    """
+    # Here we can make things much simpler by just replacing the module
+    module = recursive_getattr(model, module_name)
+    for k, v in compression_technique.items():
+        if k == WEIGHT_QUANTIZATION and v[WEIGHT_QUANTIZE_IN_FORWARD_ENABLED] and v[WEIGHT_QUANTIZE_ENABLED]:
+            return module.fix_weight_quantization()
+        elif k == SPARSE_PRUNING and v[SPARSE_PRUNING_ENABLED]:
+            return module.fix_sparse_pruning_helper()
+        elif k == ROW_PRUNING and (v[ROW_PRUNING_ENABLED] or mask is not None):
+            return module.fix_row_col_pruning_helper(mask, dim_reduction=dim_reduction)
+        elif k == HEAD_PRUNING and (v[HEAD_PRUNING_ENABLED] or mask is not None):
+            return module.fix_head_pruning_helper(mask, v[HEAD_PRUNING_NUM_HEADS], dim_reduction=dim_reduction)
+        elif k == CHANNEL_PRUNING and (v[CHANNEL_PRUNING_ENABLED] or mask is not None):
+            return module.fix_channel_pruning_helper(mask, dim_reduction=dim_reduction)
+
+
+def convert_conv1d_to_linear(model, convert_type):
+    '''
+    This is a help function to convert conv1d to linear (e.g., convert GPT2 from HF)
+    '''
+    if hasattr(model, 'module'):
+        c_model = model.module
+    else:
+        c_model = model
+
+    for name, module in c_model.named_modules():
+        if isinstance(module, convert_type):
+            old_module = recursive_getattr(c_model, name)
+            new_module = torch.nn.Linear(old_module.weight.data.size(0),
+                                         old_module.weight.data.size(1),
+                                         bias=True if old_module.bias is not None else False)
+            new_module.weight.data = old_module.weight.data.t().contiguous()
+            if new_module.bias is not None:
+                new_module.bias.data = old_module.bias.data.view(-1)
+
+            recursive_setattr(c_model, name, new_module)
+
+    return model
+
+
+def generate_pruners(config, model):
+    """Generate pruners.
+    Args:
+        config (`neural_compressor.WeightPruningConfig`)
+            The object to the class WeightPruningConfig.
+        model (`torch.nn.module`)
+            The torch module object to be pruned.
+    """
+    assert nc_pruner is not None, "please ensure the neural_compressor python package is installed by pip or conda if user wants to use snip_momentum sparse pruning"
+    from nc_pruner.utils import process_config, parse_to_prune
+    from nc_pruner.pruners import get_pruner
+    assert isinstance(model, torch.nn.Module)
+    pruners_info = process_config(config)
+    pruners = []
+    for info in pruners_info:
+        modules = parse_to_prune(info, model)
+        if modules == {}:
+            logger.warning("one pruner hooks no layers, please have a check")
+
+        pruners.append(get_pruner(info, modules))
+        info['modules'] = [key for key in modules.keys()]
+        info['len_of_modules'] = len(info['modules'])
+        logger.info(info)
+    return pruners
+
+
+def register_on_step_begin(model):
+    """Mount on_step_begin to the model.
+    Args:
+        model (`torch.nn.module`)
+            The torch module object to be pruned.
+    """
+
+    def hook(module, input):
+        for pruner in module.pruners:
+            pruner.on_step_begin(0)
+
+    hook_handle = model.register_forward_pre_hook(hook)
+    return hook_handle
+
+
+def rewrite_optimizer_step(opt: torch.optim.Optimizer):
+    """Mount on_before/after_optimizer_step to the optimizer.
+    Args:
+        model (`torch.opt.Optimizer`)
+            The torch optimizer object to be hooked.
+    """
+
+    def new_step(self, closure=None):
+        if hasattr(self, "pruners"):
+            for pruner in self.pruners:
+                pruner.on_before_optimizer_step()
+
+        if closure is not None:
+            res = self.orig_step(closure)
+        else:
+            res = self.orig_step()
+        if hasattr(self, "pruners"):
+            for pruner in self.pruners:
+                pruner.on_after_optimizer_step()
+        return res
+
+    opt.orig_step = opt.step
+    import types
+    opt.step = types.MethodType(new_step, opt)
+    return opt

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/compression/scheduler.py

@@ -0,0 +1,173 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .compress import get_module_name
+from .constants import *
+from .helper import recursive_getattr
+from deepspeed.utils import logger
+
+
+class compression_scheduler():
+    '''
+    Used to schedule different compression methods
+    '''
+
+    def __init__(self, model, compression_config):
+        self.model = model
+        self.compression_config = compression_config
+        self.make_init()
+        self.training_steps = 0
+        self.weight_quantization_enabled = False
+
+        self.verbose = {
+            WEIGHT_QUANTIZATION: False,
+            ACTIVATION_QUANTIZATION: False,
+            SPARSE_PRUNING: False,
+            HEAD_PRUNING: False,
+            ROW_PRUNING: False,
+            CHANNEL_PRUNING: False
+        }
+
+    def make_init(self):
+        self.different_compression_methods = {}
+        for method, method_content in self.compression_config.items():
+            if LAYER_REDUCTION in method:
+                continue
+            self.different_compression_methods[method] = {
+                TECHNIQUE_ENABLED: False,
+                SHARED_PARAMETERS: None,
+                DIFFERENT_GROUPS: []
+            }
+            exist_module_name = set()
+            shared_parameters = method_content[SHARED_PARAMETERS]
+            self.different_compression_methods[method][TECHNIQUE_ENABLED] = shared_parameters[TECHNIQUE_ENABLED]
+            self.different_compression_methods[method][SHARED_PARAMETERS] = shared_parameters
+
+            for group_name, method_parameters in method_content[DIFFERENT_GROUPS].items():
+                module_name_list = []
+                for key_word in method_parameters[DIFFERENT_GROUPS_MODULE_SCOPE]:
+                    module_name, exist_module_name = get_module_name(group_name,
+                                                                     self.model,
+                                                                     key_word,
+                                                                     exist_module_name,
+                                                                     verbose=False)
+                    module_name_list.extend(module_name)
+                if module_name_list:
+                    self.different_compression_methods[method][DIFFERENT_GROUPS].append(
+                        [group_name, module_name_list,
+                         method_parameters.copy().pop('params')])
+
+    def check_weight_quantization(self):
+        # check weight quantization
+        wq = self.different_compression_methods[WEIGHT_QUANTIZATION]
+        if not wq[TECHNIQUE_ENABLED]:
+            return
+        else:
+            shared_parameters = wq[SHARED_PARAMETERS]
+            if self.training_steps >= shared_parameters[TECHNIQUE_SCHEDULE_OFFSET]:
+                for group_name, module_name_list, method_parameters in wq[DIFFERENT_GROUPS]:
+                    for module_name in module_name_list:
+                        module = recursive_getattr(self.model, module_name)
+                        module.weight_quantization_enabled = True
+
+                if not self.verbose[WEIGHT_QUANTIZATION]:
+                    logger.info(f'Weight quantization is enabled at step {self.training_steps}')
+                    self.weight_quantization_enabled = True
+                    self.verbose[WEIGHT_QUANTIZATION] = True
+
+    def check_activation_quantization(self):
+        # check activation quantization
+        aq = self.different_compression_methods[ACTIVATION_QUANTIZATION]
+        if not aq[TECHNIQUE_ENABLED]:
+            return
+        else:
+            shared_parameters = aq[SHARED_PARAMETERS]
+            if self.training_steps >= shared_parameters[TECHNIQUE_SCHEDULE_OFFSET]:
+                for group_name, module_name_list, method_parameters in aq[DIFFERENT_GROUPS]:
+                    for module_name in module_name_list:
+                        module = recursive_getattr(self.model, module_name)
+                        module.activation_quantization_enabled = True
+                if not self.verbose[ACTIVATION_QUANTIZATION]:
+                    logger.info(f'Activation quantization is enabled at step {self.training_steps}')
+                    self.verbose[ACTIVATION_QUANTIZATION] = True
+
+    def check_sparse_pruning(self):
+        # check sparse pruning
+        sp = self.different_compression_methods[SPARSE_PRUNING]
+        if not sp[TECHNIQUE_ENABLED]:
+            return
+        else:
+            shared_parameters = sp[SHARED_PARAMETERS]
+            if shared_parameters[TECHNIQUE_SCHEDULE_OFFSET] <= self.training_steps <= shared_parameters[
+                    TECHNIQUE_SCHEDULE_OFFSET_END]:
+                for group_name, module_name_list, method_parameters in sp[DIFFERENT_GROUPS]:
+                    for module_name in module_name_list:
+                        module = recursive_getattr(self.model, module_name)
+                        module.sparse_pruning_enabled = True
+                if not self.verbose[SPARSE_PRUNING]:
+                    logger.info(f'Sparse pruning is enabled at step {self.training_steps}')
+                    self.verbose[SPARSE_PRUNING] = True
+
+    def check_head_pruning(self):
+        # check head pruning
+        hp = self.different_compression_methods[HEAD_PRUNING]
+        if not hp[TECHNIQUE_ENABLED]:
+            return
+        else:
+            shared_parameters = hp[SHARED_PARAMETERS]
+            if self.training_steps >= shared_parameters[TECHNIQUE_SCHEDULE_OFFSET]:
+                for group_name, module_name_list, method_parameters in hp[DIFFERENT_GROUPS]:
+                    for module_name in module_name_list:
+                        module = recursive_getattr(self.model, module_name)
+                        module.head_pruning_enabled = True
+                if not self.verbose[HEAD_PRUNING]:
+                    logger.info(f'Head pruning is enabled at step {self.training_steps}')
+                    self.verbose[HEAD_PRUNING] = True
+
+    def check_row_pruning(self):
+        # check row pruning
+        rp = self.different_compression_methods[ROW_PRUNING]
+        if not rp[TECHNIQUE_ENABLED]:
+            return
+        else:
+            shared_parameters = rp[SHARED_PARAMETERS]
+            if self.training_steps >= shared_parameters[TECHNIQUE_SCHEDULE_OFFSET]:
+                for group_name, module_name_list, method_parameters in rp[DIFFERENT_GROUPS]:
+                    for module_name in module_name_list:
+                        module = recursive_getattr(self.model, module_name)
+                        module.row_pruning_enabled = True
+                if not self.verbose[ROW_PRUNING]:
+                    logger.info(f'Row pruning is enabled at step {self.training_steps}')
+                    self.verbose[ROW_PRUNING] = True
+
+    def check_channel_pruning(self):
+        # check channel pruning
+        cp = self.different_compression_methods[CHANNEL_PRUNING]
+        if not cp[TECHNIQUE_ENABLED]:
+            return
+        else:
+            shared_parameters = cp[SHARED_PARAMETERS]
+            if self.training_steps >= shared_parameters[TECHNIQUE_SCHEDULE_OFFSET]:
+                for group_name, module_name_list, method_parameters in cp[DIFFERENT_GROUPS]:
+                    for module_name in module_name_list:
+                        module = recursive_getattr(self.model, module_name)
+                        module.channel_pruning_enabled = True
+                if not self.verbose[CHANNEL_PRUNING]:
+                    logger.info(f'Channel pruning is enabled at step {self.training_steps}')
+                    self.verbose[CHANNEL_PRUNING] = True
+
+    def check_all_modules(self):
+        # check all different compression methods we have
+        self.check_weight_quantization()
+        self.check_activation_quantization()
+        self.check_sparse_pruning()
+        self.check_head_pruning()
+        self.check_row_pruning()
+        self.check_channel_pruning()
+
+    def step(self, step_zero_check=False):
+        if not step_zero_check:
+            self.training_steps += 1
+        self.check_all_modules()

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/compression/utils.py

@@ -0,0 +1,222 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+from torch import autograd
+import math
+
+
+class TopKBinarizer(autograd.Function):
+    """
+    Top-k Binarizer.
+    Computes a binary mask M from a real value matrix S such that `M_{i,j} = 1` if and only if `S_{i,j}`
+    is among the k% highest values of S.
+    Implementation is inspired from:
+        https://github.com/yaozhewei/MLPruning
+    """
+
+    @staticmethod
+    def forward(ctx, inputs: torch.tensor, threshold: float, sigmoid: bool):
+        """
+        Args:
+            inputs (`torch.FloatTensor`)
+                The input matrix from which the binarizer computes the binary mask.
+            threshold (`float`)
+                The percentage of weights to keep (the rest is pruned).
+                `threshold` is a float between 0 and 1.
+            sigmoid (`bool`)
+                Whether to apply a sigmoid on the threshold
+        Returns:
+            mask (`torch.FloatTensor`)
+                Binary matrix of the same size as `inputs` acting as a mask (1 - the associated weight is
+                retained, 0 - the associated weight is pruned).
+        """
+        # Get the subnetwork by sorting the inputs and using the top threshold
+        if sigmoid:
+            threshold = torch.sigmoid(threshold).item()
+        ctx.sigmoid = sigmoid
+        mask = inputs.clone()
+
+        _, idx = inputs.flatten().sort(descending=True)
+        j = math.ceil(threshold * inputs.numel())
+
+        # flat_out and mask access the same memory.
+        flat_out = mask.flatten()
+        flat_out[idx[j:]] = 0.
+        flat_out[idx[:j]] = 1.
+        ctx.save_for_backward(mask)
+
+        return mask
+
+    @staticmethod
+    def backward(ctx, gradOutput):
+        mask, = ctx.saved_tensors
+        if ctx.sigmoid:
+            return gradOutput.clone(), ((gradOutput * mask).sum()).view(-1), None
+        else:
+            return gradOutput.clone(), None, None
+
+
+class SymQuantizer(torch.autograd.Function):
+    """
+    Symmetric quantization
+    """
+
+    @staticmethod
+    def forward(ctx, input, num_bits, min_value=None, max_value=None, num_groups=1):
+        """
+        Args:
+            inputs (`torch.FloatTensor`)
+                The input which needs to be quantized
+            num_bits (int, >=4)
+                Number of bits to use for quantization
+            min_value/max_value (torch.FloatTensor)
+                Used for static activation quantization
+            num_groups (int)
+                How many groups to partition the quantization into
+        Returns:
+            quantized_input (`torch.FloatTensor`)
+                Quantized input
+        """
+        assert (min_value is None and max_value is None) or (min_value is not None and max_value is not None
+                                                             and num_groups == 1)
+        q_range = 2**num_bits
+        input_shape = input.shape
+        if min_value is None:
+            input = input.reshape(num_groups, -1)
+            max_input = torch.amax(torch.abs(input), dim=-1).view(num_groups, -1)
+        else:
+            max_input = torch.max(min_value.abs(), max_value).view(-1)
+
+        scale = 2 * max_input / q_range
+        output = (input / scale).round().clamp(-q_range // 2, q_range // 2 - 1) * scale
+        output = output.reshape(input_shape).contiguous()
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        grad_input = grad_output.clone()
+        return grad_input, None, None, None, None
+
+
+class AsymQuantizer(torch.autograd.Function):
+    """
+    Asymmetric quantization
+    """
+
+    @staticmethod
+    def forward(ctx, input, num_bits, min_value=None, max_value=None, num_groups=1):
+        """
+        Args:
+            inputs (`torch.FloatTensor`)
+                The input which needs to be quantized
+            num_bits (int, >=4)
+                Number of bits to use for quantization
+            min_value/max_value (torch.FloatTensor)
+                Used for static activation quantization
+            num_groups (int)
+                How many groups to partition the quantization into
+        Returns:
+            quantized_input (`torch.FloatTensor`)
+                Quantized input
+        """
+
+        assert (min_value is None and max_value is None) or (min_value is not None and max_value is not None
+                                                             and num_groups == 1)
+        q_range = 2**num_bits
+        input_shape = input.shape
+        if min_value is None:
+            input = input.reshape(num_groups, -1)
+            min_value = input.amin(dim=-1, keepdim=True)
+            max_value = input.amax(dim=-1, keepdim=True)
+
+        scale = (max_value - min_value) / q_range
+        zero_point = (min_value / scale).round() * scale
+
+        output = ((input - zero_point) / scale).round().clamp(0, q_range - 1) * scale + zero_point
+        output = output.reshape(input_shape).contiguous()
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        grad_input = grad_output.clone()
+        return grad_input, None, None, None, None
+
+
+class TernaryQuantizer(torch.autograd.Function):
+    """
+    Ternary quantization
+    """
+
+    @staticmethod
+    def forward(ctx, input, num_bits, min_value=None, max_value=None, num_groups=1):
+        """
+        Args:
+            inputs (`torch.FloatTensor`)
+                The input which needs to be quantized
+            num_bits (int)
+                Dummy variable
+            min_value/max_value (torch.FloatTensor)
+                Used for static activation quantization; for now they are dummy variable
+            num_groups (int)
+                How many groups to partition the quantization into
+        Returns:
+            quantized_input (`torch.FloatTensor`)
+                Quantized input
+        """
+
+        assert (min_value is None and max_value is None)
+        input_flat = input.reshape(num_groups, -1)
+        n = input_flat.shape[1]
+        m = input_flat.norm(p=1, dim=1).div(n)
+        thres = (0.7 * m).view(-1, 1)
+        pos = (input_flat > thres).type(input.type())
+        neg = (input_flat < -thres).type(input.type())
+        mask = (input_flat.abs() > thres).type(input.type())
+        alpha = ((mask * input_flat).abs().sum(dim=1) / mask.sum(dim=1)).view(-1, 1)
+        output = alpha * pos - alpha * neg
+        output = output.reshape(input.shape).contiguous()
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        grad_input = grad_output.clone()
+        return grad_input, None, None, None, None
+
+
+class BinaryQuantizer(torch.autograd.Function):
+    """
+    Binary quantization
+    """
+
+    @staticmethod
+    def forward(ctx, input, num_bits, min_value=None, max_value=None, num_groups=1):
+        """
+        Args:
+            inputs (`torch.FloatTensor`)
+                The input which needs to be quantized
+            num_bits (int)
+                Dummy variable
+            min_value/max_value (torch.FloatTensor)
+                Used for static activation quantization; for now they are dummy variable
+            num_groups (int)
+                How many groups to partition the quantization into
+        Returns:
+            quantized_input (`torch.FloatTensor`)
+                Quantized input
+        """
+
+        assert (min_value is None and max_value is None)
+        input_flat = input.reshape(num_groups, -1)
+        n = input_flat.shape[1]
+        m = input_flat.norm(p=1, dim=1, keepdim=True).div(n)
+        output = input_flat.sign().mul(m)
+        output = output.reshape(input.shape).contiguous()
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        grad_input = grad_output.clone()
+        return grad_input, None, None, None, None

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

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

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/runtime/fp16/fused_optimizer.py

@@ -0,0 +1,466 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""
+Copyright NVIDIA/apex
+This file is adapted from FP16_Optimizer in NVIDIA/apex
+"""
+
+import torch
+from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
+
+from deepspeed.runtime import DeepSpeedOptimizer
+from deepspeed.runtime.utils import get_global_norm, get_grad_norm, CheckOverflow, get_weight_norm, required_torch_version
+from deepspeed.runtime.fp16.loss_scaler import INITIAL_LOSS_SCALE, SCALE_WINDOW, MIN_LOSS_SCALE
+from deepspeed.utils import groups, logger, log_dist
+from deepspeed import comm as dist
+from deepspeed.checkpoint.constants import OPTIMIZER_STATE_DICT, CLIP_GRAD
+from deepspeed.accelerator import get_accelerator
+
+OVERFLOW_CHECK_TIMER = 'overflow_check'
+COMPUTE_NORM_TIMER = 'compute_norm'
+UNSCALE_AND_CLIP_TIMER = 'unscale_and_clip'
+BASIC_STEP_TIMER = 'basic_step'
+UPDATE_FP16_TIMER = 'update_fp16'
+
+OVERFLOW_TIMERS = [COMPUTE_NORM_TIMER, OVERFLOW_CHECK_TIMER]
+STEP_TIMERS = OVERFLOW_TIMERS + [UNSCALE_AND_CLIP_TIMER, BASIC_STEP_TIMER, UPDATE_FP16_TIMER]
+
+
+class FP16_Optimizer(DeepSpeedOptimizer):
+    """
+   FP16 Optimizer for training fp16 models. Handles loss scaling.
+
+   For usage example please see, TODO:  DeepSpeed V2 Tutorial
+    """
+
+    def __init__(self,
+                 init_optimizer,
+                 deepspeed=None,
+                 static_loss_scale=1.0,
+                 dynamic_loss_scale=False,
+                 initial_dynamic_scale=2**32,
+                 dynamic_loss_args=None,
+                 verbose=True,
+                 mpu=None,
+                 clip_grad=0.0,
+                 fused_adam_legacy=False,
+                 has_moe_layers=False,
+                 timers=None):
+
+        self.fused_adam_legacy = fused_adam_legacy
+        self.timers = timers
+        self.deepspeed = deepspeed
+        self.has_moe_layers = has_moe_layers
+        self.using_pipeline = self.deepspeed.pipeline_parallelism
+        if not get_accelerator().is_available():
+            raise SystemError("Cannot use fp16 without accelerator.")
+        self.optimizer = init_optimizer
+
+        # param flattened by groups
+        self.fp16_groups = []
+        self.fp16_groups_flat = []
+        self.fp32_groups_flat = []
+
+        self._global_grad_norm = 0.
+
+        # loop to deal with groups
+        for i, param_group in enumerate(self.optimizer.param_groups):
+            # push this group to list before modify
+            self.fp16_groups.append(param_group['params'])
+            # init fp16 weight buffer, flattened
+            self.fp16_groups_flat.append(_flatten_dense_tensors([p.clone().detach() for p in self.fp16_groups[i]]))
+            # set model fp16 weight to slices of flattened buffer
+            updated_params = _unflatten_dense_tensors(self.fp16_groups_flat[i], self.fp16_groups[i])
+            for p, q in zip(self.fp16_groups[i], updated_params):
+                p.data = q.data
+            # init master weight, flattened
+            self.fp32_groups_flat.append(self.fp16_groups_flat[i].clone().float().detach())
+            # modify optimizer of have flat master weight
+            self.fp32_groups_flat[i].requires_grad = True  # keep this in case internal optimizer uses it
+            param_group['params'] = [self.fp32_groups_flat[i]]
+
+        # we may have a way of fusing dynamic scale. Do not support for now
+        if dynamic_loss_scale:
+            self.dynamic_loss_scale = True
+            self.cur_iter = 0
+            self.last_overflow_iter = -1
+            self.scale_factor = 2
+
+            if dynamic_loss_args is None:
+                self.cur_scale = initial_dynamic_scale
+                self.scale_window = 1000
+                self.min_loss_scale = 1
+            else:
+                self.cur_scale = dynamic_loss_args[INITIAL_LOSS_SCALE]
+                self.scale_window = dynamic_loss_args[SCALE_WINDOW]
+                self.min_loss_scale = dynamic_loss_args[MIN_LOSS_SCALE]
+        else:
+            self.dynamic_loss_scale = False
+            self.cur_iter = 0
+            self.cur_scale = static_loss_scale
+        self.verbose = verbose
+
+        self.custom_loss_scaler = False
+        self.external_loss_scale = None
+
+        self.clip_grad = clip_grad
+        self.norm_type = 2
+
+        if required_torch_version(max_version=0.4):
+            self.clip_grad_norm = torch.nn.utils.clip_grad_norm
+        else:
+            self.clip_grad_norm = torch.nn.utils.clip_grad_norm_
+
+        #model parallel object
+        self.mpu = mpu
+
+        self.overflow = False
+        self.overflow_checker = CheckOverflow(self.fp16_groups, mpu=self.mpu, deepspeed=deepspeed)
+        self.initialize_optimizer_states()
+
+    def initialize_optimizer_states(self):
+        for i, group in enumerate(self.fp16_groups):
+            self.fp32_groups_flat[i].grad = torch.zeros(self.fp32_groups_flat[i].size(),
+                                                        device=self.fp32_groups_flat[i].device)
+
+        self.optimizer.step()
+
+        for i, group in enumerate(self.fp16_groups):
+            self.fp32_groups_flat[i].grad = None
+
+        return
+
+    def zero_grad(self, set_to_none=True):
+        """
+        Zero FP16 parameter grads.
+        """
+        # For speed, set model fp16 grad to None by default
+        for group in self.fp16_groups:
+            for p in group:
+                if set_to_none:
+                    p.grad = None
+                else:
+                    if p.grad is not None:
+                        p.grad.detach_()
+                        p.grad.zero_()
+
+    def step_fused_adam(self, closure=None):
+        """
+        Not supporting closure.
+        """
+
+        # First compute norm for all group so we know if there is overflow
+        grads_groups_flat = []
+        norm_groups = []
+        for i, group in enumerate(self.fp16_groups):
+            grads_groups_flat.append(
+                _flatten_dense_tensors([
+                    torch.zeros(p.size(), dtype=p.dtype, device=p.device) if p.grad is None else p.grad for p in group
+                ]))
+            norm_groups.append(get_weight_norm(grads_groups_flat[i], mpu=self.mpu))
+
+        self.overflow = self.overflow_checker.check_using_norm(norm_groups)
+        prev_scale = self.cur_scale
+        self._update_scale(self.overflow)
+
+        if self.overflow:
+            if self.verbose:
+                logger.info("[deepspeed] fp16 dynamic loss scale overflow! Skipping step. Attempted loss "
+                            "scale: {}, reducing to {}".format(prev_scale, self.cur_scale))
+            return self.overflow
+
+        scaled_grad_norm = get_global_norm(norm_list=norm_groups)
+
+        combined_scale = self.unscale_and_clip_grads(grads_groups_flat, scaled_grad_norm, apply_scale=False)
+
+        # Stash unscaled gradient norm
+        self._global_grad_norm = scaled_grad_norm / self.cur_scale
+
+        # norm is in fact norm*cur_scale
+        self.optimizer.step(grads=[[g] for g in grads_groups_flat],
+                            output_params=[[p] for p in self.fp16_groups_flat],
+                            scale=combined_scale,
+                            grad_norms=norm_groups)
+        # TODO: we probably don't need this? just to be safe
+        for i in range(len(norm_groups)):
+            updated_params = _unflatten_dense_tensors(self.fp16_groups_flat[i], self.fp16_groups[i])
+            for p, q in zip(self.fp16_groups[i], updated_params):
+                p.data = q.data
+        return self.overflow
+
+    def set_lr(self, lr):
+        """Set the learning rate."""
+        for param_group in self.optimizer.param_groups:
+            param_group["lr"] = lr
+
+    def get_lr(self):
+        """Return the current learning rate."""
+        return self.optimizer.param_groups[0]["lr"]
+
+    def override_loss_scale(self, loss_scale):
+        if loss_scale != self.external_loss_scale:
+            logger.info(f'[deepspeed] setting loss scale from {self.external_loss_scale} -> {loss_scale}')
+        self.custom_loss_scaler = True
+        self.external_loss_scale = loss_scale
+
+    def step(self, closure=None):
+        """
+        Not supporting closure.
+        """
+
+        if self.fused_adam_legacy:
+            return self.step_fused_adam()
+
+        # First determine if there is overflow.
+        self.timers(OVERFLOW_CHECK_TIMER).start()
+        fp16_params = []
+        for i, group in enumerate(self.fp16_groups):
+            fp16_params.extend([p for p in group if p.grad is not None])
+        self.overflow = self.overflow_checker.has_overflow(fp16_params)
+        self.timers(OVERFLOW_CHECK_TIMER).stop()
+        prev_scale = self.cur_scale
+        self._update_scale(self.overflow)
+        if self.overflow:
+            if self.verbose:
+                log_dist(
+                    "Overflow detected. Skipping step. Attempted loss "
+                    f"scale: {prev_scale}, reducing to {self.cur_scale}",
+                    ranks=[0])
+            # Clear gradients
+            for i, group in enumerate(self.fp16_groups):
+                for p in group:
+                    p.grad = None
+
+            self.timers.log(OVERFLOW_TIMERS)
+            return self.overflow
+
+        grads_groups_flat = []
+        for i, group in enumerate(self.fp16_groups):
+            data_type = self.fp32_groups_flat[i].dtype
+
+            grads_groups_flat.append(
+                _flatten_dense_tensors([
+                    torch.zeros(p.size(), dtype=data_type, device=p.device) if p.grad is None else p.grad.to(data_type)
+                    for p in group
+                ]))
+
+            for p in group:
+                p.grad = None
+
+            self.fp32_groups_flat[i].grad = grads_groups_flat[i]
+
+        self.timers(COMPUTE_NORM_TIMER).start()
+
+        all_groups_norm = get_grad_norm(self.fp32_groups_flat, mpu=self.mpu)
+
+        self.timers(COMPUTE_NORM_TIMER).stop()
+
+        if self.has_moe_layers:
+            all_groups_norm = self._get_norm_with_moe_layers(all_groups_norm)
+
+        scaled_global_grad_norm = get_global_norm(norm_list=[all_groups_norm])
+
+        # Stash unscaled gradient norm
+        self._global_grad_norm = scaled_global_grad_norm / self.cur_scale
+
+        self.timers(UNSCALE_AND_CLIP_TIMER).start()
+        self.unscale_and_clip_grads(grads_groups_flat, scaled_global_grad_norm)
+        self.timers(UNSCALE_AND_CLIP_TIMER).stop()
+
+        self.timers(BASIC_STEP_TIMER).start()
+        self.optimizer.step()
+        self.timers(BASIC_STEP_TIMER).stop()
+
+        #get rid of the fp32 gradients. Not needed anymore
+        for group in self.fp32_groups_flat:
+            group.grad = None
+
+        self.timers(UPDATE_FP16_TIMER).start()
+
+        for i in range(len(self.fp16_groups)):
+            updated_params = _unflatten_dense_tensors(self.fp32_groups_flat[i], self.fp16_groups[i])
+            for p, q in zip(self.fp16_groups[i], updated_params):
+                p.data.copy_(q.data)
+
+        self.timers(UPDATE_FP16_TIMER).stop()
+
+        self.timers.log(STEP_TIMERS)
+
+        return self.overflow
+
+    def _get_norm_with_moe_layers(self, all_groups_norm):
+        #all_groups_norm_old = all_groups_norm
+        # Need to allreduce (avg) the norms across different ranks because moe params will not be synced during allreduce
+        if self.using_pipeline:
+            pg = self.deepspeed.mpu.get_data_parallel_group()
+        else:
+            pg = groups._get_data_parallel_group()
+        scaled_norm = all_groups_norm * 1.0 / float(dist.get_world_size(group=pg))
+        scaled_norm_tensor = torch.tensor(scaled_norm, device=self.fp32_groups_flat[0].device, dtype=torch.float)
+        dist.all_reduce(scaled_norm_tensor, group=pg)
+        all_groups_norm = scaled_norm_tensor.item()
+        #print(f"old = {all_groups_norm_old} and new = {all_groups_norm} at rank: {deepspeed.comm.get_rank()}")
+        return all_groups_norm
+
+    def unscale_and_clip_grads(self, grad_groups_flat, total_norm, apply_scale=True):
+        # compute combined scale factor for this group
+        combined_scale = self.cur_scale
+        if self.clip_grad > 0.:
+            # norm is in fact norm*scale
+            clip = ((total_norm / self.cur_scale) + 1e-6) / self.clip_grad
+            if clip > 1:
+                combined_scale = clip * self.cur_scale
+
+        if apply_scale:
+            for grad in grad_groups_flat:
+                grad.data.mul_(1. / combined_scale)
+
+        return combined_scale
+
+    def backward(self, loss, create_graph=False, retain_graph=False):
+        """
+        :attr:`backward` performs the following steps:
+
+        1. fp32_loss = loss.float()
+        2. scaled_loss = fp32_loss*loss_scale
+        3. scaled_loss.backward(), which accumulates scaled gradients into the ``.grad`` attributes of the model's fp16 leaves
+        """
+        if self.custom_loss_scaler:
+            scaled_loss = self.external_loss_scale * loss
+            scaled_loss.backward()
+        else:
+            scaled_loss = (loss.float()) * self.cur_scale
+            scaled_loss.backward(create_graph=create_graph, retain_graph=retain_graph)
+
+    def _update_scale(self, skip):
+        if self.dynamic_loss_scale:
+            prev_scale = self.cur_scale
+            if skip:
+                self.cur_scale = max(self.cur_scale / self.scale_factor, self.min_loss_scale)
+                self.last_overflow_iter = self.cur_iter
+                if self.verbose:
+                    logger.info(f"\nGrad overflow on iteration {self.cur_iter}")
+                    logger.info(f"Reducing dynamic loss scale from {prev_scale} to {self.cur_scale}")
+            else:
+                # Ensure self.scale_window updates since last overflow
+                stable_interval = (self.cur_iter - self.last_overflow_iter) - 1
+                if (stable_interval > 0) and (stable_interval % self.scale_window == 0):
+                    self.cur_scale *= self.scale_factor
+                    if self.verbose:
+                        logger.info(f"No Grad overflow for {self.scale_window} iterations")
+                        logger.info(f"Increasing dynamic loss scale from {prev_scale} to {self.cur_scale}")
+        else:
+            if skip:
+                logger.info("Grad overflow on iteration: %s", self.cur_iter)
+                logger.info("Using static loss scale of: %s", self.cur_scale)
+        self.cur_iter += 1
+        return
+
+    # Promote state so it can be retrieved or set via "fp16_optimizer_instance.state"
+    def _get_state(self):
+        return self.optimizer.state
+
+    def _set_state(self, value):
+        self.optimizer.state = value
+
+    state = property(_get_state, _set_state)
+
+    # Promote param_groups so it can be retrieved or set via "fp16_optimizer_instance.param_groups"
+    # (for example, to adjust the learning rate)
+    def _get_param_groups(self):
+        return self.optimizer.param_groups
+
+    def _set_param_groups(self, value):
+        self.optimizer.param_groups = value
+
+    param_groups = property(_get_param_groups, _set_param_groups)
+
+    def state_dict(self):
+        """
+        Returns a dict containing the current state of this :class:`FP16_Optimizer` instance.
+        This dict contains attributes of :class:`FP16_Optimizer`, as well as the state_dict
+        of the contained Pytorch optimizer.
+        Example::
+            checkpoint = {}
+            checkpoint['model'] = model.state_dict()
+            checkpoint['optimizer'] = optimizer.state_dict()
+            torch.save(checkpoint, "saved.pth")
+        """
+        state_dict = {}
+        state_dict['dynamic_loss_scale'] = self.dynamic_loss_scale
+        state_dict['cur_scale'] = self.cur_scale
+        state_dict['cur_iter'] = self.cur_iter
+        if state_dict['dynamic_loss_scale']:
+            state_dict['last_overflow_iter'] = self.last_overflow_iter
+            state_dict['scale_factor'] = self.scale_factor
+            state_dict['scale_window'] = self.scale_window
+        state_dict[OPTIMIZER_STATE_DICT] = self.optimizer.state_dict()
+        state_dict['fp32_groups_flat'] = self.fp32_groups_flat
+        state_dict[CLIP_GRAD] = self.clip_grad
+        return state_dict
+
+    # Refresh fp32 master params from fp16 copies
+    def refresh_fp32_params(self):
+        for current, saved in zip(self.fp32_groups_flat, self.fp16_groups_flat):
+            current.data.copy_(saved.data)
+
+    def load_state_dict(self, state_dict, load_optimizer_states=True):
+        """
+        Loads a state_dict created by an earlier call to state_dict().
+        If ``fp16_optimizer_instance`` was constructed from some ``init_optimizer``,
+        whose parameters in turn came from ``model``, it is expected that the user
+        will call ``model.load_state_dict()`` before
+        ``fp16_optimizer_instance.load_state_dict()`` is called.
+        Example::
+            model = torch.nn.Linear(D_in, D_out).to(get_accelerator().device_name()).half()
+            optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
+            optimizer = FP16_Optimizer(optimizer, static_loss_scale = 128.0)
+            ...
+            checkpoint = torch.load("saved.pth")
+            model.load_state_dict(checkpoint['model'])
+            optimizer.load_state_dict(checkpoint['optimizer'])
+        """
+        # I think it should actually be ok to reload the optimizer before the model.
+        self.dynamic_loss_scale = state_dict['dynamic_loss_scale']
+        self.cur_scale = state_dict['cur_scale']
+        self.cur_iter = state_dict['cur_iter']
+        if state_dict['dynamic_loss_scale']:
+            self.last_overflow_iter = state_dict['last_overflow_iter']
+            self.scale_factor = state_dict['scale_factor']
+            self.scale_window = state_dict['scale_window']
+        if load_optimizer_states:
+            self.optimizer.load_state_dict(state_dict[OPTIMIZER_STATE_DICT])
+        self.clip_grad = state_dict[CLIP_GRAD]
+        # At this point, the optimizer's references to the model's fp32 parameters are up to date.
+        # The optimizer's hyperparameters and internal buffers are also up to date.
+        # However, the fp32 master copies of the model's fp16 params stored by the optimizer are still
+        # out of date.  There are two options.
+        # 1:  Refresh the master params from the model's fp16 params.
+        # This requires less storage but incurs precision loss.
+        # 2:  Save and restore the fp32 master copies separately.
+        # We choose option 2.
+        #
+        # Pytorch Optimizer.load_state_dict casts saved buffers (e.g. momentum) to the type and device
+        # of their associated parameters, because it's possible those buffers might not exist yet in
+        # the current optimizer instance.  In our case, as long as the current FP16_Optimizer has been
+        # constructed in the same way as the one whose state_dict we are loading, the same master params
+        # are guaranteed to exist, so we can just copy_() from the saved master params.
+        for current, saved in zip(self.fp32_groups_flat, state_dict['fp32_groups_flat']):
+            current.data.copy_(saved.data)
+
+    def __repr__(self):
+        return repr(self.optimizer)
+
+    # Promote loss scale so it can be retrieved or set via "fp16_optimizer_instance.loss_scale"
+    def _get_loss_scale(self):
+        if self.custom_loss_scaler:
+            return self.external_loss_scale
+        else:
+            return self.cur_scale
+
+    def _set_loss_scale(self, value):
+        self.loss_scaler.cur_scale = value
+
+    loss_scale = property(_get_loss_scale, _set_loss_scale)

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/runtime/fp16/loss_scaler.py

@@ -0,0 +1,270 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""
+Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+Taken and modified for DeepSpeed from:
+    https://github.com/NVIDIA/Megatron-LM/blob/master/fp16/loss_scaler.py
+Commit: 93ab4bea59dc5cbf97c079d313741866af4deac9
+"""
+
+import torch
+from deepspeed import comm as dist
+from deepspeed.utils import logger
+
+INITIAL_LOSS_SCALE = 'init_scale'
+SCALE_WINDOW = 'scale_window'
+DELAYED_SHIFT = 'delayed_shift'
+CONSECUTIVE_HYSTERESIS = 'consecutive_hysteresis'
+MIN_LOSS_SCALE = 'min_scale'
+
+
+# item() is a recent addition, so this helps with backward compatibility.
+def to_python_float(t):
+    if hasattr(t, 'item'):
+        return t.item()
+    return t[0]
+
+
+class LossScalerBase:
+    """LossScalarBase
+    Base class for a loss scaler
+    """
+
+    def __init__(self, cur_scale):
+        self.cur_scale = cur_scale
+        self.dynamic = False
+
+    @property
+    def loss_scale(self):
+        return self.cur_scale
+
+    def scale_gradient(self, module, grad_in, grad_out):
+        return tuple(self.loss_scale * g for g in grad_in)
+
+    def update_scale(self, overflow):
+        pass
+
+    def backward(self, loss, retain_graph=False):
+        scaled_loss = loss * self.loss_scale
+        scaled_loss.backward(retain_graph=retain_graph)
+        # print(f'LossScalerBackward: {scaled_loss=}')
+
+
+class LossScaler(LossScalerBase):
+    """
+    Class that manages a static loss scale.  This class is intended to interact with
+    :class:`FP16_Optimizer`, and should not be directly manipulated by the user.
+
+    Use of :class:`LossScaler` is enabled via the ``static_loss_scale`` argument to
+    :class:`FP16_Optimizer`'s constructor.
+
+    Args:
+        scale (float, optional, default=1.0):  The loss scale.
+    """
+
+    def __init__(self, scale=1):
+        super(LossScaler, self).__init__(scale)
+
+    # `params` is a list / generator of torch.Variable
+    def has_overflow(self, params):
+        return False
+
+    # `x` is a torch.Tensor
+    def _has_inf_or_nan(x):
+        return False
+
+
+class DynamicLossScaler(LossScalerBase):
+    """
+    Class that manages dynamic loss scaling.  It is recommended to use :class:`DynamicLossScaler`
+    indirectly, by supplying ``dynamic_loss_scale=True`` to the constructor of
+    :class:`FP16_Optimizer`.  However, it's important to understand how :class:`DynamicLossScaler`
+    operates, because the default options can be changed using the
+    the ``dynamic_loss_args`` argument to :class:`FP16_Optimizer`'s constructor.
+
+    Loss scaling is designed to combat the problem of underflowing gradients encountered at long
+    times when training fp16 networks.  Dynamic loss scaling begins by attempting a very high loss
+    scale.  Ironically, this may result in OVERflowing gradients.  If overflowing gradients are
+    encountered, :class:`DynamicLossScaler` informs :class:`FP16_Optimizer` that an overflow has
+    occurred.
+    :class:`FP16_Optimizer` then skips the update step for this particular iteration/minibatch,
+    and :class:`DynamicLossScaler` adjusts the loss scale to a lower value.
+    If a certain number of iterations occur without overflowing gradients detected,
+    :class:`DynamicLossScaler` increases the loss scale once more.
+    In this way :class:`DynamicLossScaler` attempts to "ride the edge" of
+    always using the highest loss scale possible without incurring overflow.
+
+    Args:
+        init_scale (float, optional, default=2**32):  Initial loss scale attempted by :class:`DynamicLossScaler.`
+        scale_factor (float, optional, default=2.0):  Factor used when adjusting the loss scale. If an overflow is encountered, the loss scale is readjusted to loss scale/``scale_factor``.  If ``scale_window`` consecutive iterations take place without an overflow, the loss scale is readjusted to loss_scale*``scale_factor``.
+        scale_window (int, optional, default=1000):  Number of consecutive iterations without an overflow to wait before increasing the loss scale.
+        consecutive_hysteresis (bool, optional, default=False): Whether to refill hysteresis if we reach an iteration that doesn't overflow
+    """
+
+    def __init__(self,
+                 init_scale=2**32,
+                 scale_factor=2.,
+                 scale_window=1000,
+                 min_scale=1,
+                 delayed_shift=1,
+                 consecutive_hysteresis=False,
+                 raise_error_at_min_scale=True,
+                 dtype=torch.half):
+        super(DynamicLossScaler, self).__init__(init_scale)
+        self.cur_iter = 0
+        self.last_overflow_iter = -1
+        self.scale_factor = scale_factor
+        self.scale_window = scale_window
+        self.min_scale = min_scale
+        self.delayed_shift = delayed_shift
+        self.cur_hysteresis = delayed_shift
+        self.consecutive_hysteresis = consecutive_hysteresis
+        self.raise_error_at_min_scale = raise_error_at_min_scale
+        self.dynamic = True
+        self.dtype = dtype
+
+    # `params` is a list / generator of torch.Variable
+    def has_overflow_serial(self, params):
+        for p in params:
+            if p.grad is not None and self._has_inf_or_nan(p.grad.data):
+                return True
+
+        return False
+
+    # `x` is a torch.Tensor
+    def _has_inf_or_nan(x):
+        try:
+            # if x is half, the .float() incurs an additional deep copy, but it's necessary if
+            # Pytorch's .sum() creates a one-element tensor of the same type as x
+            # (which is true for some recent version of pytorch).
+            cpu_sum = float(x.float().sum())
+            # More efficient version that can be used if .sum() returns a Python scalar
+            # cpu_sum = float(x.sum())
+        except RuntimeError as instance:
+            # We want to check if inst is actually an overflow exception.
+            # RuntimeError could come from a different error.
+            # If so, we still want the exception to propagate.
+            if "value cannot be converted" not in instance.args[0]:
+                raise
+            return True
+        else:
+            if cpu_sum in [float('inf'), -float('inf')] or cpu_sum != cpu_sum:
+                return True
+            return False
+
+    # `overflow` is boolean indicating whether the gradient overflowed
+    def update_scale(self, overflow):
+        if overflow:
+            # self.cur_scale /= self.scale_factor
+            if self.delayed_shift == 1 or self.cur_hysteresis == 1:
+                if (self.cur_scale == self.min_scale) and self.raise_error_at_min_scale:
+                    raise Exception(
+                        "Current loss scale already at minimum - cannot decrease scale anymore. Exiting run.")
+                else:
+                    next_scale = max(self.cur_scale / self.scale_factor, self.min_scale)
+                    if dist.get_rank() == 0:
+                        overflow_msg = f"[deepspeed] OVERFLOW! Rank {dist.get_rank()} Skipping step."
+                        if self.dtype == torch.half:
+                            overflow_msg += f" Attempted loss scale: {int(self.cur_scale)}, reducing to {int(next_scale)}"
+                        logger.info(overflow_msg)
+                    self.cur_scale = next_scale
+            else:
+                if dist.get_rank() == 0:
+                    overflow_msg = f"[deepspeed] OVERFLOW! Rank {dist.get_rank()} Skipping step."
+                    if self.dtype == torch.half:
+                        overflow_msg += f" Attempted loss scale: {int(self.cur_scale)}, but hysteresis is {self.cur_hysteresis}. Reducing hysteresis to {self.cur_hysteresis-1}"
+                    logger.info(overflow_msg)
+                self.cur_hysteresis -= 1
+            self.last_overflow_iter = self.cur_iter
+        else:
+            if self.consecutive_hysteresis:
+                if dist.get_rank() == 0:
+                    hysteresis_msg = f"Consecutive hysteresis is enabled. Restoring hysteresis to {self.delayed_shift}"
+                    logger.info(hysteresis_msg)
+                self.cur_hysteresis = self.delayed_shift
+            if (self.cur_iter - self.last_overflow_iter) % self.scale_window == 0:
+                if not self.consecutive_hysteresis:
+                    self.cur_hysteresis = self.delayed_shift
+                self.cur_scale *= self.scale_factor
+        self.cur_iter += 1
+
+
+# Although loss scaling is only defined for fp16, yet for backwards compatibility
+# we still create a scaler for other dtypes (fp32, bf16) which does not perform any scaling.
+def CreateLossScaler(dtype, static_loss_scale, dynamic_scaling, dynamic_loss_args):
+    if dtype == torch.half and dynamic_scaling:
+        if dynamic_loss_args is None:
+            return DynamicLossScaler(dtype=dtype)
+        return DynamicLossScaler(dtype=dtype, **dynamic_loss_args)
+
+    loss_scale_value = static_loss_scale if dtype == torch.half else 1.0
+    return LossScaler(scale=loss_scale_value)
+
+
+##############################################################
+# Example usage below here -- assuming it's in a separate file
+##############################################################
+"""
+TO-DO separate out into an example.
+if __name__ == "__main__":
+    import torch
+    from torch.autograd import Variable
+    from dynamic_loss_scaler import DynamicLossScaler
+
+    # N is batch size; D_in is input dimension;
+    # H is hidden dimension; D_out is output dimension.
+    N, D_in, H, D_out = 64, 1000, 100, 10
+
+    # Create random Tensors to hold inputs and outputs, and wrap them in Variables.
+    x = Variable(torch.randn(N, D_in), requires_grad=False)
+    y = Variable(torch.randn(N, D_out), requires_grad=False)
+
+    w1 = Variable(torch.randn(D_in, H), requires_grad=True)
+    w2 = Variable(torch.randn(H, D_out), requires_grad=True)
+    parameters = [w1, w2]
+
+    learning_rate = 1e-6
+    optimizer = torch.optim.SGD(parameters, lr=learning_rate)
+    loss_scaler = DynamicLossScaler()
+
+    for t in range(500):
+        y_pred = x.mm(w1).clamp(min=0).mm(w2)
+        loss = (y_pred - y).pow(2).sum() * loss_scaler.loss_scale
+        print('Iter {} loss scale: {}'.format(t, loss_scaler.loss_scale))
+        print('Iter {} scaled loss: {}'.format(t, loss.data[0]))
+        print('Iter {} unscaled loss: {}'.format(t, loss.data[0] / loss_scaler.loss_scale))
+
+        # Run backprop
+        optimizer.zero_grad()
+        loss.backward()
+
+        # Check for overflow
+        has_overflow = DynamicLossScaler.has_overflow(parameters)
+
+        # If no overflow, unscale grad and update as usual
+        if not has_overflow:
+            for param in parameters:
+                param.grad.data.mul_(1. / loss_scaler.loss_scale)
+            optimizer.step()
+        # Otherwise, don't do anything -- ie, skip iteration
+        else:
+            print('fp16 dynamic loss scale overflow!')
+
+        # Update loss scale for next iteration
+        loss_scaler.update_scale(has_overflow)
+
+"""

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/runtime/fp16/onebit/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .adam import OnebitAdam
+from .lamb import OnebitLamb
+from .zoadam import ZeroOneAdam

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/runtime/fp16/onebit/lamb.py

@@ -0,0 +1,443 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import types
+import torch
+import numpy as np
+from deepspeed import comm as dist
+from deepspeed.runtime.utils import required_torch_version
+from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
+from deepspeed.accelerator import get_accelerator
+
+
+class OnebitLamb(torch.optim.Optimizer):
+    """Implements the 1-bit Lamb algorithm. Currently GPU-only.
+    For usage example please see https://www.deepspeed.ai/tutorials/onebit-lamb/
+    For technical details please see our paper https://arxiv.org/abs/2104.06069.
+
+    Arguments:
+        params (iterable): iterable of parameters to optimize or dicts defining
+            parameter groups.
+        lr (float, optional): learning rate. (default: 1e-3)
+        freeze_step (int, optional): Number of steps for warmup (uncompressed)
+            stage before we start using compressed communication. (default 100000)
+        betas (Tuple[float, float], optional): coefficients used for computing
+            running averages of gradient and its square. (default: (0.9, 0.999))
+        eps (float, optional): term added to the denominator to improve
+            numerical stability. (default: 1e-8)
+        weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
+        max_coeff(float, optional): maximum value of the lamb coefficient (default: 10.0)
+        min_coeff(float, optional): minimum value of the lamb coefficient (default: 0.01)
+        amsgrad (boolean, optional): whether to use the AMSGrad variant of this
+            algorithm from the paper `On the Convergence of Adam and Beyond`_
+            (default: False) NOT SUPPORTED in 1-bit Lamb!
+        eps_inside_sqrt (boolean, optional): in the 'update parameters' step,
+            adds eps to the bias-corrected second moment estimate before
+            evaluating square root instead of adding it to the square root of
+            second moment estimate as in the original paper. (default: False)
+        cuda_aware (boolean, required): Set True if the underlying MPI implementation
+            supports CUDA-Aware communication. (default: False)
+        comm_backend_name (string, optional): Set to 'mpi' if needed. (default: 'nccl')
+        coeff_beta (float, optional): coefficient used for computing
+            running averages of lamb coefficient (default: 0.9) note that you may want to
+            increase or decrease this beta depending on the freeze_step you choose, as
+            1/(1 - coeff_beta) should be smaller than or equal to freeze_step
+        factor_max (float, optional): maximum value of scaling factor to the frozen lamb
+            coefficient during compression stage (default: 4.0)
+        factor_min (float, optional): minimum value of scaling factor to the frozen lamb
+            coefficient during compression stage (default: 0.5)
+        factor_threshold (float, optional): threshold of how much the scaling factor can
+            fluctuate between steps (default: 0.1)
+    .. _Large Batch Optimization for Deep Learning\\: Training BERT in 76 minutes:
+        https://arxiv.org/abs/1904.00962
+    .. _Adam\\: A Method for Stochastic Optimization:
+        https://arxiv.org/abs/1412.6980
+    .. _On the Convergence of Adam and Beyond:
+        https://openreview.net/forum?id=ryQu7f-RZ
+    """
+
+    def __init__(self,
+                 params,
+                 deepspeed=None,
+                 lr=1e-3,
+                 freeze_step=100000,
+                 bias_correction=True,
+                 betas=(0.9, 0.999),
+                 eps=1e-8,
+                 eps_inside_sqrt=False,
+                 weight_decay=0.,
+                 max_grad_norm=0.,
+                 max_coeff=10.0,
+                 min_coeff=0.01,
+                 amsgrad=False,
+                 cuda_aware=False,
+                 comm_backend_name='nccl',
+                 coeff_beta=0.9,
+                 factor_max=4.0,
+                 factor_min=0.5,
+                 factor_threshold=0.1):
+
+        if amsgrad:
+            raise RuntimeError('1-bit Lamb does not support the AMSGrad variant.')
+
+        defaults = dict(lr=lr,
+                        bias_correction=bias_correction,
+                        betas=betas,
+                        eps=eps,
+                        weight_decay=weight_decay,
+                        max_grad_norm=max_grad_norm,
+                        max_coeff=max_coeff,
+                        min_coeff=min_coeff)
+
+        super(OnebitLamb, self).__init__(params, defaults)
+        self.eps_mode = 0 if eps_inside_sqrt else 1
+        self.deepspeed = deepspeed
+        self.lamb_freeze_key = False
+        self.initialize = False
+        self.freeze_step = freeze_step
+        self.cuda_aware = cuda_aware
+        self.coeff_beta = coeff_beta
+        self.factor_max = factor_max
+        self.factor_min = factor_min
+        self.factor_threshold = factor_threshold
+        self.using_pipeline = False
+
+        self.comm_backend_name = comm_backend_name
+
+        assert dist.is_initialized(), "Please initialize the torch distributed backend."
+        # Empty initializer. Set handle based on the comm backend as follows.
+        self.comm_backend_handle = None
+        if self.comm_backend_name == 'nccl':
+            assert (
+                required_torch_version(min_version=1.8)
+            ), "Please use torch 1.8 or greater to enable NCCL backend in 1-bit Adam. Alternatively, please specify 'mpi' as the 'comm_backend_name' in config file to proceed with the MPI backend"
+            from deepspeed.runtime.comm.nccl import NcclBackend
+            self.using_pipeline = hasattr(self.deepspeed, 'pipeline_enable_backward_allreduce')
+            self.comm_backend_handle = NcclBackend(self.deepspeed.mpu)
+        elif self.comm_backend_name == 'mpi':
+            from deepspeed.runtime.comm.mpi import MpiBackend
+            self.comm_backend_handle = MpiBackend(cuda_aware)
+        elif self.comm_backend_name == 'hccl':
+            from deepspeed.runtime.comm.hccl import HcclBackend
+            self.using_pipeline = hasattr(self.deepspeed, 'pipeline_enable_backward_allreduce')
+            self.comm_backend_handle = HcclBackend(self.deepspeed.mpu)
+
+        self.size = self.comm_backend_handle.size
+
+        self.divider = int(self.size * 8 / np.gcd(self.size, 8))
+
+        self.exp_avg_flat = []
+        self.dummy_exp_avg = {}
+        self.corrected_tensor_sizes = []
+        self.server_chunk_sizes = []
+        self.worker_errors = []
+        self.server_errors = []
+
+        self.lamb_coeffs = []
+
+    def step(self, closure=None, grads=None):
+        """Performs a single optimization step.
+        Arguments:
+            closure (callable, optional): A closure that reevaluates the model
+                and returns the loss.
+            grads (list of tensors, optional): weight gradient to use for the
+                optimizer update. If gradients have type torch.half, parameters
+                are expected to be in type torch.float. (default: None)
+        """
+        loss = None
+        if closure is not None:
+            loss = closure()
+
+        if grads is None:
+            grads_group = [None] * len(self.param_groups)
+        # backward compatibility
+        # assuming a list/generator of parameter means single group
+        elif isinstance(grads, types.GeneratorType):
+            grads_group = [grads]
+        elif type(grads[0]) != list:
+            grads_group = [grads]
+        else:
+            grads_group = grads
+
+        # remove the previous stats
+        del self.lamb_coeffs[:]
+
+        if self.lamb_freeze_key:
+            exp_avg_last_step = []
+            for group in self.param_groups:
+                exp_avg_last_step.append([self.state[p]['exp_avg'].detach().clone() for p in group['params']])
+            if 'scaling_coeff' not in self.state[self.param_groups[0]['params'][0]]:
+                # Compute the scaling_coeff for each momentum at the end of warmup stage.
+                # This is used to reduce compression error during compression stage.
+                momentum_scales = []
+                for group in self.param_groups:
+                    momentum_scales.append([(torch.linalg.norm(self.state[p]['exp_avg']) /
+                                             np.sqrt(torch.numel(self.state[p]['exp_avg']))).item()
+                                            for p in group['params']])
+                united_scale = sum([sum(x) for x in momentum_scales]) / sum([len(x) for x in momentum_scales])
+                for i, group in enumerate(self.param_groups):
+                    for j, p in enumerate(group['params']):
+                        self.state[p]['scaling_coeff'] = united_scale / momentum_scales[i][j]
+
+        for group, grads_this_group in zip(self.param_groups, grads_group):
+            if grads_this_group is None:
+                grads_this_group = [None] * len(group['params'])
+
+            bias_correction = 1 if group['bias_correction'] else 0
+
+            for p, grad in zip(group['params'], grads_this_group):
+                if p.grad is None and grad is None:
+                    continue
+                if grad is None:
+                    grad = p.grad.data
+                if grad.is_sparse:
+                    raise RuntimeError('1-bit Lamb does not support sparse gradients')
+
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0 or (len(state) == 1 and 'scaling_coeff' in state.keys()):
+                    state['step'] = 0
+                    state['lamb_coeff_freeze'] = 0.0
+                    state['last_factor'] = 1.0
+                    # Exponential moving average of gradient values
+                    state['exp_avg'] = torch.zeros_like(p.data)
+                    # Exponential moving average of squared gradient values
+                    state['exp_avg_sq'] = torch.zeros_like(p.data)
+                    state['exp_avg_sq_fresh'] = torch.zeros_like(p.data)
+
+                if not self.initialize:
+                    self.lamb_freeze_key = True
+
+                exp_avg, exp_avg_sq, exp_avg_sq_fresh = state['exp_avg'], state['exp_avg_sq'], state[
+                    'exp_avg_sq_fresh']
+                beta1, beta2 = group['betas']
+                max_coeff = group['max_coeff']
+                min_coeff = group['min_coeff']
+
+                state['step'] += 1
+
+                if self.lamb_freeze_key is False:
+                    # warmup stage, baseline Lamb optimization
+                    exp_avg.mul_(beta1).add_(1 - beta1, grad)
+                    exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)
+                    if state['step'] == self.freeze_step:
+                        exp_avg_sq_fresh.data = exp_avg_sq.detach().clone()
+                    grad = None
+                    if self.initialize:
+                        weight_norm = p.data.pow(2).sum().sqrt()
+                        update = exp_avg / (exp_avg_sq.sqrt() + group['eps'])
+                        if group['weight_decay'] > 0.0:
+                            update += group['weight_decay'] * p.data
+                        update_norm = update.pow(2).sum().sqrt()
+                        lamb_coeff = 1.0
+                        if weight_norm != 0 and update_norm != 0:
+                            lamb_coeff = (weight_norm / update_norm).item()
+                            if lamb_coeff > max_coeff:
+                                lamb_coeff = max_coeff
+                            if lamb_coeff < min_coeff:
+                                lamb_coeff = min_coeff
+                        if lamb_coeff != 1.0:
+                            state['lamb_coeff_freeze'] = self.coeff_beta * state['lamb_coeff_freeze'] + (
+                                1 - self.coeff_beta) * lamb_coeff
+                        self.lamb_coeffs.append(lamb_coeff)
+                        with torch.no_grad():
+                            p.add_(-group['lr'] * lamb_coeff * update)
+                else:
+                    # compression stage, update each momentum locally, then
+                    # communicate based on the compressed_allreduce below
+                    if self.initialize:
+                        exp_avg.mul_(beta1).add_(1 - beta1, grad)
+                        exp_avg.mul_(self.state[p]['scaling_coeff'])
+                    grad = None
+
+        # init fused momentum
+        if len(self.exp_avg_flat) == 0:
+            momentum_groups = []
+            tensor_size = 0
+            for group in self.param_groups:
+                for p in group['params']:
+                    momentum_groups.append(self.state[p]['exp_avg'])
+                    tensor_size += torch.numel(p.data)
+            corrected_tensor_size = tensor_size
+            if tensor_size % (self.size * self.divider) != 0:
+                difference = ((self.size * self.divider) - (tensor_size % (self.size * self.divider)))
+                corrected_tensor_size += difference
+                self.dummy_exp_avg[0] = torch.zeros(difference, device=momentum_groups[0].data.device)
+                momentum_groups.append(self.dummy_exp_avg[0])
+            self.corrected_tensor_sizes.append(corrected_tensor_size)
+            self.server_chunk_sizes.append(corrected_tensor_size // self.size)
+
+            self.exp_avg_flat.append(_flatten_dense_tensors([p.detach().clone() for p in momentum_groups]))
+            updated_params = _unflatten_dense_tensors(self.exp_avg_flat[0], momentum_groups)
+            for p, q in zip(momentum_groups, updated_params):
+                p.data = q.data
+
+        if self.initialize and len(self.worker_errors) == 0:
+            get_accelerator().empty_cache()
+            for i in range(len(self.exp_avg_flat)):
+                self.worker_errors.append(
+                    torch.zeros(self.corrected_tensor_sizes[i], device=self.exp_avg_flat[i].device))
+                self.server_errors.append(torch.zeros(self.server_chunk_sizes[i], device=self.exp_avg_flat[i].device))
+            get_accelerator().empty_cache()
+
+        if self.lamb_freeze_key:
+            if self.size > 1:
+                for i in range(len(self.exp_avg_flat)):
+                    if not self.initialize:
+                        get_accelerator().empty_cache()
+                        self.worker_errors.append(
+                            torch.zeros(self.corrected_tensor_sizes[i], device=self.exp_avg_flat[i].device))
+                        self.server_errors.append(
+                            torch.zeros(self.server_chunk_sizes[i], device=self.exp_avg_flat[i].device))
+                        get_accelerator().empty_cache()
+                        if dist.get_rank() == 0:
+                            print("Cupy Buffers Initialized Successfully.")
+
+                        self.comm_backend_handle.compressed_allreduce(self.exp_avg_flat[i], self.worker_errors[0],
+                                                                      self.server_errors[0], self.deepspeed.local_rank)
+
+                        if dist.get_rank() == 0:
+                            print('Pop out errors', flush=True)
+                        del self.worker_errors[:]
+                        del self.server_errors[:]
+                    else:
+                        self.comm_backend_handle.compressed_allreduce(self.exp_avg_flat[i], self.worker_errors[i],
+                                                                      self.server_errors[i], self.deepspeed.local_rank)
+
+        if self.lamb_freeze_key and self.initialize:
+            for i, group in enumerate(self.param_groups):
+                bias_correction = 1 if group['bias_correction'] else 0
+
+                for j, p in enumerate(group['params']):
+                    state = self.state[p]
+                    exp_avg, exp_avg_sq, exp_avg_sq_fresh = state['exp_avg'], state['exp_avg_sq'], state[
+                        'exp_avg_sq_fresh']
+                    beta1, beta2 = group['betas']
+                    exp_avg.div_(self.state[p]['scaling_coeff'])
+                    # Because 1-bit compression cannot represent exact zero, it is required to
+                    # provide a momentum mask for those params that have constant exact zeros in their
+                    # momentums, otherwise the compression error would keep accumulating.
+                    # For example, for BERT pre-training seq 128, bert.embeddings.position_embeddings.weight
+                    # always have exact zeros in its momentum for row 129 to 512, because it only
+                    # learns up to seq length 128 while the model supports up to 512 seq length.
+                    # (See example in DeepSpeedExamples/bing_bert/deepspeed_train.py about how
+                    # to add this exp_avg_mask for BERT pre-training.)
+                    if 'exp_avg_mask' in group:
+                        if exp_avg.device != group['exp_avg_mask'].device:
+                            group['exp_avg_mask'] = group['exp_avg_mask'].to(device=exp_avg.device)
+                        exp_avg.mul_(group['exp_avg_mask'])
+
+                    grad_reconstruct = ((exp_avg - exp_avg_last_step[i][j] * beta1) / (1 - beta1))
+                    exp_avg_sq_fresh.mul_(beta2).addcmul_(1 - beta2, grad_reconstruct, grad_reconstruct)
+                    denom = exp_avg_sq.sqrt() + group['eps']
+                    update_prelim = exp_avg / denom
+
+                    if group['weight_decay'] > 0.0:
+                        update = update_prelim + group['weight_decay'] * p.data
+                    else:
+                        update = update_prelim
+
+                    lamb_coeff = 1.0
+                    update_norm = update.pow(2).sum().sqrt()
+                    denom_real = exp_avg_sq_fresh.sqrt() + group['eps']
+                    factor = (denom / denom_real).max().item()
+                    if group['weight_decay'] > 0.0:
+                        update_ratio = min(1.0, (update_prelim.pow(2).sum().sqrt() / update_norm).item())
+                        factor = factor * update_ratio + (1.0 - update_ratio)
+                    if factor > self.factor_max:
+                        factor = self.factor_max
+                    if factor < self.factor_min:
+                        factor = self.factor_min
+                    if factor > state['last_factor'] * (1.0 + self.factor_threshold):
+                        factor = state['last_factor'] * (1.0 + self.factor_threshold)
+                    if factor < state['last_factor'] * (1.0 - self.factor_threshold):
+                        factor = state['last_factor'] * (1.0 - self.factor_threshold)
+                    state['last_factor'] = factor
+                    lamb_coeff = state['lamb_coeff_freeze'] * factor
+                    self.lamb_coeffs.append(lamb_coeff)
+                    with torch.no_grad():
+                        p.add_(-group['lr'] * lamb_coeff * update)
+            del exp_avg_last_step[:]
+            exp_avg_last_step = None
+
+        if not self.initialize:
+            self.lamb_freeze_key = False
+            self.initialize = True
+            print(f"Finished the initialization step at rank {dist.get_rank()}")
+            return loss
+
+        if self.lamb_freeze_key is False:
+            if state['step'] >= self.freeze_step:
+                print('OnebitLamb - starting compressed communication')
+                self.lamb_freeze_key = True
+                if self.using_pipeline:
+                    self.deepspeed.pipeline_enable_backward_allreduce = False
+                else:
+                    self.deepspeed.enable_backward_allreduce = False
+
+        return loss
+
+    def load_state_dict(self, state_dict):
+        """
+        Overrides load_state_dict() to add special handling when loading checkpoints
+        """
+        # Because at different stage exp_avg_mask may change (e.g.,
+        # BERT pre-training seqlen 128 and 512 ), we don't use the exp_avg_mask
+        # in checkpoints but always use the one user provided in training script.
+        # (See example in DeepSpeedExamples/bing_bert/deepspeed_train.py.)
+        # Thus here we keep the exp_avg_mask unchanged when loading checkpoint
+        for i, group in enumerate(self.param_groups):
+            if 'exp_avg_mask' in group:
+                state_dict['param_groups'][i]['exp_avg_mask'] = group['exp_avg_mask']
+            elif 'exp_avg_mask' not in group and 'exp_avg_mask' in state_dict['param_groups'][i]:
+                state_dict['param_groups'][i].pop('exp_avg_mask')
+        super().load_state_dict(state_dict)
+        # need to reset the fused momentum since loading states will break the linking
+        del self.exp_avg_flat[:]
+        self.dummy_exp_avg.clear()
+        del self.corrected_tensor_sizes[:]
+        del self.server_chunk_sizes[:]
+        if self.state[self.param_groups[0]['params'][0]]['step'] < self.freeze_step:
+            if dist.get_rank() == 0:
+                print("Checkpoint loaded and OnebitLamb warmup stage starts/continues.")
+            if self.lamb_freeze_key is True:
+                self.lamb_freeze_key = False
+                if self.using_pipeline:
+                    self.deepspeed.pipeline_enable_backward_allreduce = True
+                else:
+                    self.deepspeed.enable_backward_allreduce = True
+            for group in self.param_groups:
+                for p in group['params']:
+                    self.state[p]['lamb_coeff_freeze'] = 0.0
+                    self.state[p]['last_factor'] = 1.0
+                    if 'scaling_coeff' in self.state[p]:
+                        self.state[p].pop('scaling_coeff')
+        else:
+            if dist.get_rank() == 0:
+                print("Checkpoint loaded and OnebitLamb compression stage starts/continues.")
+            if self.lamb_freeze_key is False:
+                self.lamb_freeze_key = True
+                if self.using_pipeline:
+                    self.deepspeed.pipeline_enable_backward_allreduce = False
+                else:
+                    self.deepspeed.enable_backward_allreduce = False
+        # We reset the compression errors when loading checkpoints for 3 reasons:
+        # 1) The worker and server error at each GPU are distinct, so in current implementation
+        # only rank 0's errors are saved in the checkpoint. Thus we have to reset the errors.
+        # If we want to save them correctly we need O(num_gpu*model_size) memory in order to
+        # gather all the error, which is a very large memory requirement. It's possible to save
+        # them in a distributed way, but it will make the checkpoint saving/loading much more complicated.
+        # 2) Even if we are able to save the compression errors correctly, you need to have the
+        # exact same number of GPUs in order to load them correctly.
+        # 3) We verified on BERT pre-training that occasionally resetting the compression error
+        # at checkpoint loading does not affect the convergence.
+        # However, please avoid frequent checkpoint loading which could break the error
+        # compensation mechanism thus affect the convergence.
+        del self.worker_errors[:]
+        del self.server_errors[:]
+
+    def get_lamb_coeffs(self):
+        return self.lamb_coeffs

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/runtime/fp16/onebit/zoadam.py

@@ -0,0 +1,359 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import types
+import torch
+import numpy as np
+from deepspeed.accelerator import get_accelerator
+from deepspeed.runtime.utils import required_torch_version
+from deepspeed import comm as dist
+
+
+class ZeroOneAdam(torch.optim.Optimizer):
+    """Implements the 0/1 Adam algorithm. Currently GPU-only.
+    For usage example please see https://www.deepspeed.ai/tutorials/zero-one-adam/
+    For technical details please read https://arxiv.org/abs/2202.06009
+    Arguments:
+        params (iterable): iterable of parameters to optimize or dicts defining
+            parameter groups.
+        lr (float, optional): learning rate. (default: 1e-3)
+        betas (Tuple[float, float], optional): coefficients used for computing
+            running averages of gradient and its square. (default: (0.9, 0.999))
+        eps (float, optional): term added to the denominator to improve
+            numerical stability. (default: 1e-8)
+        weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
+        var_freeze_step (int, optional): The latest step to update the variance,
+            using the notation from https://arxiv.org/abs/2202.06009, it denotes the
+            max{i|i in T_v}. Note that this is different from the freeze step from the
+            1-bit Adam. The var_freeze_step is usually the end of the learning rate warmup
+            and thus does not require tuning. (default: 100000)
+        var_update_scaler (int, optional): The interval to update the variance. Note that
+            the update policy for variance follows an exponential rule, where var_update_scaler
+            denotes the kappa in the 0/1 Adam paper. (default: 16)
+        local_step_scaler (int, optional): The interval to scale the local steps interval
+            according to the learning rate policy. (default: 32678)
+        local_step_clipper (int, optional): The largest interval for local steps with
+            learning rate policy. This corresponds to the variable H in the 0/1 Adam paper.
+            (default: 16)
+        amsgrad (boolean, optional): whether to use the AMSGrad variant of this
+            algorithm from the paper `On the Convergence of Adam and Beyond`_
+            (default: False) NOT SUPPORTED in 0/1 Adam!
+        eps_inside_sqrt (boolean, optional): in the 'update parameters' step,
+            adds eps to the bias-corrected second moment estimate before
+            evaluating square root instead of adding it to the square root of
+            second moment estimate as in the original paper. (default: False)
+        cuda_aware (boolean, required): Set True if the underlying MPI implementation
+            supports CUDA-Aware communication. (default: False)
+        comm_backend_name (string, optional): Set to 'mpi' if needed. (default: 'nccl')
+    .. _Adam\\: A Method for Stochastic Optimization:
+        https://arxiv.org/abs/1412.6980
+    .. _On the Convergence of Adam and Beyond:
+        https://openreview.net/forum?id=ryQu7f-RZ
+    """
+
+    def __init__(self,
+                 params,
+                 deepspeed=None,
+                 lr=1e-3,
+                 bias_correction=True,
+                 betas=(0.9, 0.999),
+                 eps=1e-8,
+                 eps_inside_sqrt=False,
+                 weight_decay=0.,
+                 max_grad_norm=0.,
+                 var_freeze_step=100000,
+                 var_update_scaler=16,
+                 local_step_scaler=32678,
+                 local_step_clipper=16,
+                 amsgrad=False,
+                 cuda_aware=False,
+                 comm_backend_name='nccl'):
+
+        if amsgrad:
+            raise RuntimeError('0/1 Adam does not support the AMSGrad variant.')
+
+        defaults = dict(lr=lr,
+                        bias_correction=bias_correction,
+                        betas=betas,
+                        eps=eps,
+                        weight_decay=weight_decay,
+                        max_grad_norm=max_grad_norm)
+
+        super(ZeroOneAdam, self).__init__(params, defaults)
+        self.eps_mode = 0 if eps_inside_sqrt else 1
+        self.deepspeed = deepspeed
+        self.initialize = False
+        self.cuda_aware = cuda_aware
+        self.using_pipeline = False
+
+        self.var_freeze_step = var_freeze_step
+        self.var_update_scaler = var_update_scaler
+        self.local_step_scaler = local_step_scaler
+        self.local_step_clipper = local_step_clipper
+        self.freeze_key = False
+        self.reinitial_error_buffer = False
+
+        self.comm_backend_name = comm_backend_name
+
+        assert dist.is_initialized(), "Please initialize the torch distributed backend."
+        # Empty initializer. Set handle based on the comm backend as follows.
+        self.comm_backend_handle = None
+        if self.comm_backend_name == 'nccl':
+            assert (
+                required_torch_version(min_version=1.8)
+            ), "Please use torch 1.8 or greater to enable NCCL backend in 0/1 Adam. Alternatively, please specify 'mpi' as the 'comm_backend_name' in config file to proceed with the MPI backend"
+            from deepspeed.runtime.comm.nccl import NcclBackend
+            self.using_pipeline = hasattr(self.deepspeed, 'pipeline_enable_backward_allreduce')
+            self.comm_backend_handle = NcclBackend(self.deepspeed.mpu)
+        elif self.comm_backend_name == 'mpi':
+            from deepspeed.runtime.comm.mpi import MpiBackend
+            self.comm_backend_handle = MpiBackend(cuda_aware)
+        elif self.comm_backend_name == 'hccl':
+            from deepspeed.runtime.comm.hccl import HcclBackend
+            self.using_pipeline = hasattr(self.deepspeed, 'pipeline_enable_backward_allreduce')
+            self.comm_backend_handle = HcclBackend(self.deepspeed.mpu)
+        self.size = self.comm_backend_handle.size
+
+        self.divider = int(self.size * 8 / np.gcd(self.size, 8))
+
+    def step(self, closure=None, grads=None):
+        """Performs a single optimization step.
+        Arguments:
+            closure (callable, optional): A closure that reevaluates the model
+                and returns the loss.
+            grads (list of tensors, optional): weight gradient to use for the
+                optimizer update. If gradients have type torch.half, parameters
+                are expected to be in type torch.float. (default: None)
+            output params (list of tensors, optional): A reduced precision copy
+                of the updated weights written out in addition to the regular
+                updated weights. Have to be of same type as gradients. (default: None)
+            scale (float, optional): factor to divide gradient tensor values
+                by before applying to weights. (default: 1)
+        """
+        loss = None
+        if closure is not None:
+            loss = closure()
+
+        if grads is None:
+            grads_group = [None] * len(self.param_groups)
+        # backward compatibility
+        # assuming a list/generator of parameter means single group
+        elif isinstance(grads, types.GeneratorType):
+            grads_group = [grads]
+        elif type(grads[0]) != list:
+            grads_group = [grads]
+        else:
+            grads_group = grads
+
+        for group, grads_this_group in zip(self.param_groups, grads_group):
+            if grads_this_group is None:
+                grads_this_group = [None] * len(group['params'])
+
+            bias_correction = 1 if group['bias_correction'] else 0
+
+            for p, grad in zip(group['params'], grads_this_group):
+                if p.grad is None and grad is None:
+                    continue
+                if grad is None:
+                    grad = p.grad.data
+                if grad.is_sparse:
+                    raise RuntimeError('0/1 Adam does not support sparse gradients')
+
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0:
+                    state['step'] = 0
+                    # Exponential moving average of gradient values
+                    state['exp_avg'] = torch.zeros_like(p.data)
+                    # Exponential moving average of squared gradient values
+                    state['exp_avg_sq'] = torch.zeros_like(p.data)
+
+                if not self.initialize or 'worker_error' not in state.keys():
+                    # Some scalars to help scale the variance update/local step policies
+                    state['var_interval'] = 1
+                    state['var_counter'] = 0
+                    state['local_step_interval'] = 1
+                    state['local_step_counter'] = 0
+                    state['lrs'] = 0
+                    state['tensor_size'] = torch.numel(p.data)
+                    state['corrected_tensor_size'] = state['tensor_size']
+
+                    if state['tensor_size'] % (self.size * self.divider) != 0:
+                        state['corrected_tensor_size'] += ((self.size * self.divider) - (state['tensor_size'] %
+                                                                                         (self.size * self.divider)))
+                    state['server_chunk_size'] = state['corrected_tensor_size'] // self.size
+                    get_accelerator().empty_cache()
+                    state['worker_error'] = torch.zeros(state['corrected_tensor_size'], device=p.device)
+                    state['server_error'] = torch.zeros(state['server_chunk_size'], device=p.device)
+                    # Accumulation of momentum, i.e., the u variable in the 0/1 Adam paper
+                    state['momentum_accumulator'] = torch.zeros_like(p.data)
+                    get_accelerator().empty_cache()
+                    # self.freeze_key = True
+                    if not self.initialize and dist.get_rank() == 0:
+                        print("Cupy Buffers Initialized Successfully.")
+
+                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
+                comm_buffer = state['momentum_accumulator']
+                beta1, beta2 = group['betas']
+
+                state['step'] += 1
+
+                if self.initialize:
+                    if self.freeze_key is False:
+                        if state['step'] % state['var_interval'] == 0:
+                            exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)
+                            exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                        else:
+                            if self.size > 1:
+                                with torch.no_grad():
+                                    grad_onebit = self.comm_backend_handle.compressed_allreduce(
+                                        grad, state['worker_error'], state['server_error'], self.deepspeed.local_rank)
+                                    if 'exp_avg_mask' in group:
+                                        if grad_onebit.device != group['exp_avg_mask'].device:
+                                            group['exp_avg_mask'] = group['exp_avg_mask'].to(device=grad_onebit.device)
+                                        grad_onebit.mul_(group['exp_avg_mask'])
+                                    exp_avg.mul_(beta1).add_(1 - beta1, grad_onebit)
+                    else:
+                        exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                        state['lrs'] += group['lr']
+                    grad = None
+
+                if not self.initialize:
+                    if self.size > 1:
+                        comm_buffer.set_(
+                            self.comm_backend_handle.compressed_allreduce(comm_buffer, state['worker_error'],
+                                                                          state['server_error'],
+                                                                          self.deepspeed.local_rank))
+                        if 'exp_avg_mask' in group:
+                            if comm_buffer.device != group['exp_avg_mask'].device:
+                                group['exp_avg_mask'] = group['exp_avg_mask'].to(device=comm_buffer.device)
+                            comm_buffer.mul_(group['exp_avg_mask'])
+
+                if self.initialize:
+                    update = exp_avg / (exp_avg_sq.sqrt() + group['eps'])
+                    if group['weight_decay'] > 0.0:
+                        update += group['weight_decay'] * p.data
+                    with torch.no_grad():
+                        p.data.add_(-group['lr'] * update)
+                        if self.freeze_key is True:
+                            comm_buffer.add_(-group['lr'] * update)
+                    if state['step'] % state['local_step_interval'] == 0 and self.freeze_key:
+                        with torch.no_grad():
+                            p.data.add_(-1 * comm_buffer)
+                            comm_buffer.mul_(exp_avg_sq.sqrt() + group['eps'])
+                            if self.size > 1:
+                                comm_buffer.copy_(
+                                    self.comm_backend_handle.compressed_allreduce(comm_buffer, state['worker_error'],
+                                                                                  state['server_error'],
+                                                                                  self.deepspeed.local_rank))
+                                if 'exp_avg_mask' in group:
+                                    if comm_buffer.device != group['exp_avg_mask'].device:
+                                        group['exp_avg_mask'] = group['exp_avg_mask'].to(device=comm_buffer.device)
+                                    comm_buffer.mul_(group['exp_avg_mask'])
+                            exp_avg.zero_().add_(comm_buffer / state['lrs'], alpha=-1)
+                            p.data.add_(comm_buffer / (exp_avg_sq.sqrt() + group['eps']))
+                            comm_buffer.zero_()
+
+                            state['lrs'] = 0
+
+                    # According to 0/1 Adam theory, a fixed variance would allow more accurate estimation of momentum
+                    # However, in practice, we can also disable the manual freezing of variance, since the interval of
+                    # updating variance will increase exponentially, so that it has negligible effect on the estimation.
+                    if self.freeze_key is False:
+                        if state['step'] % state['var_interval'] == 0:
+                            state['var_counter'] += 1
+                            if state['var_counter'] == self.var_update_scaler:
+                                state['var_counter'] = 0
+                                state['var_interval'] *= 2
+                        if (state['step'] + 1) % state['var_interval'] == 0:
+                            if self.using_pipeline:
+                                self.deepspeed.pipeline_enable_backward_allreduce = True
+                            else:
+                                self.deepspeed.enable_backward_allreduce = True
+                        else:
+                            if self.using_pipeline:
+                                self.deepspeed.pipeline_enable_backward_allreduce = False
+                            else:
+                                self.deepspeed.enable_backward_allreduce = False
+                    else:
+                        state['local_step_counter'] += 1
+                        if state['local_step_counter'] == self.local_step_scaler:
+                            state['local_step_counter'] = 0
+                            state['local_step_interval'] = min(self.local_step_clipper,
+                                                               state['local_step_interval'] * 2)
+
+            if not self.initialize:
+                print('Pop out errors', flush=True)
+                self.freeze_key = False
+                state.pop('worker_error')
+                state.pop('server_error')
+
+        if not self.initialize:
+            self.initialize = True
+            print(f"Finished the initialization step at rank {dist.get_rank()}")
+            return loss
+
+        if self.state[self.param_groups[0]['params'][0]]['step'] > self.var_freeze_step:
+            self.freeze_key = True
+            if self.using_pipeline:
+                self.deepspeed.pipeline_enable_backward_allreduce = False
+            else:
+                self.deepspeed.enable_backward_allreduce = False
+
+        if self.freeze_key is True and self.reinitial_error_buffer is False:
+            # We need to reinitialize the error buffers when local step > 1 since
+            # the errors will be logged for different metrics (gradient vs. accumulated momentum).
+            for group in self.param_groups:
+                for p in group['params']:
+                    self.state[p]['worker_error'].zero_()
+                    self.state[p]['server_error'].zero_()
+            self.reinitial_error_buffer = True
+
+        return loss
+
+    def load_state_dict(self, state_dict):
+        """
+        Overrides load_state_dict() to add special handling when loading checkpoints
+        """
+        # Because at different stage exp_avg_mask may change (e.g.,
+        # BERT pre-training seqlen 128 and 512 ), we don't use the exp_avg_mask
+        # in checkpoints but always use the one user provided in training script.
+        # (See example in DeepSpeedExamples/bing_bert/deepspeed_train.py.)
+        # Thus here we keep the exp_avg_mask unchanged when loading checkpoint
+        for i, group in enumerate(self.param_groups):
+            if 'exp_avg_mask' in group:
+                state_dict['param_groups'][i]['exp_avg_mask'] = group['exp_avg_mask']
+            elif 'exp_avg_mask' not in group and 'exp_avg_mask' in state_dict['param_groups'][i]:
+                state_dict['param_groups'][i].pop('exp_avg_mask')
+        super().load_state_dict(state_dict)
+        if self.state[self.param_groups[0]['params'][0]]['step'] < self.var_freeze_step:
+            self.var_freeze_key = False
+            if (self.state[self.param_groups[0]['params'][0]]['step'] +
+                    1) % self.state[self.param_groups[0]['params'][0]]['var_interval'] == 0:
+                if self.using_pipeline:
+                    self.deepspeed.pipeline_enable_backward_allreduce = True
+                else:
+                    self.deepspeed.enable_backward_allreduce = True
+            else:
+                if self.using_pipeline:
+                    self.deepspeed.pipeline_enable_backward_allreduce = False
+                else:
+                    self.deepspeed.enable_backward_allreduce = False
+        else:
+            self.var_freeze_key = True
+            if self.using_pipeline:
+                self.deepspeed.pipeline_enable_backward_allreduce = False
+            else:
+                self.deepspeed.enable_backward_allreduce = False
+        self.reinitial_error_buffer = False
+        for group in self.param_groups:
+            for p in group['params']:
+                if 'worker_error' in self.state[p]:
+                    self.state[p].pop('worker_error')
+                if 'server_error' in self.state[p]:
+                    self.state[p].pop('server_error')
+                if 'momentum_accumulator' in self.state[p]:
+                    self.state[p].pop('momentum_accumulator')

evalkit_cambrian/lib/python3.10/site-packages/deepspeed/runtime/fp16/unfused_optimizer.py

@@ -0,0 +1,427 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""
+Copyright NVIDIA/apex
+This file is adapted from FP16_Optimizer in NVIDIA/apex
+"""
+
+from deepspeed.moe.utils import split_params_grads_into_shared_and_expert_params
+import torch
+from torch._utils import _flatten_dense_tensors
+
+from deepspeed.runtime import DeepSpeedOptimizer
+from deepspeed.runtime.utils import get_global_norm, CheckOverflow, get_weight_norm, required_torch_version
+from deepspeed.runtime.fp16.loss_scaler import INITIAL_LOSS_SCALE, SCALE_WINDOW, MIN_LOSS_SCALE
+from deepspeed.utils import logger
+from deepspeed.checkpoint.constants import OPTIMIZER_STATE_DICT
+from deepspeed.accelerator import get_accelerator
+from deepspeed import comm as dist
+
+
+class FP16_UnfusedOptimizer(DeepSpeedOptimizer):
+    """
+    FP16 Optimizer without weight fusion to support LAMB optimizer
+
+    For usage example please see, TODO:  DeepSpeed V2 Tutorial
+    """
+
+    def __init__(self,
+                 init_optimizer,
+                 deepspeed=None,
+                 static_loss_scale=1.0,
+                 dynamic_loss_scale=False,
+                 dynamic_loss_args=None,
+                 verbose=True,
+                 mpu=None,
+                 clip_grad=0.0,
+                 fused_lamb_legacy=False):
+
+        self.fused_lamb_legacy = fused_lamb_legacy
+        self._global_grad_norm = 0.
+
+        if dist.get_rank() == 0:
+            logger.info(f'Fused Lamb Legacy : {self.fused_lamb_legacy} ')
+
+        if not get_accelerator().is_available():
+            raise SystemError("Cannot use fp16 without accelerator.")
+        self.optimizer = init_optimizer
+
+        # param groups
+        self.fp16_groups = []
+        self.fp32_groups = []
+
+        # loop to deal with groups
+        for i, param_group in enumerate(self.optimizer.param_groups):
+            #fp16 weights that represents the actual model weights
+            self.fp16_groups.append(param_group['params'])
+
+            #creating a fp32 copy of the weights that will be updated first then
+            #copied to fp16 weights
+            fp32_group = [p.clone().float().detach() for p in param_group['params']]
+
+            #in case the internal optimizer needs it
+            for p in fp32_group:
+                p.requires_grad = True
+
+            #setting the param groups in the optimizer to point to fp32
+            #note these are not the weights used by the model
+            #the model uses the fp16 version that we added to fp16_group
+            self.fp32_groups.append(fp32_group)
+            param_group['params'] = self.fp32_groups[i]
+
+        # we may have a way of fusing dynamic scale. Do not support for now
+        if dynamic_loss_scale:
+            self.dynamic_loss_scale = True
+            self.cur_iter = 0
+            self.last_overflow_iter = -1
+            self.scale_factor = 2.0
+            if dynamic_loss_args is None:
+                self.cur_scale = 1.0 * 2**16
+                self.scale_window = 1000
+                self.min_loss_scale = 0.25
+            else:
+                self.cur_scale = dynamic_loss_args[INITIAL_LOSS_SCALE]
+                self.scale_window = dynamic_loss_args[SCALE_WINDOW]
+                self.min_loss_scale = dynamic_loss_args[MIN_LOSS_SCALE]
+        else:
+            self.dynamic_loss_scale = False
+            self.cur_iter = 0
+            self.cur_scale = static_loss_scale
+
+        self.custom_loss_scaler = False
+        self.external_loss_scale = None
+
+        self.verbose = verbose
+
+        self.clip_grad = clip_grad
+        self.norm_type = 2
+
+        if required_torch_version(max_version=0.4):
+            self.clip_grad_norm = torch.nn.utils.clip_grad_norm
+        else:
+            self.clip_grad_norm = torch.nn.utils.clip_grad_norm_
+
+        self.mpu = mpu
+
+        self.overflow = False
+        self.overflow_checker = CheckOverflow(self.fp16_groups, mpu=self.mpu, deepspeed=deepspeed)
+
+        self.initialize_optimizer_states()
+
+    def zero_grad(self, set_to_none=True):
+        """
+        Zero FP16 parameter grads.
+        """
+        # FP32 grad should never exist outside of the step function
+        # For speed, set model fp16 grad to None by default
+        for group in self.fp16_groups:
+            for p in group:
+                if set_to_none:
+                    p.grad = None
+                else:
+                    if p.grad is not None:
+                        p.grad.detach_()
+                        p.grad.zero_()
+
+    def step_fused_lamb(self, closure=None):
+        """
+        Not supporting closure.
+        """
+        # First compute norm for all group so we know if there is overflow
+        grads_groups_flat = []
+        grads_groups = []
+        norm_groups = []
+        expert_norm_groups = []
+        for i, group in enumerate(self.fp16_groups):
+            grads = [
+                torch.zeros(p.size(), dtype=p.dtype, device=p.device) if p.grad is None else p.grad for p in group
+            ]
+            grads_groups.append(grads)
+            grads_groups_flat.append(_flatten_dense_tensors(grads))
+            grads_for_norm, expert_grads_for_norm = split_params_grads_into_shared_and_expert_params(group)
+            norm_group_value = 0.0
+            if len(grads_for_norm) > 0:
+                norm_group_value = get_weight_norm(_flatten_dense_tensors(grads_for_norm), mpu=self.mpu)
+            norm_groups.append(norm_group_value)
+            expert_norm_group_value = 0.0
+            if len(expert_grads_for_norm) > 0:
+                expert_norm_group_value = get_weight_norm(_flatten_dense_tensors(expert_grads_for_norm), mpu=self.mpu)
+            expert_norm_groups.append(expert_norm_group_value)
+
+        self.overflow = self.overflow_checker.check_using_norm(norm_groups + expert_norm_groups)
+        prev_scale = self.cur_scale
+
+        self._update_scale(self.overflow)
+        if self.overflow:
+            if self.verbose:
+                logger.info("[deepspeed] fp16 dynamic loss scale overflow! Skipping step. Attempted loss "
+                            "scale: {}, reducing to {}".format(prev_scale, self.cur_scale))
+            return self.overflow
+
+        self._global_grad_norm = get_global_norm(norm_list=norm_groups)
+        combined_scale = self.unscale_and_clip_grads(self._global_grad_norm, apply_scale=False)
+        self.optimizer.step(grads=grads_groups, output_params=self.fp16_groups, scale=combined_scale)
+
+        for fp32_group, fp16_group in zip(self.fp32_groups, self.fp16_groups):
+            for idx, (fp32_param, fp16_param) in enumerate(zip(fp32_group, fp16_group)):
+
+                #remove the fp32 grad
+                fp32_param.grad = None
+
+                #copy data from fp32 to fp16
+                fp16_param.data.copy_(fp32_param.data)
+
+        return self.overflow
+
+    def set_lr(self, lr):
+        """Set the learning rate."""
+        for param_group in self.optimizer.param_groups:
+            param_group["lr"] = lr
+
+    def get_lr(self):
+        """Return the current learning rate."""
+        return self.optimizer.param_groups[0]["lr"]
+
+    def override_loss_scale(self, loss_scale):
+        if loss_scale != self.external_loss_scale:
+            logger.info(f'[deepspeed] setting loss scale from {self.external_loss_scale} -> {loss_scale}')
+        self.custom_loss_scaler = True
+        self.external_loss_scale = loss_scale
+
+    def step(self, closure=None):
+        """
+        Not supporting closure.
+        """
+
+        if self.fused_lamb_legacy:
+            return self.step_fused_lamb()
+
+        self.overflow = self.overflow_checker.check()
+        prev_scale = self.cur_scale
+
+        self._update_scale(self.overflow)
+        if self.overflow:
+            if self.verbose:
+                logger.info("[deepspeed] fp16 dynamic loss scale overflow! Skipping step. Attempted loss "
+                            "scale: {}, reducing to {}".format(prev_scale, self.cur_scale))
+            return self.overflow
+
+        norm_groups = []
+        for i, group in enumerate(self.fp16_groups):
+            grads_for_norm, _ = split_params_grads_into_shared_and_expert_params(group)
+            norm_group_value = 0.0
+            if len(grads_for_norm) > 0:
+                norm_group_value = get_weight_norm(grads_for_norm, mpu=self.mpu)
+            norm_groups.append(norm_group_value)
+
+            # copying gradients to fp32 to work with fp32 parameters
+            for fp32_param, fp16_param in zip(self.fp32_groups[i], self.fp16_groups[i]):
+                if fp16_param.grad is None:
+                    fp32_param.grad = torch.zeros(fp16_param.size(), dtype=fp32_param.dtype, device=fp32_param.device)
+                else:
+                    fp32_param.grad = fp16_param.grad.to(fp32_param.dtype)
+
+        self._global_grad_norm = get_global_norm(norm_list=norm_groups)
+        self.unscale_and_clip_grads(self._global_grad_norm)
+
+        self.optimizer.step()
+
+        for fp32_group, fp16_group in zip(self.fp32_groups, self.fp16_groups):
+            for idx, (fp32_param, fp16_param) in enumerate(zip(fp32_group, fp16_group)):
+
+                #remove the fp32 grad
+                fp32_param.grad = None
+
+                #copy data from fp32 to fp16
+                fp16_param.data.copy_(fp32_param.data)
+
+        return self.overflow
+
+    def unscale_and_clip_grads(self, total_norm, apply_scale=True):
+        # compute combined scale factor for this group
+        combined_scale = self.cur_scale
+        if self.clip_grad > 0.:
+            # norm is in fact norm*scale
+            clip = ((total_norm / self.cur_scale) + 1e-6) / self.clip_grad
+            if clip > 1:
+                combined_scale = clip * self.cur_scale
+
+        if apply_scale:
+            for group in self.fp32_groups:
+                for param in group:
+                    if param.grad is not None:
+                        param.grad.data.mul_(1. / combined_scale)
+
+        return combined_scale
+
+    def backward(self, loss, create_graph=False, retain_graph=False):
+        """
+        :attr:`backward` performs the following steps:
+
+        1. fp32_loss = loss.float()
+        2. scaled_loss = fp32_loss*loss_scale
+        3. scaled_loss.backward(), which accumulates scaled gradients into the ``.grad`` attributes of the model's fp16 leaves
+        """
+        if self.custom_loss_scaler:
+            scaled_loss = self.external_loss_scale * loss
+            scaled_loss.backward()
+        else:
+            scaled_loss = (loss.float()) * self.cur_scale
+            scaled_loss.backward(create_graph=create_graph, retain_graph=retain_graph)
+
+    def _update_scale(self, skip):
+        if self.dynamic_loss_scale:
+            prev_scale = self.cur_scale
+            if skip:
+                self.cur_scale = max(self.cur_scale / self.scale_factor, self.min_loss_scale)
+                self.last_overflow_iter = self.cur_iter
+                if self.verbose:
+                    logger.info("Grad overflow on iteration: %s", self.cur_iter)
+                    logger.info(f"Reducing dynamic loss scale from {prev_scale} to {self.cur_scale}")
+            else:
+                # Ensure self.scale_window updates since last overflow
+                stable_interval = (self.cur_iter - self.last_overflow_iter) - 1
+                if (stable_interval > 0) and (stable_interval % self.scale_window == 0):
+                    self.cur_scale *= self.scale_factor
+                    if self.verbose:
+                        logger.info(f"No Grad overflow for {self.scale_window} iterations")
+                        logger.info(f"Increasing dynamic loss scale from {prev_scale} to {self.cur_scale}")
+        else:
+            if skip:
+                logger.info("Grad overflow on iteration %s", self.cur_iter)
+                logger.info("Using static loss scale of %s", self.cur_scale)
+        self.cur_iter += 1
+        return
+
+    # Promote state so it can be retrieved or set via "fp16_optimizer_instance.state"
+    def _get_state(self):
+        return self.optimizer.state
+
+    def _set_state(self, value):
+        self.optimizer.state = value
+
+    state = property(_get_state, _set_state)
+
+    # Promote param_groups so it can be retrieved or set via "fp16_optimizer_instance.param_groups"
+    # (for example, to adjust the learning rate)
+    def _get_param_groups(self):
+        return self.optimizer.param_groups
+
+    def _set_param_groups(self, value):
+        self.optimizer.param_groups = value
+
+    param_groups = property(_get_param_groups, _set_param_groups)
+
+    # Promote loss scale so it can be retrieved or set via "fp16_optimizer_instance.loss_scale"
+    def _get_loss_scale(self):
+        if self.custom_loss_scaler:
+            return self.external_loss_scale
+        else:
+            return self.cur_scale
+
+    def _set_loss_scale(self, value):
+        self.loss_scaler.cur_scale = value
+
+    loss_scale = property(_get_loss_scale, _set_loss_scale)
+
+    def state_dict(self):
+        """
+        Returns a dict containing the current state of this :class:`FP16_Optimizer` instance.
+        This dict contains attributes of :class:`FP16_Optimizer`, as well as the state_dict
+        of the contained Pytorch optimizer.
+        Example::
+            checkpoint = {}
+            checkpoint['model'] = model.state_dict()
+            checkpoint['optimizer'] = optimizer.state_dict()
+            torch.save(checkpoint, "saved.pth")
+        """
+        state_dict = {}
+        state_dict['dynamic_loss_scale'] = self.dynamic_loss_scale
+        state_dict['cur_scale'] = self.cur_scale
+        state_dict['cur_iter'] = self.cur_iter
+        if state_dict['dynamic_loss_scale']:
+            state_dict['last_overflow_iter'] = self.last_overflow_iter
+            state_dict['scale_factor'] = self.scale_factor
+            state_dict['scale_window'] = self.scale_window
+        state_dict[OPTIMIZER_STATE_DICT] = self.optimizer.state_dict()
+        state_dict['fp32_groups'] = self.fp32_groups
+        return state_dict
+
+    # Refresh fp32 master params from fp16 copies
+    def refresh_fp32_params(self):
+        for current_group, saved_group in zip(self.fp32_groups, self.fp16_groups):
+            for current, saved in zip(current_group, saved_group):
+                current.data.copy_(saved.data)
+
+    def load_state_dict(self, state_dict, load_optimizer_states=True):
+        """
+        Loads a state_dict created by an earlier call to state_dict().
+        If ``fp16_optimizer_instance`` was constructed from some ``init_optimizer``,
+        whose parameters in turn came from ``model``, it is expected that the user
+        will call ``model.load_state_dict()`` before
+        ``fp16_optimizer_instance.load_state_dict()`` is called.
+        Example::
+            model = torch.nn.Linear(D_in, D_out).to(get_accelerator().device_name()).half()
+            optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
+            optimizer = FP16_Optimizer(optimizer, static_loss_scale = 128.0)
+            ...
+            checkpoint = torch.load("saved.pth")
+            model.load_state_dict(checkpoint['model'])
+            optimizer.load_state_dict(checkpoint['optimizer'])
+        """
+        # I think it should actually be ok to reload the optimizer before the model.
+        self.dynamic_loss_scale = state_dict['dynamic_loss_scale']
+        self.cur_scale = state_dict['cur_scale']
+        self.cur_iter = state_dict['cur_iter']
+        if state_dict['dynamic_loss_scale']:
+            self.last_overflow_iter = state_dict['last_overflow_iter']
+            self.scale_factor = state_dict['scale_factor']
+            self.scale_window = state_dict['scale_window']
+
+        if load_optimizer_states:
+            self.optimizer.load_state_dict(state_dict[OPTIMIZER_STATE_DICT])
+        # At this point, the optimizer's references to the model's fp32 parameters are up to date.
+        # The optimizer's hyperparameters and internal buffers are also up to date.
+        # However, the fp32 master copies of the model's fp16 params stored by the optimizer are still
+        # out of date.  There are two options.
+        # 1:  Refresh the master params from the model's fp16 params.
+        # This requires less storage but incurs precision loss.
+        # 2:  Save and restore the fp32 master copies separately.
+        # We choose option 2.
+        #
+        # Pytorch Optimizer.load_state_dict casts saved buffers (e.g. momentum) to the type and device
+        # of their associated parameters, because it's possible those buffers might not exist yet in
+        # the current optimizer instance.  In our case, as long as the current FP16_Optimizer has been
+        # constructed in the same way as the one whose state_dict we are loading, the same master params
+        # are guaranteed to exist, so we can just copy_() from the saved master params.
+        for current_group, saved_group in zip(self.fp32_groups, state_dict['fp32_groups']):
+            for current, saved in zip(current_group, saved_group):
+                current.data.copy_(saved.data)
+
+    def __repr__(self):
+        return repr(self.optimizer)
+
+    def initialize_optimizer_states(self):
+        for i, group in enumerate(self.fp16_groups):
+            for param in group:
+                param.grad = torch.zeros(param.size(),
+                                         dtype=param.dtype,
+                                         device=get_accelerator().current_device_name())
+
+        for i, group in enumerate(self.fp32_groups):
+            for param in group:
+                param.grad = torch.zeros(param.size(),
+                                         dtype=param.dtype,
+                                         device=get_accelerator().current_device_name())
+
+        self.optimizer.step()
+
+        for i, group in enumerate(self.fp16_groups):
+            for param in group:
+                param.grad = None
+
+        for i, group in enumerate(self.fp32_groups):
+            for param in group:
+                param.grad = None

evalkit_cambrian/lib/python3.10/site-packages/dockerpycreds/__init__.py

@@ -0,0 +1,4 @@
+# flake8: noqa
+from .store import Store
+from .errors import StoreError, CredentialsNotFound
+from .constants import *

evalkit_cambrian/lib/python3.10/site-packages/dockerpycreds/constants.py

@@ -0,0 +1,4 @@
+PROGRAM_PREFIX = 'docker-credential-'
+DEFAULT_LINUX_STORE = 'secretservice'
+DEFAULT_OSX_STORE = 'osxkeychain'
+DEFAULT_WIN32_STORE = 'wincred'

evalkit_cambrian/lib/python3.10/site-packages/dockerpycreds/errors.py

@@ -0,0 +1,25 @@
+class StoreError(RuntimeError):
+    pass
+
+
+class CredentialsNotFound(StoreError):
+    pass
+
+
+class InitializationError(StoreError):
+    pass
+
+
+def process_store_error(cpe, program):
+    message = cpe.output.decode('utf-8')
+    if 'credentials not found in native keychain' in message:
+        return CredentialsNotFound(
+            'No matching credentials in {0}'.format(
+                program
+            )
+        )
+    return StoreError(
+        'Credentials store {0} exited with "{1}".'.format(
+            program, cpe.output.decode('utf-8').strip()
+        )
+    )

evalkit_cambrian/lib/python3.10/site-packages/dockerpycreds/store.py

@@ -0,0 +1,107 @@
+import json
+import os
+import subprocess
+
+import six
+
+from . import constants
+from . import errors
+from .utils import create_environment_dict
+from .utils import find_executable
+
+
+class Store(object):
+    def __init__(self, program, environment=None):
+        """ Create a store object that acts as an interface to
+            perform the basic operations for storing, retrieving
+            and erasing credentials using `program`.
+        """
+        self.program = constants.PROGRAM_PREFIX + program
+        self.exe = find_executable(self.program)
+        self.environment = environment
+        if self.exe is None:
+            raise errors.InitializationError(
+                '{0} not installed or not available in PATH'.format(
+                    self.program
+                )
+            )
+
+    def get(self, server):
+        """ Retrieve credentials for `server`. If no credentials are found,
+            a `StoreError` will be raised.
+        """
+        if not isinstance(server, six.binary_type):
+            server = server.encode('utf-8')
+        data = self._execute('get', server)
+        result = json.loads(data.decode('utf-8'))
+
+        # docker-credential-pass will return an object for inexistent servers
+        # whereas other helpers will exit with returncode != 0. For
+        # consistency, if no significant data is returned,
+        # raise CredentialsNotFound
+        if result['Username'] == '' and result['Secret'] == '':
+            raise errors.CredentialsNotFound(
+                'No matching credentials in {}'.format(self.program)
+            )
+
+        return result
+
+    def store(self, server, username, secret):
+        """ Store credentials for `server`. Raises a `StoreError` if an error
+            occurs.
+        """
+        data_input = json.dumps({
+            'ServerURL': server,
+            'Username': username,
+            'Secret': secret
+        }).encode('utf-8')
+        return self._execute('store', data_input)
+
+    def erase(self, server):
+        """ Erase credentials for `server`. Raises a `StoreError` if an error
+            occurs.
+        """
+        if not isinstance(server, six.binary_type):
+            server = server.encode('utf-8')
+        self._execute('erase', server)
+
+    def list(self):
+        """ List stored credentials. Requires v0.4.0+ of the helper.
+        """
+        data = self._execute('list', None)
+        return json.loads(data.decode('utf-8'))
+
+    def _execute(self, subcmd, data_input):
+        output = None
+        env = create_environment_dict(self.environment)
+        try:
+            if six.PY3:
+                output = subprocess.check_output(
+                    [self.exe, subcmd], input=data_input, env=env,
+                )
+            else:
+                process = subprocess.Popen(
+                    [self.exe, subcmd], stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE, env=env,
+                )
+                output, err = process.communicate(data_input)
+                if process.returncode != 0:
+                    raise subprocess.CalledProcessError(
+                        returncode=process.returncode, cmd='', output=output
+                    )
+        except subprocess.CalledProcessError as e:
+            raise errors.process_store_error(e, self.program)
+        except OSError as e:
+            if e.errno == os.errno.ENOENT:
+                raise errors.StoreError(
+                    '{0} not installed or not available in PATH'.format(
+                        self.program
+                    )
+                )
+            else:
+                raise errors.StoreError(
+                    'Unexpected OS error "{0}", errno={1}'.format(
+                        e.strerror, e.errno
+                    )
+                )
+        return output

evalkit_cambrian/lib/python3.10/site-packages/dockerpycreds/utils.py

@@ -0,0 +1,38 @@
+import distutils.spawn
+import os
+import sys
+
+
+def find_executable(executable, path=None):
+    """
+    As distutils.spawn.find_executable, but on Windows, look up
+    every extension declared in PATHEXT instead of just `.exe`
+    """
+    if sys.platform != 'win32':
+        return distutils.spawn.find_executable(executable, path)
+
+    if path is None:
+        path = os.environ['PATH']
+
+    paths = path.split(os.pathsep)
+    extensions = os.environ.get('PATHEXT', '.exe').split(os.pathsep)
+    base, ext = os.path.splitext(executable)
+
+    if not os.path.isfile(executable):
+        for p in paths:
+            for ext in extensions:
+                f = os.path.join(p, base + ext)
+                if os.path.isfile(f):
+                    return f
+        return None
+    else:
+        return executable
+
+
+def create_environment_dict(overrides):
+    """
+    Create and return a copy of os.environ with the specified overrides
+    """
+    result = os.environ.copy()
+    result.update(overrides or {})
+    return result