Add files using upload-large-folder tool

.gitattributes

@@ -130,3 +130,6 @@ lm-evaluation-harness/wandb/run-20240606_045127-vb760voe/run-vb760voe.wandb filt
 venv/lib/python3.10/site-packages/nvidia/cublas/lib/libcublasLt.so.12 filter=lfs diff=lfs merge=lfs -text
 venv/lib/python3.10/site-packages/torch/lib/libtorch_cuda.so filter=lfs diff=lfs merge=lfs -text
 venv/lib/python3.10/site-packages/nvidia/cudnn/lib/libcudnn_cnn_infer.so.8 filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.10/site-packages/scipy/special/_ufuncs.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.10/site-packages/scipy/stats/_unuran/unuran_wrapper.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.10/site-packages/scipy/sparse/_sparsetools.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

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

@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .utils import *
+from .comm import *

venv/lib/python3.10/site-packages/deepspeed/comm/backend.py

@@ -0,0 +1,47 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+"""
+DeepSpeed Communication Backend.
+
+In the future, directly use NCCL/MPI/Gloo/etc without requiring torch.distributed. Simply wrap torch.distributed for now.
+
+# Custom DS Backends -- Direct C/Ops
+ - NCCL -- [EXPERIMENTAL]
+ - MPI -- [EXPERIMENTAL]
+ - RCCL -- [EXPERIMENTAL]
+ - GLOO -- [EXPERIMENTAL]
+# DS backend wrapper for torch.distributed [DEFAULT]
+ - T-NCCL -- [DEFAULT]
+ - T-GLOO
+ - T-MPI
+
+# Backend is the base class
+     -- NcclBackend, MpiBackend, and TorchBackend are the main subclasses. TorchBackend is the only officially supported backend for now.
+"""
+
+
+class Backend(object):
+
+    def __init__(self, name='backend', rank=0, size=1):
+        self.name = name
+        # The world size and rank of the world process group
+        self.world_group = None
+        self.world_size = size
+        self.world_rank = rank
+        # Single process group (pg) implementation for now but keep a list for future
+        self.process_groups = []
+        self.initialized = False
+
+    def is_initialized(self):
+        return self.initialized
+
+    def new_group(self):
+        # create a new pg and add it to pg list
+        pass
+
+    def init_process_group(self):
+        # subclasses will initialize them fully
+        # - initialize a default world process group and add it to pg list
+        self.initialized = True

venv/lib/python3.10/site-packages/deepspeed/comm/reduce_op.py

@@ -0,0 +1,18 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from enum import Enum
+
+
+class ReduceOp(Enum):
+    SUM = 0
+    PRODUCT = 1
+    MIN = 2
+    MAX = 3
+    BAND = 4
+    BOR = 5
+    BXOR = 6
+    AVG = 7
+    UNUSED = 8

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

@@ -0,0 +1,392 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import deepspeed
+from deepspeed import utils
+
+from .utils import *
+from .backend import *
+from .comm import *
+from ..runtime import compiler
+from deepspeed.utils.torch import required_torch_version
+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 build_shm_op():
+    builder = get_accelerator().create_op_builder("ShareMemCommBuilder")
+    if builder is None or not deepspeed.ops.__compatible_ops__[builder.NAME]:
+        return None
+    shm_cpp_module = builder.load()
+    print(f'DeepSpeed {builder.absolute_name()} built successfully')
+    return shm_cpp_module
+
+
+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 required_torch_version(min_version=1.13)
+
+
+def get_coalescing_manager(group, device, reqs, async_op):
+    if required_torch_version(min_version=2.0, max_version=2.0):
+        return torch.distributed.distributed_c10d._coalescing_manager(group, device=device, reqs=reqs)
+    elif required_torch_version(min_version=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.shm_comm_op = build_shm_op()
+        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)
+        if self.shm_comm_op != None:
+            self.shm_comm_op.initialize(self.get_world_size(), self.get_rank())
+
+    @classmethod
+    @compiler.disable
+    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
+    @compiler.disable
+    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'
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    def inference_all_reduce(self, tensor, op, group=None):
+        if self.shm_comm_op == None or self.shm_comm_op.inference_all_reduce(tensor, op) == -1:
+            op = self._reduce_op(op)
+            return torch.distributed.all_reduce(tensor=tensor, op=op, group=group, async_op=False)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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
+
+    @compiler.disable
+    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()
+
+    @compiler.disable
+    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
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    def send(self, tensor, dst, group=None, tag=0):
+        return torch.distributed.send(tensor=tensor, dst=dst, group=group, tag=tag)
+
+    @compiler.disable
+    def recv(self, tensor, src=None, group=None, tag=0):
+        return torch.distributed.recv(tensor=tensor, src=src, group=group, tag=tag)
+
+    @compiler.disable
+    def isend(self, tensor, dst, group=None, tag=0):
+        return torch.distributed.isend(tensor=tensor, dst=dst, group=group, tag=tag)
+
+    @compiler.disable
+    def irecv(self, tensor, src=None, group=None, tag=0):
+        return torch.distributed.irecv(tensor=tensor, src=src, group=group, tag=tag)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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)
+
+    @compiler.disable
+    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

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

@@ -0,0 +1,21 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .bert import DS_BERTContainer, HFBertLayerPolicy
+from .bloom import DS_BloomContainer, BLOOMLayerPolicy, supported_models
+from .distil_bert import DS_DistilBERTContainer, HFDistilBertLayerPolicy
+from .gpt2 import DS_GPT2Container, HFGPT2LayerPolicy
+from .gptj import DS_GPTJContainer, HFGPTJLayerPolicy
+from .gptneo import DS_GPTNEOContainer, HFGPTNEOLayerPolicy
+from .gptneox import DS_GPTNEOXContainer, GPTNEOXLayerPolicy
+from .llama import DS_LLAMAContainer, LLAMALayerPolicy
+from .llama2 import LLAMA2LayerPolicy, DS_LLAMA2Container
+from .internlm import DS_InternLMContainer, InternLMLayerPolicy
+from .megatron_gpt import DS_MegatronGPTContainer, MegatronLayerPolicy
+from .megatron_gpt_moe import DS_MegatronGPTMoEContainer, MegatronMoELayerPolicy
+from .opt import DS_OPTContainer, HFOPTLayerPolicy
+from .clip import DS_CLIPContainer, HFCLIPLayerPolicy
+from .unet import UNetPolicy
+from .vae import VAEPolicy

venv/lib/python3.10/site-packages/deepspeed/module_inject/containers/base.py

@@ -0,0 +1,322 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+# Create a container object to save model-specific tensors using the policy file above.
+from abc import ABC
+
+import torch
+
+import deepspeed
+from deepspeed.ops.transformer.inference.config import DeepSpeedInferenceConfig
+from deepspeed.accelerator import get_accelerator
+
+# If the intermediate size attribute is set DEFAULT_INTERMEDIATE_SIZE
+# it is assumed the intermediate size is 4x the embedding dimension
+DEFAULT_INTERMEDIATE_SIZE = -1
+
+
+class BaseConvolutionContainer(ABC):
+    # not implemented
+    def __init__(self):
+        pass
+
+
+class BaseTransformerContainer(ABC):
+
+    def __init__(self, policy, config, model_config, layer_id, child):
+        self.policy = policy
+        self.config = config
+        self.model_config = model_config
+        self.layer_id = layer_id
+        self.child = child
+
+        self.megatron_v2 = self.policy.is_megatron_v2
+        self.scale_attention = self.policy.scale_attention
+        self.ckpt_load_enabled = False
+
+        # configuration for models. todo: can this be moved to a pydantic model config?
+        self.hidden_size = None
+        self.intermediate_size = None
+        self.num_attention_heads = None
+        self.mp_size = self.config.tensor_parallel.tp_size
+        self.pre_layer_norm = self.model_config.do_layer_norm_before if \
+            hasattr(self.model_config, 'do_layer_norm_before') else self.policy.pre_attn_norm
+        self.dtype = self.config.dtype
+        self.attn_linear_layer = self.policy.linear_layer
+        self.mlp_linear_layer = self.policy.linear_layer
+        self.return_tuple = self.config.return_tuple
+        self.triangular_masking = True
+        self.local_attention = ((self.model_config.attention_layers[self.layer_id] == "local") if hasattr(
+            self.model_config, 'attention_layers') else False)
+        self.window_size = getattr(self.model_config, "window_size", 1)
+        self.mlp_act_func_type = self.policy.mlp_act_func_type
+        self.norm_type = self.policy.norm_type
+        self.training_mp_size = self.config.training_mp_size
+        self.bigscience_bloom = False
+        self.max_out_tokens = self.config.max_out_tokens
+        self.min_out_tokens = self.config.min_out_tokens
+        self.scale_attn_by_inverse_layer_idx = getattr(self.config, "scale_attn_by_inverse_layer_idx", False)
+        self.use_mup = self.policy.use_mup
+        self.return_single_tuple = False
+        self.rotary_dim = self.get_rotary_dim()
+        self.mlp_after_attn = (self.rotary_dim is None or self.rotary_dim < 0)
+
+        # Attention tensors
+        self.qkvw = None
+        self.qkvb = None
+        self.dense_w = None
+        self.dense_b = None
+        # MLP tensors
+        self._h4h_w = None
+        self._h4h_b = None
+        self._4hh_w = None
+        self._4hh_b = None
+        # LayerNorm tensors
+        self.attn_nw = None
+        self.attn_nb = None
+        self.input_nw = None
+        self.input_nb = None
+
+        self.mp_group = None
+        self.use_triton = False
+
+        # Triton
+        self.use_triton = config.use_triton and deepspeed.HAS_TRITON
+
+    def create_ds_model_config(self):
+        self.set_hidden_heads(*self.policy.get_hidden_heads())
+        assert self.num_attention_heads % self.mp_size == 0,\
+                "To run the model parallel across the GPUs, the attention_heads require to be divisible by the world_size!" +\
+                "This is because the attention computation is partitioned evenly among the parallel GPUs."
+
+        self.ds_model_config = DeepSpeedInferenceConfig(
+            hidden_size=self.hidden_size,
+            intermediate_size=self.intermediate_size,
+            heads=self.num_attention_heads,
+            layer_norm_eps=self.layernorm_epsilon,
+            dtype=self.dtype,
+            pre_layer_norm=self.pre_layer_norm,
+            norm_type=self.norm_type,
+            mp_size=self.mp_size,
+            return_tuple=self.return_tuple,
+            triangular_masking=self.triangular_masking,
+            local_attention=self.local_attention,
+            window_size=self.window_size,
+            rotary_dim=self.rotary_dim,
+            mlp_after_attn=self.mlp_after_attn,
+            mlp_act_func_type=self.mlp_act_func_type,
+            training_mp_size=self.training_mp_size,
+            bigscience_bloom=self.bigscience_bloom,
+            max_out_tokens=self.max_out_tokens,
+            min_out_tokens=self.min_out_tokens,
+            scale_attn_by_inverse_layer_idx=self.scale_attn_by_inverse_layer_idx,
+            use_mup=self.use_mup,
+            return_single_tuple=self.return_single_tuple,
+            set_empty_params=self.config.set_empty_params,
+            transposed_mode=self.config.transposed_mode,
+            use_triton=self.use_triton,
+            triton_autotune=self.config.triton_autotune)
+
+        if self.use_triton and deepspeed.HAS_TRITON:
+            from .bert import DS_BERTContainer
+            if not isinstance(self, DS_BERTContainer):
+                raise NotImplementedError("Triton kernels are only for BERT-like models yet")
+
+            if not self.config.triton_autotune:
+                from deepspeed.ops.transformer.inference.triton.matmul_ext import fp16_matmul
+                fp16_matmul.skip_autotune()
+
+        return self.ds_model_config
+
+    def check_meta_tensor_support(self):
+        if hasattr(self.qkvw, 'is_meta'):
+            if self.qkvw.is_meta:
+                assert self.ckpt_load_enabled, "Meta tensors are not supported for this model currently."
+        else:
+            raise NotImplementedError("Meta tensor support is not available, please upgrade to torch 1.10+")
+
+    def initialize_tensors(self, enable_training=False):
+        # Set the tensors from policy (user module) to container (DS module)
+        self.set_attention(*self.policy.attention(enable_training=enable_training))
+        self.set_mlp(*self.policy.mlp(enable_training=enable_training))
+        self.set_layernorm(*self.policy.layernorm())
+        #self.check_meta_tensor_support()
+
+    def convert_to_required_dtype(self):
+        # Note: converting tensors to fp16 requires that we do it in-place using self.__dict__ and not make a list/dict copy
+        if self.dtype in [torch.half, torch.bfloat16]:
+            for k, v in self.__dict__.items():
+                # The list comprehension is used for MoE tensor lists
+                if isinstance(v, list) and all((isinstance(tensor, torch.Tensor) \
+                   or isinstance(tensor, torch.nn.Parameter)) for tensor in v):
+                    self.__dict__[k] = [moe_tensor.to(self.dtype) for moe_tensor in v]
+
+                if isinstance(v, torch.Tensor) or isinstance(v, torch.nn.Parameter):
+                    self.__dict__[k] = v.to(self.dtype)
+
+    def get_rotary_dim(self):
+        if hasattr(self.model_config, 'rotary_dim'):
+            return self.model_config.rotary_dim
+        if hasattr(self.child, 'attention') and hasattr(self.child.attention, 'rotary_ndims'):
+            return self.child.attention.rotary_ndims
+        return -1
+
+    def set_moe(self, moe=False):
+        self.moe = moe
+
+    def set_tensor_parallel_config(self, mp_size, mp_group):
+        self.mp_size = mp_size
+        self.mp_group = mp_group
+
+    def set_quantization_config(self, quantizer):
+        self.quantizer = quantizer
+
+    def set_hidden_heads(self, hidden_size, num_attention_heads, epsilon, intermediate_size):
+        """
+        Args:
+            hidden_size: embedding dimension of the model
+            num_attention_heads: number of attention heads in the model
+            epsilon: epsilon value for layer norm (same value used for all norms)
+            intermediate_size: Size of MLP projection. If `DEFAULT_INTERMEDIATE_SIZE` is passed
+                it is assumed to be `4 * hidden_size`
+        """
+        self.hidden_size = hidden_size
+        if intermediate_size == DEFAULT_INTERMEDIATE_SIZE:
+            self.intermediate_size = 4 * hidden_size
+        else:
+            self.intermediate_size = intermediate_size
+        self.num_attention_heads = num_attention_heads
+        self.layernorm_epsilon = epsilon
+
+    def set_attention(self, qkvw, qkvb, dense_w, dense_b):
+        self.qkvw = qkvw
+        self.qkvb = qkvb
+        self.dense_w = dense_w
+        self.dense_b = dense_b
+
+    def set_mlp(self, _h4h_w, _h4h_b, _4hh_w, _4hh_b):
+        self._h4h_w = _h4h_w
+        self._h4h_b = _h4h_b
+        self._4hh_w = _4hh_w
+        self._4hh_b = _4hh_b
+
+    def set_layernorm(self, attn_nw, attn_nb, input_nw, input_nb):
+        self.attn_nw = attn_nw
+        self.attn_nb = attn_nb
+        self.input_nw = input_nw
+        self.input_nb = input_nb
+
+    def apply_weight_quantization(self):
+        # quantize attention weights
+        self.attention_quantization()
+
+        # quantize mlp weights
+        self.mlp_quantization()
+
+    def attention_quantization(self):
+        self.module.attention.attn_qkvw = self.quantizer.quantize(self.module.attention.attn_qkvw)
+        self.module.attention.attn_ow = self.quantizer.quantize(self.module.attention.attn_ow)
+
+    def mlp_quantization(self):
+        self.module.mlp.inter_w = self.quantizer.quantize(self.module.mlp.inter_w)
+        self.module.mlp.output_w = self.quantizer.quantize(self.module.mlp.output_w)
+
+    def apply_tensor_parallelism(self, mp_replace):
+        # setup the new Attention module
+        self.attention_qkv_mp(mp_replace)
+        self.attention_o_mp(mp_replace)
+
+        # setup the new MLP module
+        self.mlp_inter_mp(mp_replace)
+        self.mlp_output_mp(mp_replace)
+
+        # Apply weight quantization
+        # TODO(cmikeh2): Re-enable this once verified
+        #self.apply_weight_quantization()
+
+    def attention_qkv_mp(self, mp_replace, reversed_dim=False):
+        self.module.attention.attn_qkvw = mp_replace.strided_copy(self.module.attention.attn_qkvw,
+                                                                  self.qkvw,
+                                                                  num_splits=3,
+                                                                  int8=reversed_dim)
+        self.module.attention.attn_qkvb = mp_replace.strided_copy(self.module.attention.attn_qkvb,
+                                                                  self.qkvb,
+                                                                  num_splits=3,
+                                                                  int8=reversed_dim)
+
+    def attention_o_mp(self, mp_replace, reversed_dim=False):
+        self.module.attention.attn_ow = mp_replace.copy(self.module.attention.attn_ow, self.dense_w, int8=reversed_dim)
+        self.module.attention.attn_ob = mp_replace.copy(self.module.attention.attn_ob,
+                                                        self.dense_b,
+                                                        int8=reversed_dim,
+                                                        allocate_tensor=reversed_dim)
+
+    def mlp_inter_mp(self, mp_replace, reversed_dim=False):
+        self.module.mlp.inter_w = mp_replace.copy(self.module.mlp.inter_w, self._h4h_w, int8=reversed_dim)
+        self.module.mlp.inter_b = mp_replace.copy(self.module.mlp.inter_b, self._h4h_b, int8=reversed_dim)
+
+    def mlp_output_mp(self, mp_replace, reversed_dim=False):
+        self.module.mlp.output_w = mp_replace.copy(self.module.mlp.output_w, self._4hh_w, int8=reversed_dim)
+        self.module.mlp.output_b = mp_replace.copy(self.module.mlp.output_b,
+                                                   self._4hh_b,
+                                                   int8=reversed_dim,
+                                                   allocate_tensor=reversed_dim)
+
+    def copy_data_to_new_module(self):
+        params = {'attn_nw': self.attn_nw, 'attn_nb': self.attn_nb}
+        for key in params:
+            if params[key] is None:
+                setattr(self.module.mlp, key, None)
+            else:
+                setattr(self.module.mlp, key,
+                        torch.nn.parameter.Parameter(params[key].to(get_accelerator().current_device_name())))
+
+        params = {'norm_w': self.input_nw, 'norm_b': self.input_nb}
+        for key in params:
+            if params[key] is None:
+                setattr(self.module, key, None)
+            else:
+                setattr(self.module, key,
+                        torch.nn.parameter.Parameter(params[key].to(get_accelerator().current_device_name())))
+
+    def transpose(self):
+        self.transpose_attention()
+        self.transpose_mlp()
+
+    def transpose_attention(self):
+        if self.attn_linear_layer:
+            self.qkvw = self.transpose_impl(self.qkvw.data)
+            self.dense_w = self.transpose_impl(self.dense_w.data)
+
+    def transpose_mlp(self):
+        if self.mlp_linear_layer:
+            self._h4h_w = self.transpose_impl(self._h4h_w.data)
+            self._4hh_w = self.transpose_impl(self._4hh_w.data)
+
+    def transpose_impl(self, data):
+        data = data.contiguous()
+        data.reshape(-1).copy_(data.transpose(-1, -2).contiguous().reshape(-1))
+        data = data.reshape(data.shape[-1], data.shape[-2])
+        data.to(get_accelerator().current_device_name())
+        return data
+
+    def get_all_params(self):
+        params = [
+            self.attn_nw,
+            self.attn_nb,
+            self.input_nw,
+            self.input_nb,
+        ]
+
+        params.extend(self.get_attn_params())
+        params.extend(self.get_mlp_params())
+
+        return params
+
+    def get_attn_params(self):
+        return [self.qkvw, self.qkvb, self.dense_w, self.dense_b]
+
+    def get_mlp_params(self):
+        return [self._h4h_w, self._h4h_b, self._4hh_w, self._4hh_b]

venv/lib/python3.10/site-packages/deepspeed/module_inject/containers/base_moe.py

@@ -0,0 +1,130 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+# Create a container object to save model-specific tensors using the policy file above.
+from .base import *
+from deepspeed import comm as dist
+import deepspeed.ops.transformer as transformer_inference
+from deepspeed.accelerator import get_accelerator
+
+
+class BaseTransformerMoEContainer(BaseTransformerContainer):
+
+    def __init__(self, **kwargs):
+        # Call the init function of the parent class to initialize the tensors and configs from parent class
+        super().__init__(**kwargs)
+
+        self.num_experts = self.policy.get_num_experts()
+        self.ep_world_size = dist.get_world_size()
+        self.local_ep_size = 1 if self.num_experts < self.ep_world_size else self.num_experts // self.ep_world_size
+
+        self.layer_norm_eps = self.config.layer_norm_eps if hasattr(self.config, 'layer_norm_eps') else 1e-12,
+
+        # MoE models will have a list of mlp related tensors
+        self._h4h_w = []
+        self._h4h_b = []
+        self._4hh_w = []
+        self._4hh_b = []
+
+        # Residual MoE needs extra parameters
+        self._res_h4h_w = None
+        self._res_h4h_b = None
+        self._res_4hh_w = None
+        self._res_4hh_b = None
+        self._res_coef = None
+
+    def create_ds_model_config(self):
+        self.set_hidden_heads(*self.policy.get_hidden_heads())
+        assert self.num_attention_heads % self.mp_size == 0,\
+                "To run the model parallel across the GPUs, the attention_heads require to be divisible by the world_size!" +\
+                "This is because the attention computation is partitioned evenly among the parallel GPUs."
+
+        self.ds_model_config = transformer_inference.DeepSpeedMoEInferenceConfig(
+            hidden_size=self.hidden_size,
+            heads=self.num_attention_heads,
+            layer_norm_eps=self.layer_norm_eps,
+            fp16=self.fp16,
+            pre_layer_norm=self.pre_layer_norm,
+            mp_size=self.mp_size,
+            q_int8=self.quantize,
+            moe_experts=self.local_ep_size,
+            global_experts=self.num_experts,
+            mlp_type=self.config.moe.type,
+            scale_attn_by_inverse_layer_idx=self.scale_attn_by_inverse_layer_idx,
+        )
+
+        return self.ds_model_config
+
+    def initialize_tensors(self):
+        # Set the tensors from policy (user module) to container (DS module)
+        self.set_attention(*self.policy.attention())
+        self.set_mlp(self.config.moe.type)
+        self.set_layernorm(*self.policy.layernorm())
+
+    def set_mlp(self, config_moe_type):
+        if config_moe_type == 'standard':
+            self._h4h_w, self._h4h_b, \
+            self._4hh_w, self._4hh_b = self.policy.mlp()
+        else:
+            self._h4h_w, self._h4h_b, self._4hh_w, \
+            self._4hh_b, self._res_h4h_w, self._res_h4h_b, \
+            self._res_4hh_w, self._res_4hh_b, \
+            self._res_coef = self.policy.mlp(config_moe_type)
+
+    def transpose(self):
+        self.transpose_attention()
+        self.transpose_mlp()
+
+        if self.config.moe.type == 'residual':
+            self.transpose_residual()
+
+    def transpose_mlp(self):
+        self._h4h_w = [self.transpose_impl(moe_w1.data) for moe_w1 in self._h4h_w]
+        self._4hh_w = [self.transpose_impl(moe_w1.data) for moe_w1 in self._4hh_w]
+
+    def transpose_residual(self):
+        self._res_h4h_w.data = self.transpose_impl(self._res_h4h_w.data)
+        self._res_4hh_w.data = self.transpose_impl(self._res_4hh_w.data)
+        self._res_coef.data = self.transpose_impl(self._res_coef.data)
+
+    def apply_tensor_parallelism(self, mp_replace):
+        # setup the new Attention module
+        self.attention_qkv_mp(mp_replace)
+        self.attention_o_mp(mp_replace)
+
+        # quantize attention weights
+        self.attention_quantization()
+
+        # setup the new MLP module
+        self.mlp_mp()
+
+    def mlp_mp(self):
+        gpu_index = dist.get_rank()
+        for ep_index in range(self.local_ep_size):
+            # mlp inter
+            self.module.mlp[ep_index].inter_w.data = self._h4h_w[gpu_index * self.local_ep_size + ep_index].to(
+                get_accelerator().current_device_name())
+            self.module.mlp[ep_index].inter_b.data = self._h4h_b[gpu_index * self.local_ep_size + ep_index].to(
+                get_accelerator().current_device_name())
+
+            # mlp output
+            self.module.mlp[ep_index].output_w.data = self._4hh_w[gpu_index * self.local_ep_size + ep_index].to(
+                get_accelerator().current_device_name())
+            self.module.mlp[ep_index].output_b.data = self._4hh_b[gpu_index * self.local_ep_size + ep_index].to(
+                get_accelerator().current_device_name())
+
+    def copy_data_to_new_module(self):
+        self.module.attn_nw.data = self.attn_nw.to(get_accelerator().current_device_name())
+        self.module.attn_nb.data = self.attn_nb.to(get_accelerator().current_device_name())
+
+        self.module.norm_w.data.copy_(self.input_nw.to(get_accelerator().current_device_name()))
+        self.module.norm_b.data.copy_(self.input_nb.to(get_accelerator().current_device_name()))
+
+        if self.config.moe.type == 'residual':
+            self.module.res_mlp.inter_w.data = self._res_h4h_w.to(get_accelerator().current_device_name())
+            self.module.res_mlp.inter_b.data = self._res_h4h_b.to(get_accelerator().current_device_name())
+            self.module.res_mlp.output_w.data = self._res_4hh_w.to(get_accelerator().current_device_name())
+            self.module.res_mlp.output_b.data = self._res_4hh_b.to(get_accelerator().current_device_name())
+            self.module.res_coef.data = self._res_coef.to(get_accelerator().current_device_name())

venv/lib/python3.10/site-packages/deepspeed/module_inject/containers/bert.py

@@ -0,0 +1,93 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .base import *
+from deepspeed.model_implementations.transformers.ds_bert import DeepSpeedBERTInference
+import torch
+from torch.nn.parameter import Parameter
+from ..policy import TransformerPolicy
+
+
+class DS_BERTContainer(BaseTransformerContainer):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # All model specific things should be defined here instead of the base class.
+        self.return_tuple = True
+        self.triangular_masking = False
+        self.use_triton = kwargs['config'].use_triton and deepspeed.HAS_TRITON
+
+    def create_module(self, config=None):
+        _config = config if config is not None else self.ds_model_config
+        self.module = DeepSpeedBERTInference(_config, mp_group=self.mp_group)
+        self.module.config.scale_attention = self.scale_attention
+        return self.module
+
+
+class HFBertLayerPolicy(TransformerPolicy):
+
+    def __init__(self, client_module, inference=False):
+        super().__init__(inference, pre_attn_norm=False)
+        self.client_module = client_module
+        self.cuda_graph_supported = True
+
+        if HFBertLayerPolicy._orig_layer_class is None:
+            try:
+                import transformers
+                HFBertLayerPolicy._orig_layer_class = [
+                    transformers.models.bert.modeling_bert.BertLayer,
+                    transformers.models.roberta.modeling_roberta.RobertaLayer
+                ]
+            except:
+                HFBertLayerPolicy._orig_layer_class = None
+
+    def get_hidden_heads(self):
+        if self.pre_attn_norm:
+            attention_layernorm = self.client_module.PostAttentionLayerNorm
+        else:
+            attention_layernorm = self.client_module.attention.output.LayerNorm
+        return self.client_module.attention.self.query.weight.shape[1], \
+                self.client_module.attention.self.num_attention_heads, \
+                attention_layernorm.eps, \
+                DEFAULT_INTERMEDIATE_SIZE
+
+    def attention(self, enable_training=False):
+        qw = self.client_module.attention.self.query.weight
+        qb = self.client_module.attention.self.query.bias
+        kw = self.client_module.attention.self.key.weight
+        kb = self.client_module.attention.self.key.bias
+        vw = self.client_module.attention.self.value.weight
+        vb = self.client_module.attention.self.value.bias
+
+        qkvw = Parameter(torch.cat((qw, kw, vw), dim=0), requires_grad=enable_training)
+        qkvb = Parameter(torch.cat((qb, kb, vb), dim=0), requires_grad=enable_training)
+
+        return qkvw, \
+               qkvb, \
+               self.client_module.attention.output.dense.weight, \
+               self.client_module.attention.output.dense.bias, \
+
+    def mlp(self, enable_training=False):
+        if self.pre_attn_norm:
+            intermediate_ff = self.client_module.intermediate.dense_act
+        else:
+            intermediate_ff = self.client_module.intermediate.dense
+
+        return intermediate_ff.weight, intermediate_ff.bias, \
+            self.client_module.output.dense.weight, \
+            self.client_module.output.dense.bias
+
+    def layernorm(self):
+        if self.pre_attn_norm:
+            attention_layernorm = self.client_module.PostAttentionLayerNorm
+            transformer_layernorm = self.client_module.PreAttentionLayerNorm
+        else:
+            attention_layernorm = self.client_module.attention.output.LayerNorm
+            transformer_layernorm = self.client_module.output.LayerNorm
+        return attention_layernorm.weight, \
+               attention_layernorm.bias, \
+               transformer_layernorm.weight, \
+               transformer_layernorm.bias

venv/lib/python3.10/site-packages/deepspeed/module_inject/containers/bloom.py

@@ -0,0 +1,131 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .base import *
+from .features.meta_tensor import MetaTensorContainer
+from .features.hybrid_engine import HybridEngineContainer
+from deepspeed.model_implementations.transformers.ds_bloom import DeepSpeedBloomInference
+from ..policy import TransformerPolicy
+from ..policy import transformer_param_names
+from ..policy import maybe_copy
+
+from ..policy import maybe_get_lora
+
+supported_models = {None}
+
+
+class DS_BloomContainer(MetaTensorContainer, HybridEngineContainer, BaseTransformerContainer):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # All model specific things should be defined here instead of the base class.
+        self.bigscience_bloom = True
+        self.triangular_masking = False
+
+    def create_module(self, config=None):
+        _config = config if config is not None else self.ds_model_config
+
+        self.module = DeepSpeedBloomInference(_config, mp_group=self.mp_group)
+        self.module.config.scale_attention = self.scale_attention
+        self.module.config.invert_mask = False
+        return self.module
+
+    def attention_qkv_mp(self, mp_replace, reversed_dim=False):
+        self.module.attention.attn_qkvw = mp_replace.copy(self.module.attention.attn_qkvw, self.qkvw)
+        self.module.attention.attn_qkvb = mp_replace.copy(self.module.attention.attn_qkvb, self.qkvb)
+
+    def get_lora_matched_pair(self):
+        """
+        Necessary to implement for `HybridEngineContainer`
+        """
+        fc1_lora, fc2_lora, qkv_lora, out_lora = self.get_lora_params()
+        ret = [(fc1_lora, self._h4h_w), (fc2_lora, self._4hh_w), (qkv_lora, self.qkvw), (out_lora, self.dense_w)]
+        return ret
+
+    def set_lora_params(self):
+        """
+        Necessary to implement for `HybridEngineContainer`
+        """
+        self.lora_params = [
+            maybe_get_lora(p) for p in [
+                self.policy.client_module.mlp.dense_h_to_4h, self.policy.client_module.mlp.dense_4h_to_h, self.policy.
+                client_module.self_attention.query_key_value, self.policy.client_module.self_attention.dense
+            ]
+        ]
+
+    def load_params(self, module, sd, weight_quantizer, mp_replace, prefix):
+        param_names = (
+            'self_attention.query_key_value.weight', \
+            'self_attention.query_key_value.bias', \
+            'self_attention.dense.weight', \
+            'self_attention.dense.bias', \
+            'mlp.dense_h_to_4h.weight', \
+            'mlp.dense_h_to_4h.bias', \
+            'mlp.dense_4h_to_h.weight', \
+            'mlp.dense_4h_to_h.bias', \
+            'post_attention_layernorm.weight', \
+            'post_attention_layernorm.bias', \
+            'input_layernorm.weight', \
+            'input_layernorm.bias'
+        )
+        for i in range(0, 2):
+            maybe_copy(module.attention,
+                       sd,
+                       weight_quantizer,
+                       mp_replace,
+                       transformer_param_names[i],
+                       prefix + param_names[i],
+                       qkv=True,
+                       megatron_v2=self.policy.is_megatron_v2,
+                       split_qkv=self.policy.split_qkv)
+        for i in range(2, 4):
+            maybe_copy(module.attention, sd, weight_quantizer, mp_replace, transformer_param_names[i],
+                       prefix + param_names[i])
+        for i in range(4, 10):
+            maybe_copy(module.mlp, sd, weight_quantizer, mp_replace, transformer_param_names[i],
+                       prefix + param_names[i])
+        for i in range(10, 12):
+            maybe_copy(module, sd, weight_quantizer, mp_replace, transformer_param_names[i], prefix + param_names[i])
+
+
+class BLOOMLayerPolicy(TransformerPolicy):
+    _orig_layer_class = None
+
+    def __init__(self, client_module, inference=True, use_load_prefix=True, split_qkv=False):
+        super().__init__(inference, linear_layer=True, use_load_prefix=use_load_prefix, split_qkv=split_qkv)
+        self.client_module = client_module
+        try:
+            import transformers
+            BLOOMLayerPolicy._orig_layer_class = transformers.models.bloom.modeling_bloom.BloomBlock
+            global supported_models
+            supported_models.update({transformers.models.bloom.modeling_bloom.BloomModel})
+        except Exception as e:
+            print(f"WARNING! Setting BLOOMLayerPolicy._orig_layer_class to None due to Exception: {e}")
+            BLOOMLayerPolicy._orig_layer_class = None
+
+    def get_hidden_heads(self):
+        return self.client_module.self_attention.hidden_size, \
+                self.client_module.self_attention.num_heads, \
+                self.client_module.input_layernorm.eps, \
+                DEFAULT_INTERMEDIATE_SIZE
+
+    def attention(self, enable_training=False):
+        return self.client_module.self_attention.query_key_value.weight, \
+                self.client_module.self_attention.query_key_value.bias, \
+                self.client_module.self_attention.dense.weight, \
+                self.client_module.self_attention.dense.bias,
+
+    def mlp(self, enable_training=False):
+        return self.client_module.mlp.dense_h_to_4h.weight, \
+               self.client_module.mlp.dense_h_to_4h.bias, \
+               self.client_module.mlp.dense_4h_to_h.weight, \
+               self.client_module.mlp.dense_4h_to_h.bias
+
+    def layernorm(self):
+        return self.client_module.post_attention_layernorm.weight, \
+               self.client_module.post_attention_layernorm.bias, \
+               self.client_module.input_layernorm.weight, \
+               self.client_module.input_layernorm.bias

venv/lib/python3.10/site-packages/deepspeed/module_inject/containers/clip.py

@@ -0,0 +1,73 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .base import *
+from deepspeed.model_implementations.transformers.ds_gpt import DeepSpeedGPTInference
+import torch
+from torch.nn.parameter import Parameter
+from ..policy import TransformerPolicy
+
+
+class DS_CLIPContainer(BaseTransformerContainer):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # All model specific things should be defined here instead of the base class.
+
+    def create_module(self, config=None):
+        _config = config if config is not None else self.ds_model_config
+        self.module = DeepSpeedGPTInference(_config, mp_group=self.mp_group)
+        self.module.config.scale_attention = self.scale_attention
+        return self.module
+
+
+class HFCLIPLayerPolicy(TransformerPolicy):
+
+    def __init__(self, client_module, inference=False):
+        super().__init__(inference, pre_attn_norm=True, scale_attention=True)
+        self.client_module = client_module
+        self.cuda_graph_supported = True
+
+        if HFCLIPLayerPolicy._orig_layer_class is None:
+            try:
+                import transformers
+                HFCLIPLayerPolicy._orig_layer_class = transformers.models.clip.modeling_clip.CLIPEncoderLayer
+            except:
+                HFCLIPLayerPolicy._orig_layer_class = None
+
+    def get_hidden_heads(self):
+        return self.client_module.self_attn.q_proj.weight.shape[1], \
+                self.client_module.self_attn.num_heads, \
+                self.client_module.layer_norm1.eps, \
+                DEFAULT_INTERMEDIATE_SIZE
+
+    def attention(self, enable_training=False):
+        qw = self.client_module.self_attn.q_proj.weight
+        qb = self.client_module.self_attn.q_proj.bias
+        kw = self.client_module.self_attn.k_proj.weight
+        kb = self.client_module.self_attn.k_proj.bias
+        vw = self.client_module.self_attn.v_proj.weight
+        vb = self.client_module.self_attn.v_proj.bias
+
+        qkvw = Parameter(torch.cat((qw, kw, vw), dim=0), requires_grad=enable_training)
+        qkvb = Parameter(torch.cat((qb, kb, vb), dim=0), requires_grad=enable_training)
+
+        return qkvw, \
+               qkvb, \
+               self.client_module.self_attn.out_proj.weight, \
+               self.client_module.self_attn.out_proj.bias
+
+    def mlp(self, enable_training=False):
+        return self.client_module.mlp.fc1.weight, \
+               self.client_module.mlp.fc1.bias, \
+               self.client_module.mlp.fc2.weight, \
+               self.client_module.mlp.fc2.bias
+
+    def layernorm(self):
+        return self.client_module.layer_norm2.weight, \
+               self.client_module.layer_norm2.bias, \
+               self.client_module.layer_norm1.weight, \
+               self.client_module.layer_norm1.bias

venv/lib/python3.10/site-packages/deepspeed/module_inject/containers/distil_bert.py

@@ -0,0 +1,82 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .base import *
+from deepspeed.model_implementations.transformers.ds_bert import DeepSpeedBERTInference
+import torch
+from torch.nn.parameter import Parameter
+from ..policy import TransformerPolicy
+
+
+class DS_DistilBERTContainer(BaseTransformerContainer):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # All model specific things should be defined here instead of the base class.
+        self.triangular_masking = False
+        self.return_single_tuple = True
+        self.use_triton = kwargs['config'].use_triton and deepspeed.HAS_TRITON
+
+    def create_module(self, config=None):
+        _config = config if config is not None else self.ds_model_config
+        self.module = DeepSpeedBERTInference(_config, mp_group=self.mp_group)
+        self.module.config.scale_attention = self.scale_attention
+        return self.module
+
+
+class HFDistilBertLayerPolicy(TransformerPolicy):
+    _orig_layer_class = None
+
+    def __init__(self, client_module, inference=False, preln=False):
+        super().__init__(inference)
+        self.client_module = client_module
+        self.preln = preln
+        self.cuda_graph_supported = True
+        if HFDistilBertLayerPolicy._orig_layer_class is None:
+            try:
+                import transformers
+                HFDistilBertLayerPolicy._orig_layer_class = [
+                    transformers.models.distilbert.modeling_distilbert.TransformerBlock,
+                ]
+            except:
+                HFDistilBertLayerPolicy._orig_layer_class = None
+
+    def get_hidden_heads(self):
+        return self.client_module.attention.q_lin.weight.shape[1], \
+                self.client_module.attention.n_heads, \
+                self.client_module.sa_layer_norm.eps, \
+                DEFAULT_INTERMEDIATE_SIZE
+
+    def attention(self, enable_training=False):
+        qw = self.client_module.attention.q_lin.weight
+        qb = self.client_module.attention.q_lin.bias
+        kw = self.client_module.attention.k_lin.weight
+        kb = self.client_module.attention.k_lin.bias
+        vw = self.client_module.attention.v_lin.weight
+        vb = self.client_module.attention.v_lin.bias
+
+        qkvw = Parameter(torch.cat((qw, kw, vw), dim=0), requires_grad=enable_training)
+        qkvb = Parameter(torch.cat((qb, kb, vb), dim=0), requires_grad=enable_training)
+
+        return qkvw, \
+               qkvb, \
+               self.client_module.attention.out_lin.weight, \
+               self.client_module.attention.out_lin.bias
+
+    def mlp(self, enable_training=False):
+        intermediate_ff = self.client_module.ffn.lin1
+
+        return intermediate_ff.weight, intermediate_ff.bias, \
+            self.client_module.ffn.lin2.weight, \
+            self.client_module.ffn.lin2.bias
+
+    def layernorm(self):
+        attention_layernorm = self.client_module.sa_layer_norm
+        transformer_layernorm = self.client_module.output_layer_norm
+        return attention_layernorm.weight, \
+               attention_layernorm.bias, \
+               transformer_layernorm.weight, \
+               transformer_layernorm.bias

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

@@ -0,0 +1,9 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .gated_mlp import HybridGatedMLPContainer
+from .megatron import MegatronContainer
+from .meta_tensor import MetaTensorContainer
+from .split_qkv import HybridSplitQKVContainer